In [1]:

    

from Parser import Parser
from Lexer import Lexer


    

In [2]:

    

import pydot
from cStringIO import StringIO

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

def to_image(graph):
    pd = pydot.graph_from_dot_data(graph.to_dot())[0]
    png_str = pd.create_png(prog='dot')
    sio = StringIO()
    sio.write(png_str)
    sio.seek(0)
    img = mpimg.imread(sio)
    width = 12
    height = 12
    # plot the image
    plt.figure(figsize=(width, height))
    imgplot = plt.imshow(img, aspect='equal')
    plt.show(block=False)


    

In [3]:

    

import random
from tqdm import tqdm

p = Parser(Lexer(open('LoZ_test.txt').read()))
p.parse()
print p.startGraph


def vertex_equals(x,y):
    #is_good = (x.label == y.label or 'WILDCARD' in x.label or 'WILDCARD' in y.label)
    #print x, ' == ', y, '?', is_good ,'{',x.label == y.label , 'WILDCARD' in x.label , 'WILDCARD' in y.label,'}'
    return (x.label == y.label or 'WILDCARD' in x.label or 'WILDCARD' in y.label)

def is_good(graph,config):
    v_count = len(graph.vertices)
    min_v = int(config.get('min_vertices',0))
    max_v = int(config.get('max_vertices',999))
    print v_count, min_v, max_v
    if v_count < min_v:
        print 'Too Small', v_count ,' < ', min_v, v_count < min_v
        return False
    if v_count > max_v:
        print 'Too Big', v_count ,' > ', max_v
        return False
    for v in graph.vertices:
        if v.label[0].isupper():
            
            print 'Non Terminal', v
            return False
    for v in graph.edges:
        if len(v.label) > 0:
            if v.label[0].isupper():

                print 'Non Terminal', v
                return False
    return True

def apply_rules(start,productions,config):
    
    cloned = start.clone()
    path = []
    while not is_good(cloned,config):
        cloned = start.clone()
        #to_image(cloned)
        acceptable = []
        for rule in productions:
            #print rule
            matches = rule.find_matches(cloned,vertex_equals=vertex_equals)
            #print matches
            if len(matches) > 0:
                acceptable.append((rule,matches))
        path = []
        while len(acceptable) > 0:
            rule, matches = random.choice(acceptable)
            match = random.choice(matches)
            print ' '.join([str(m) for m in match])
            #print len(matches)
            #print '\nBEFORE:\n',cloned
            print 'Applying ', rule
            path.append(rule)
            rule.apply_to(cloned,match)
            to_image(cloned)
            
            #if len(cloned.vertices) > config.get('max_vertices',float('inf')):
            #    break
            #print '\nAFTER:\n',cloned
            acceptable = []
            for rule in productions:
                #print '\nRule LHS\n',rule.lhs
                #print 'Rule RHS\n',rule.rhs
                matches = rule.find_matches(cloned,vertex_equals=vertex_equals)
                if len(matches) > 0:
                    acceptable.append((rule,matches))
        to_image(cloned)
        break
    print 'GOOD'
    return cloned,path
paths = []

reverse_productions = [r.reverse() for r in p.productions]

for ii in tqdm(range(1)):
    cloned,path = apply_rules(p.startGraph,reverse_productions,{'max_vertices':1})
    to_image(cloned)
    paths.append(path)
    #destroyed,path = apply_rules(cloned,reverse_productions)
    #to_image(destroyed)
    #while len(destroyed.vertices) > 1:
    #    destroyed,path = apply_rules(cloned,reverse_productions)
    #    to_image(destroyed)


    

    




  0%|          | 0/1 [00:00<?, ?it/s]





    




vertex: ek17
vertex: b15
vertex: ekp12
vertex: ei13
vertex: ek5
vertex: empty8
vertex: empty0
vertex: e14
vertex: ek3
vertex: ei9
vertex: ekeyitem1
vertex: ek16
vertex: e4
vertex: e10
vertex: p18
vertex: keyitem2
vertex: t11
vertex: ek6
vertex: s7
edge: ek17-k->b15
edge: ekp12-->ei13
edge: ek5-->empty8
edge: empty0-->e14
edge: ek3-->ei9
edge: ekeyitem1-->ek17
edge: ekeyitem1-->ei13
edge: ei13-->ekp12
edge: ekp12-k->ek16
edge: empty8-k->e4
edge: ek3-->e4
edge: ek3-l->e10
edge: ek16-k->p18
edge: keyitem2-l->p18
edge: b15-l->ek17
edge: ek16-->ekp12
edge: ei9-b->ekeyitem1
edge: empty8-->ek5
edge: p18-l->keyitem2
edge: e14-->ei13
edge: p18-->ek16
edge: ei13-k->ekeyitem1
edge: ek3-b->ei13
edge: e14-->empty0
edge: b15-->t11
edge: e14-->e10
edge: ei13-->e14
edge: ekeyitem1-b->ei9
edge: e4-->ek3
edge: empty8-->ek6
edge: e4-->empty8
edge: s7-->empty8
edge: ei9-->ek3
edge: ei13-b->ek3
edge: e10-->ek3
edge: e10-k->e14
edge: t11-l->b15
edge: ek6-->empty8
edge: empty8-->s7
edge: ek17-->ekeyitem1

19 0 1
Too Big 19  >  1
p18
Applying  RULE:
vertex: p1

=>
vertex: HasChallenge1








    













    




keyitem2
Applying  RULE:
vertex: keyitem1

=>
vertex: Keyitem1








    













    




ei9
Applying  RULE:
vertex: ei1

=>
vertex: HasChallenge1








    













    




empty0
Applying  RULE:
vertex: empty1

=>
vertex: Middle1








    













    




ei13
Applying  RULE:
vertex: ei1

=>
vertex: HasChallenge1








    













    




Keyitem2 HasChallenge18
Applying  RULE:
vertex: WILDCARD1
vertex: WILDCARD2
edge: WILDCARD1-l->WILDCARD2

=>
vertex: WILDCARD1
vertex: WILDCARD2
edge: WILDCARD1-->WILDCARD2








    













    




HasChallenge13
Applying  RULE:
vertex: HasChallenge1

=>
vertex: Middle1








    













    




e10
Applying  RULE:
vertex: e1

=>
vertex: HasChallenge1








    













    




empty8
Applying  RULE:
vertex: empty1

=>
vertex: Middle1








    













    




ek17
Applying  RULE:
vertex: ek1

=>
vertex: HasKey1








    













    




e14
Applying  RULE:
vertex: e1

=>
vertex: HasChallenge1








    













    




ek3
Applying  RULE:
vertex: ek1

=>
vertex: HasKey1








    













    




HasChallenge18
Applying  RULE:
vertex: HasChallenge1

=>
vertex: Middle1








    













    




HasKey3 HasChallenge10
Applying  RULE:
vertex: WILDCARD1
vertex: WILDCARD2
edge: WILDCARD1-l->WILDCARD2

=>
vertex: WILDCARD1
vertex: WILDCARD2
edge: WILDCARD1-->WILDCARD2








    













    




ekp12
Applying  RULE:
vertex: ekp1

=>
vertex: HasKey1








    













    




ek16
Applying  RULE:
vertex: ek1

=>
vertex: HasKey1








    













    




Keyitem2
Applying  RULE:
vertex: Keyitem1

=>
vertex: Middle1








    













    




ek5
Applying  RULE:
vertex: ek1

=>
vertex: HasKey1








    













    




Middle8 e4 HasKey5
Applying  RULE:
vertex: Middle1
vertex: WILDCARD2
vertex: HasKey3
edge: Middle1-k->WILDCARD2
edge: Middle1-->HasKey3
edge: WILDCARD2-->Middle1
edge: HasKey3-->Middle1

=>
vertex: Middle1
vertex: WILDCARD2
edge: Middle1-->WILDCARD2
edge: WILDCARD2-->Middle1








    




---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-3-5487cc6634a8> in <module>()
     81 
     82 for ii in tqdm(range(1)):
---> 83     cloned,path = apply_rules(p.startGraph,reverse_productions,{'max_vertices':1})
     84     to_image(cloned)
     85     paths.append(path)

<ipython-input-3-5487cc6634a8> in apply_rules(start, productions, config)
     59             print 'Applying ', rule
     60             path.append(rule)
---> 61             rule.apply_to(cloned,match)
     62             to_image(cloned)
     63 

/home/adam/TheRecipeOfZelda/Graph.py in apply_to(self, graph, match, vertex_equals, edge_equals)
    241         for v in self.to_delete:
    242             #print 'deleting',v
--> 243             graph.remove_vertex(mapping[v],self.prune)
    244 
    245         for v in self.lhs_to_rhs:

/home/adam/TheRecipeOfZelda/Graph.py in remove_vertex(self, v, prune)
     65         return None
     66     def remove_vertex(self,v,prune=True):
---> 67         graph.rectify_edges()
     68 
     69         into = []

NameError: global name 'graph' is not defined

In [ ]:

    

p = Parser(Lexer(open('Test1.txt').read()))
p.parse()
print p.startGraph

cloned = p.startGraph.clone()

rule = p.productions[3]
    #print rule
matches = rule.find_matches(cloned,vertex_equals=vertex_equals)
match = random.choice(matches)
rule.apply_to(cloned,match)
print cloned


    

In [ ]:

    

import itertools
possibles = [range(2),['a','b']]
for p in itertools.product(*possibles):
    print p


    

In [ ]: