#RobustFillPrimitives from dreamcoder.program import Primitive, prettyProgram from dreamcoder.grammar import Grammar from dreamcoder.type import tint, arrow, baseType #, t0, t1, t2 from string import printable import re from collections import defaultdict #from functools import reduce disallowed = [ ("#", "hash"), ("!", "bang"), ("\"", "double_quote"), ("$", "dollar"), ("%", "percent"), ("&", "ampersand"), ("'", "single_quote"), (")", "left_paren"), ("(", "right_paren"), ("*", "astrisk"), ("+", "plus"), (",", "comma"), ("-", "dash"), (".", "period"), ("/", "slash"), (":", "colon"), (";", "semicolon"), ("<", "less_than"), ("=", "equal"), (">", "greater_than"), ("?", "question_mark"), ("@", "at"), ("[", "left_bracket"), ("\\", "backslash"), ("]", "right_bracket"), ("^", "carrot"), ("_", "underscore"), ("`", "backtick"), ("|", "bar"), ("}", "right_brace"), ("{", "left_brace"), ("~", "tilde"), (" ", "space"), ("\t", "tab") ] disallowed = dict(disallowed) delimiters = "&,.?!@()[]%{/}:;$#\"'" delim_dict = {disallowed[c]:c for c in delimiters} types = {} types["Number"] = r'\d+' types["Word"] = r'\w+' types["Alphanum"] = r'\w' types["PropCase"] = r'[A-Z][a-z]+' types["AllCaps"] = r'[A-Z]' types["Lower"] = r'[a-z]' types["Digit"] = r'\d' types["Char"] = r'.' regexes = {name: re.escape(val) for name, val in delim_dict.items()} regexes = {**regexes, **types} tposition = baseType("position") tindex = baseType("index") tcharacter = baseType("character") tboundary = baseType("boundary") tregex = baseType("regex") tsubstr = baseType("substr") texpression = baseType("expression") tprogram = baseType("program") tnesting = baseType("nesting") ttype = baseType("type") tdelimiter = baseType("delimiter") def _substr(k1): return lambda k2: lambda string: string[k1:k2] #i think this is fine def _getspan(r1): return lambda i1: lambda b1: lambda r2: lambda i2: lambda b2: lambda string: \ string[ [m.end() for m in re.finditer(r1, string)][i1] if b1 == "End" else [m.start() for m in re.finditer(r1, string)][i1]:[m.end() for m in re.finditer(r2, string)][i2] if b2 == "End" else [m.start() for m in re.finditer(r2, string)][i2] ] #TODO format correctly def _getspan_const(r1): return lambda i1: lambda b1: lambda r2: lambda i2: lambda b2: (defaultdict(int, {r1:i1+1 if i1>=0 else abs(i1), r2:i2+1 if i2>=0 else abs(i2)}), max(i1+1 if i1>=0 else abs(i1), i2+1 if i2>=0 else abs(i2))) def _trim(string): assert False return string def _replace(d1, d2): return lambda string: string.replace(d1,d2) def _getall(tp): return lambda string: ''.join(re.findall(tp, string)) def _getfirst(tp, i): return lambda string: ''.join(re.findall(tp, string)[:i]) def _gettoken(tp, i): return lambda string: re.findall(tp, string)[i] def _gettoken_const(tp, i): return defaultdict(int, {tp: i+1 if i>=0 else abs(i)}), i+1 if i>=0 else abs(i) def _getupto(reg): return lambda string: string[:[m.end() for m in re.finditer(reg, string)][0]] def _getfrom(reg): return lambda string: string[[m.end() for m in re.finditer(reg, string)][-1]:] def _concat2(expr1): return lambda expr2: lambda string: expr1(string) + expr2(string) #More concats plz def _concat1(expr): return lambda string: expr(string) def _concat_list(expr): return lambda program: lambda string: expr(string) + program(string) #i've decided that all of the things which are expressions should take tstring as last input and output a tstring. Thus, all requests are arrow(tstring, tstring) and we limit size with recursive depth """ todo: - _trim - incorporate tcharacter - constraints - format _getspan - figure out how to represent on top_level - flatten for nn - parse - robustfill_util - train dc model for robustfill - main_supervised_robustfill - evaluate_robustfill - sample_data - deal with escapes ... constraints: elements, and number necessary, and lengths """ def robustFillPrimitives(max_len=100, max_index=5): return [ #CPrimitive("concat2", arrow(texpression, texpression, tprogram), _concat2), CPrimitive("concat1", arrow(texpression, tprogram), _concat1), CPrimitive("concat_list", arrow(texpression, tprogram, tprogram), _concat_list), #expressions CPrimitive("Constant", arrow(tcharacter, texpression), lambda x: lambda y: x), # add a constraint CPrimitive("apply", arrow(tnesting, tsubstr, texpression), lambda n: lambda sub: lambda string: n(sub(string))), CPrimitive("apply_n", arrow(tnesting, tnesting, texpression), lambda n1: lambda n2: lambda string: n1(n2(string))), CPrimitive("expr_n", arrow(tnesting, texpression), lambda x: x), CPrimitive("expr_f", arrow(tsubstr, texpression), lambda x: x) ] + [ #substrings CPrimitive("SubStr", arrow(tposition, tposition, tsubstr), _substr), # handled CPrimitive("GetSpan", arrow(tregex, tindex, tboundary, tregex, tindex, tboundary, tsubstr), _getspan, _getspan_const) #TODO constraint ] + [ #nestings CPrimitive("GetToken"+name+str(i), tnesting, _gettoken(tp,i), _gettoken_const(tp, i)) for name, tp in types.items() for i in range(-max_index, max_index) ] + [ CPrimitive("ToCase_ProperCase", tnesting, lambda x: x.title(), (defaultdict(int, {r'[A-Z][a-z]+':1}), 1)), CPrimitive("ToCase_AllCapsCase", tnesting, lambda x: x.upper(), (defaultdict(int, {r'[A-Z]':1}) ,1)), CPrimitive("ToCase_LowerCase", tnesting, lambda x: x.lower(), (defaultdict(int, {r'[a-z]':1}), 1) ) ] + [ CPrimitive("Replace_"+name1+name2, tnesting, _replace(char1, char2), (defaultdict(int, {char1:1}), 1)) for name1, char1 in delim_dict.items() for name2, char2 in delim_dict.items() if char1 is not char2 ] + [ #CPrimitive("Trim", tnesting, _trim), #TODO ] + [ CPrimitive("GetUpTo"+name, tnesting, _getupto(reg), (defaultdict(int, {reg:1} ),1)) for name, reg in regexes.items() ] + [ CPrimitive("GetFrom"+name, tnesting, _getfrom(reg), (defaultdict(int, {reg:1} ),1)) for name, reg in regexes.items() ] + [ CPrimitive("GetFirst_"+name+str(i), tnesting, _getfirst(tp, i), (defaultdict(int, {tp:i} ), i+1 if i>=0 else abs(i))) for name, tp in types.items() for i in list(range(-max_index,0))+ list(range(1,max_index+1)) ] + [ CPrimitive("GetAll_"+name, tnesting, _getall(reg),(defaultdict(int, {reg:1} ),1) ) for name, reg in types.items() ] + [ #regexes CPrimitive("type_to_regex", arrow(ttype, tregex), lambda x: x), #TODO also make disappear CPrimitive("delimiter_to_regex", arrow(tdelimiter, tregex), lambda x: re.escape(x)) #TODO also make disappear ] + [ #types CPrimitive("Number", ttype, r'\d+', r'\d+'), #TODO CPrimitive("Word", ttype, r'\w+', r'\w+'), #TODO CPrimitive("Alphanum", ttype, r'\w', r'\w'), #TODO CPrimitive("PropCase", ttype, r'[A-Z][a-z]+', r'[A-Z][a-z]+'), #TODO CPrimitive("AllCaps", ttype, r'[A-Z]', r'[A-Z]'), #TODO CPrimitive("Lower", ttype, r'[a-z]', r'[a-z]'), #TODO CPrimitive("Digit", ttype, r'\d', r'\d'), #TODO CPrimitive("Char", ttype, r'.', r'.') #TODO ] + [ #Cases # CPrimitive("ProperCase", tcase, .title()), #TODO # CPrimitive("AllCapsCase", tcase, .upper()), #TODO # CPrimitive("LowerCase", tcase, .lower()) #TODO ] + [ #positions CPrimitive("position"+str(i), tposition, i, (defaultdict(int), i+1 if i>=0 else abs(i)) ) for i in range(-max_len,max_len+1) #deal with indicies ] + [ #indices CPrimitive("index"+str(i), tindex, i, i) for i in range(-max_index,max_index+1) #deal with indicies ] + [ #characters CPrimitive(i, tcharacter, i, (defaultdict(int, {i:1}),1) ) for i in printable[:-5] if i not in disallowed ] + [ CPrimitive(name, tcharacter, char, (defaultdict(int, {char:1}), 1)) for char, name in disallowed.items() # NB: disallowed is reversed ] + [ #delimiters CPrimitive("delim_"+name, tdelimiter, char, char) for name, char in delim_dict.items() ] + [ #boundaries CPrimitive("End", tboundary, "End"), CPrimitive("Start", tboundary, "Start") ] def RobustFillProductions(max_len=100, max_index=5): return [(0.0, prim) for prim in robustFillPrimitives(max_len=max_len, max_index=max_index)] def flatten_program(p): string = p.show(False) string = string.replace('(', '') string = string.replace(')', '') #remove '_fn' (optional) string = string.split(' ') string = list(filter(lambda x: x is not '', string)) return string def add_constraints(c1, c2=None): if c2 is None: return c1 d1, m1 = c1 d2, m2 = c2 min_size = max(m1, m2) d = defaultdict(int) for item in set(d1.keys()) | set(d2.keys()): d[item] = max(d1[item], d2[item]) return d, min_size # class Constraint_prop: # def application(self, p, environment): # self.f.visit(self, environment)(self.x.visit(self, environment)) # def primitive(self, p, environment): # return self.value class Constraint_prop: def __init__(self): pass def application(self, p): return p.f.visit(self)(p.x.visit(self)) def primitive(self, p): return p.constraint def execute(self, p): return p.visit(self) class CPrimitive(Primitive): def __init__(self, name, ty, value, constraint=None): #I have no idea why this works but it does ..... if constraint is None: if len(ty.functionArguments())==0: self.constraint = (defaultdict(int), 0) elif len(ty.functionArguments())==1: self.constraint = lambda x: x elif len(ty.functionArguments())==2: self.constraint = lambda x: lambda y: add_constraints(x,y) else: self.constraint = lambda x: x for _ in range(len(ty.functionArguments()) - 1): self.constraint = lambda x: lambda y: add_constraints(x, self.constraint(y)) else: self.constraint = constraint super(CPrimitive, self).__init__(name, ty, value) #def __getinitargs__(self): # return (self.name, self.tp, self.value, None) def __getstate__(self): #print("self.name", self.name) return self.name def __setstate__(self, state): #for backwards compatibility: if type(state) == dict: pass #do nothing, i don't need to load them if they are old... else: p = Primitive.GLOBALS[state] self.__init__(p.name, p.tp, p.value, p.constraint) if __name__=='__main__': import time CPrimitive("testCPrim", tint, lambda x: x, 17) g = Grammar.fromProductions(RobustFillProductions()) print(len(g)) request = tprogram p = g.sample(request) print("request:", request) print("program:") print(prettyProgram(p)) s = 'abcdefg' e = p.evaluate([]) #print("prog applied to", s) #print(e(s)) print("flattened_program:") flat = flatten_program(p) print(flat) t = time.time() constraints = Constraint_prop().execute(p) print(time.time() - t) print(constraints)