2

I am trying to rewrite the following piece of python code which generates the current output below 

 import json
 import re

 jsoninput = open("input.json").read()
 data = json.loads(jsoninput)
 dictat = {}
 dicvalue = {}
 def ev_declaration(line):
     tree = line['declared-variable']
     re.match ("x", line['declared-variable'])
     value = ev_value(line['value'])
     if line['declared-variable'] not in dictat.keys():
         dictat.update({line['declared-variable']:(value)})
     dicvalue.update({tree: (value)})
     return 'let ',tree ,value

 def ev_expression(line):
     if line['operator'] == 'set':
         args = [ev_value(a) for a in line['arguments']]
         try:
             return set(args)
         except:
             return (args)
     elif line['operator']== 'tuple':
         args = [ev_value(b) for b in line['arguments']]
         return (tuple(x for x in args))
     elif line['operator']=='equal':
         args = [ev_value(a) for a in line['arguments']]
         if args[0] == args[1]:
             return 1
         else:
             return 0
     elif line['operator']=='member':
         args = line['arguments']
         if ev_value(args[0]) in ev_value(args[1]):
             return 1
         else:
             return 0
     else:
         print ("Undefined!")

 def ev_value(line):
     try:
         if type(line) is int:
             return line
         elif type(line) is set:
             return line
         elif 'operator' in line:
             return ev_expression(line)
         elif 'variable' in line:
             if line['variable'] not in dictat.keys():
                 return 'undefined'
             if line['variable'] in dictat.keys():
                 return dictat[line['variable']]

     except TypeError:
         return ('be ', line)

 def output_tree(data):
     declaration_list = data['declaration-list']
     with open("output.txt","w")as outputfile:
         for i in declaration_list:
                 ev_declaration(i)
                 #json.dump(dicvalue,outputfile)
                 outputfile.write(';\n')
     with open("output.txt","w")as outputfile:
         for i in dicvalue:
             if i is not None:
                 temp = dicvalue[i]
                 print "let", i, "be", temp
     print dicvalue

 if __name__ == "__main__":
     output_tree(data)

as the following,

 import json
 import re

 jsoninput = open("input.json").read()
 data = json.loads(jsoninput)
 dictat = {}
 dicvalue = {}
 def parse_declaration(valinfo):
     tree = valinfo['declared-variable']
     re.match ("x", valinfo['declared-variable'])
     value = parse_rvalue(valinfo['value'])
     if valinfo['declared-variable'] not in dictat.keys():
         dictat.update({valinfo['declared-variable']:(value)})
     dicvalue.update({tree: (value)})
     return ('let ',tree ,value)


#def ev_expression(valinfo):
    #opfunc = _rv_parser[valinfo['operator']]
    #return opfunc(valinfo)

 def _rv_parse_set(valinfo):
     assert valinfo['operator'] == 'set'
     args = [parse_rvalue(a) for a in valinfo['arguments']]
     try:
         return set(args)
     except:
         return (args)

 def _rv_parse_equal(valinfo):
     assert valinfo['operator']=='equal'
     args = [parse_rvalue(a) for a in valinfo['arguments']]
     if args[0] == args[1]:
         return 1
     else:
         return 0   

 def _rv_parse_tuple(valinfo):
     assert valinfo['operator']== 'tuple'
     args = [parse_rvalue(b) for b in valinfo['arguments']]
     return (tuple(x for x in args))

 def _rv_parse_member(valinfo):
     assert valinfo['operator']=='member'
     args = valinfo['arguments']
     if parse_rvalue(args[0]) in parse_rvalue(args[1]):
         return 1
     else:
         return 0

_rv_parser = {
    "set": _rv_parse_set,
    "tuple":_rv_parse_tuple,
    "equal":_rv_parse_equal,
    "member":_rv_parse_member,
}

 def parse_rvalue(valinfo):
     try:
         if type(valinfo) is int:
             return valinfo
         elif type(valinfo) is set:
             return valinfo
         elif 'operator' in valinfo:
             return ev_expression(valinfo)
         elif 'variable' in valinfo:
             if valinfo['variable'] not in dictat.keys():
                 return 'undefined'
             if valinfo['variable'] in dictat.keys():
                 return dictat[valinfo['variable']]

     except TypeError:
         return ('be ', valinfo)


 def parse_json(data):
     declaration_list = data['declaration-list']
     with open("output.txt","w")as outputfile:
         for i in declaration_list:
                 parse_declaration(i)
                #json.dump(dicvalue,outputfile)
                 outputfile.write(';\n')
     with open("output.txt","w")as outputfile:
         for i in dicvalue:
             if i is not None:
                 temp = dicvalue[i]
                 print "let", i, "be", temp
     print dicvalue

 if __name__ == "__main__":
     parse_json(data)

like to know if i'm doing this correctly and if not, how to go about fixing it? as it doesn't seem to be working. do i need to declare a def ev_expression(line) as well? The first code parsecs the input below as json and is supposed to return the expected below. It mostly works in my first code above, but i'm trying to refactor to make it a bit clearer as well output to a text file instead of printing to the terminal

Current Output

 Undefined!
 Undefined!
 Undefined!
 Undefined!
 let x5 be None #should be Undefined
 let x13 be 0
 let x7 be None #should be Undefined
 let x19 be ([set([8, 1, 2]), (1, set([8, 1, 2]))], set([8, 1, 2]))
 let x14 be 1
 let x15 be 1
 let x18 be [set([8, 1, 2]), (1, set([8, 1, 2]))]
 let x2 be set([1, 2])
 let x8 be ((0, 1), (3, (4, 5)))
 let x9 be set([((0, 1), (3, (4, 5)))])
 let x4 be None #should be undefined
 let x11 be None #should be undefined
 let x10 be set([(1, 6), (0, 4)])
 let x3 be set([(1, 2), (3, 4)])
 let x0 be 1
 let x1 be 2
 let x6 be 1
 let x12 be -1
 let x16 be 8
 let x17 be set([8, 1, 2])

Expected Output

 let x0 be 1;
 let x1 be 2;
 let x2 be {1, 2};
 let x3 be {(1, 2), (3, 4)};
 let x6 be 1;
 let x8 be ((0, 1), (3, (4, 5)));
 let x9 be {((0, 1), (3, (4, 5)))};
 let x10 be {(0, 4), (1, 6)};
 let x12 be -1;
 let x13 be 0;
 let x14 be 1;
 let x15 be 1;
 let x16 be 8;
 let x17 be {1, 2, 8};
 let x18 be {{1, 2, 8}, (1, {1, 2, 8})};
 let x19 be ({{1, 2, 8}, (1, {1, 2, 8})}, {1, 2, 8});
 Undefined!
 Undefined!
 Undefined!
 Undefined!
 Undefined!
 Undefined!
 Undefined!
 Undefined!
 Undefined!

and input

{
"declaration-list": [{
    "declared-variable": "x0",
    "value": 1
}, {
    "declared-variable": "x1",
    "value": 2
}, {
    "declared-variable": "x2",
    "value": {
        "operator": "set",
        "arguments": [{
            "variable": "x0"
        }, {
            "variable": "x1"
        }]
    }

although the python program parses the input from a json file

Improve this question
8
  • 3
    You should add sample input, expected output and actual output. Commented Feb 18, 2016 at 23:46
  • Welcome to StackOverflow. Please read and follow the posting guidelines in the help documentation. Minimal, complete, verifiable example applies here. We cannot effectively help you until you post your code and accurately describe the problem. Commented Feb 19, 2016 at 0:04
  • @prune, i did post both complete codes yesterday, but it got taken down.. i have added the samples as asked Commented Feb 19, 2016 at 0:52
  • Thanks. All we're missing now is the code that produced that output. There's no main program in your posted code. Commented Feb 19, 2016 at 0:53
  • @prune done... hope its not too code heavy Commented Feb 19, 2016 at 1:07

1 Answer 1

Reset to default
2

Yes, you still need a declaration for ev_expression, unless you also refactor it out. You will probably want a dict mapping the various operators to the functions. Something like:

op_funcs = {
    'set' : _rv_parse_set,
    'tuple' : _rv_parse_tuple,
    ...
}

Then your code would look like:

def ev_expression(line):
    opfunc = op_funcs[line['operator']]
    return opfunc(line)

EDIT

Okay, after your updates I added a MySet class to your code. This will format the way you want, and otherwise pretend to be a set.

import json
import re

class MySet:
    def __init__(self, *args):
        self._set = set(*args)

    def __contains__(self, x):
        return x in self._set

    def __repr__(self):
        return str(self)

    def __str__(self):
        return '{' + ', '.join((str(x) for x in self._set)) + '}'

dictat = {}
dicvalue = {}

def parse_declaration(valinfo):
    tree = valinfo['declared-variable']
    re.match ("x", valinfo['declared-variable'])
    value = parse_rvalue(valinfo['value'])
    if valinfo['declared-variable'] not in dictat.keys():
        dictat.update({valinfo['declared-variable']:(value)})
    dicvalue.update({tree: (value)})
    return ('let ',tree ,value)

def _rv_parse_apply_function(valinfo):
    assert valinfo['operator'] == 'apply-function'
    args = [parse_rvalue(a) for a in valinfo['arguments']]
    return "apply_function(" + ', '.join((str(a) for a in args)) + ")"

def _rv_parse_equal(valinfo):
    assert valinfo['operator']=='equal'
    args = [parse_rvalue(a) for a in valinfo['arguments']]
    return int(args[0] == args[1])

def _rv_parse_is_function(valinfo):
    assert valinfo['operator'] == 'is-function'
    args = [parse_rvalue(a) for a in valinfo['arguments']]
    return "is_function(" + ', '.join((str(a) for a in args)) + ")"

def _rv_parse_set(valinfo):
    assert valinfo['operator'] == 'set'
    args = [parse_rvalue(a) for a in valinfo['arguments']]
    try:
        #return set(args)
        return MySet(args)
    except:
        return args

def _rv_parse_tuple(valinfo):
    assert valinfo['operator']== 'tuple'
    args = [parse_rvalue(b) for b in valinfo['arguments']]
    return (tuple(x for x in args))

def _rv_parse_member(valinfo):
    assert valinfo['operator']=='member'
    args = [parse_rvalue(a) for a in valinfo['arguments']]
    return int(args[0] in args[1])

_rv_parser = {
    "apply-function": _rv_parse_apply_function,
    "equal":          _rv_parse_equal,
    "is-function":    _rv_parse_is_function,
    "set":            _rv_parse_set,
    "tuple":          _rv_parse_tuple,
    "member":         _rv_parse_member,
}

def parse_rvalue(valinfo):
#    try:
        if type(valinfo) is int:
            return valinfo
        elif type(valinfo) is set:
            return valinfo
        elif 'operator' in valinfo:
            opfunc = _rv_parser[valinfo['operator']]
            return opfunc(valinfo)
        elif 'variable' in valinfo:
            if valinfo['variable'] not in dictat.keys():
                return 'undefined'
            if valinfo['variable'] in dictat.keys():
                return dictat[valinfo['variable']]
#    except TypeError:
#        return ('be ', valinfo)


def parse_json(data):
    declaration_list = data['declaration-list']
    for i in declaration_list:
        parse_declaration(i)

    for i in sorted(dicvalue, key=lambda s: int(s[1:])):
        if i is not None:
            temp = str(dicvalue[i])
            print "let", i, "be", temp

if __name__ == "__main__":
    jsoninput = open("input.json").read()
    data = json.loads(jsoninput)
    parse_json(data)
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

have a look at the above
You are showing json code, but asking for help with a text-parsing program. So it's not like you'll get a lot of good answers. But it looks like parse_declaration just tries to store value into the dictionaries, rather than parsing or evaluating it.
just added the full json

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.