dreamcoder/domains/misc/RobustFillPrimitives.py

#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)