def call(self, args, keywords, starargs, context, dryrun, orig_args):
assert isinstance(orig_args[0], _ast.Str)
assert args[0] == Union(STR)
if args[1] == Union.EMPTY:
context.log_error("no metadata specified")
return Union.EMPTY
assert args[1] == Union(MetaData.instance()), (args[1].display(),
args[1].types())
cols = []
for a in args[2:]:
if not a.types():
return Union.EMPTY
assert len(a.types()) == 1
t, = a.types()
assert isinstance(t, ColumnType)
cols.append(t)
t = context.get_cached(self.call)
if not t:
t = TableType(orig_args[0].s, cols)
context.set_cached(self.call, t)
else:
assert t._cols == cols, (t._cols, cols)
return Union(t)
def _fetchall_rtn(args, keywords, starargs, context, dryrun, orig_args):
r = args[0].types()[0]
assert isinstance(r, ResultProxyType)
t = context.get_cached(_fetchall_rtn)
if not t:
t = InstanceType(ListClass, [Union(r._rptype)])
context.set_cached(_fetchall_rtn, t)
return Union(t)
def __init__(self, cols):
assert cols, cols
assert isinstance(cols, list), cols
super(ExpressionType, self).__init__(Expression, [])
self._cols = cols
f = FixedFunction([ANY], FixedArg(Union(self)), ndefaults=1)
for n in ("order_by", "limit", "asc", "desc", "not_", "null",
"group_by", "offset"):
self.setattr(n, Union(f))
def _select_rtn(args, keywords, starargs, context, dryrun, orig_args):
if args[0] == Union.EMPTY:
context.log_error("Don't know what this is a select of")
return Union.EMPTY
l = args[0].types()[0]
if not isinstance(l, InstanceType):
context.log_error("Passed in a '%s'?" % (l.display(), ))
return Union.EMPTY
if l.cls is ListClass:
if l.unions[0] == Union.EMPTY:
context.log_error("Passed in an empty list of columns")
return Union.EMPTY
cols = list(l.unions[0].types())
elif l.cls is TupleClass:
# if not all(u.types() for u in l.unions):
# context.log_error("Passed in a potentially-undefined column")
# return Union.EMPTY
cols = [
u.types()[0] for u in l.unions
if u.types() and isinstance(u.types()[0], ColumnType)
]
if not cols:
context.log_error("Passed in no analyzable columns")
return Union.EMPTY
elif l.cls is Column:
cols = [l]
elif l.cls is ColumnCollection:
cols = list(l._cols)
assert all(isinstance(c, ColumnType) for c in cols), cols
else:
raise Exception(l.cls.name)
assert cols
for c in cols:
if not isinstance(c, ColumnType):
context.log_error("Passed in '%s' instead of a column?" %
(c.display(), ))
return Union.EMPTY
t = context.get_cached(_select_rtn)
if not t:
t = ExpressionType(cols)
context.set_cached(_select_rtn, t)
else:
if cols != t._cols:
context.log_error(
"don't pass in different columns, can't analyze that")
return Union(TOP)
return Union(t)
def _table_select_rtn(args, keywords, starargs, context, dryrun, orig_args):
t = args[0].types()[0]
r = context.get_cached(_table_select_rtn)
if not r:
r = ExpressionType(t._cols)
context.set_cached(_table_select_rtn, r)
else:
if r._cols != t._cols:
context.log_error(
"don't pass in different tables, can't analyze that")
return Union(TOP)
return Union(r)
def __init__(self, cols):
for c in cols:
assert isinstance(c, ColumnType)
super(ColumnCollectionType, self).__init__(ColumnCollection, [])
for c in cols:
self.setattr(c._name, Union(c))
self._cols = cols
def _execute_rtn(args, keywords, starargs, context, dryrun, orig_args):
if starargs:
context.log_error("why??")
return Union.EMPTY
c = args[0].types()[0]
assert isinstance(c, InstanceType)
assert c.cls in (Connection, Engine)
if len(args[1].types()) != 1:
context.log_error("bad first arg to execute")
return Union.EMPTY
a = args[1].types()[0]
if a is STR:
return Union(TOP)
if a is TOP:
return Union(TOP)
if isinstance(a, InstanceType):
if a.cls is ListClass:
cols = []
for t in a.unions[0].types():
if isinstance(t, ColumnType):
cols.append(t)
elif a.cls is Expression:
cols = a._cols
elif a.cls is TupleClass:
cols = [u.types()[0] for u in a.unions]
elif a.cls is Column:
cols = [a]
else:
context.log_error("don't understand argument: %s" %
(a.display(), ))
return Union.EMPTY
else:
context.log_error("didn't expect a %s" % (a.display(), ))
return Union.EMPTY
t = context.get_cached(_execute_rtn)
if not t:
t = ResultProxyType(cols)
context.set_cached(_execute_rtn, t)
else:
assert t._cols == cols
return Union(t)
def _mapper_rtn(args, keywords, starargs, context, dryrun, orig_args):
if args[0] == Union.EMPTY or args[1] == Union.EMPTY:
return Union.EMPTY
cls = args[0].types()[0]
table = args[1].types()[0]
for col in table._cols:
cls.setattr(col._name, Union(col._type._t))
return Union.EMPTY
def __init__(self, cols):
assert cols, cols
assert isinstance(cols, list), cols
for c in cols:
assert isinstance(c, ColumnType)
super(RowProxyType, self).__init__(RowProxy, [])
self._cols = cols
for c in cols:
self.setattr(c._name, Union(c._type._t))
def call(self, args, keywords, starargs, context, dryrun, orig_args):
assert isinstance(orig_args[0], _ast.Str)
assert args[0] == Union(STR)
t = context.get_cached(self.call)
if not t:
if args[1] == Union.EMPTY:
context.log_error("no column type specified")
return Union.EMPTY
t = ColumnType(orig_args[0].s, args[1].types()[0], context)
context.set_cached(self.call, t)
else:
assert t._name == orig_args[0].s
assert isinstance(
args[1].types()[0],
FixedFunction) or t._type == args[1].types()[0], (
t._type, args[1].types()[0])
return Union(t)
def __init__(self, cols):
assert cols, cols
assert isinstance(cols, list), cols
for c in cols:
assert isinstance(c, ColumnType)
super(ResultProxyType, self).__init__(ResultProxy, [])
self._cols = cols
self.setattr(
"scalar",
Union(FixedFunction([], FixedArg(Union(cols[0]._type._t)))))
self._rptype = RowProxyType(self._cols)
self.setattr(
"__iter__",
Union(
FixedFunction([],
FixedArg(
Union(
InstanceType(Iterator,
[Union(self._rptype)]))))))
def __init__(self, name, cols):
assert isinstance(name, str)
for c in cols:
assert isinstance(c, ColumnType)
super(TableType, self).__init__(Table, [])
self._name = name
self._cols = cols
for c in cols:
c._table = self
col_collection = Union(ColumnCollectionType(cols))
self.setattr("c", col_collection)
self.setattr("columns", col_collection)
def _fetchone_rtn(args, keywords, starargs, context, dryrun, orig_args):
r = args[0].types()[0]
assert isinstance(r, ResultProxyType)
return Union(r._rptype)
translate_call,
_FuncArgsError,
get_iter_type,
Subtype,
InstanceArg,
Var,
FixedArg,
ANY,
BOT,
)
from icbd.type_analyzer.builtins import (BUILTINS, KNOWN_MODULES, make_class)
sqlalchemy = Module("sqlalchemy", "__builtin__")
schema = Module("schema", "__builtin__")
sqlalchemy.setattr("schema", Union(schema))
MetaData = UserClassType("MetaData", (ObjectClass, ))
class TableClassType(CustomClass):
def __init__(self):
super(TableClassType, self).__init__("Table")
def call(self, args, keywords, starargs, context, dryrun, orig_args):
assert isinstance(orig_args[0], _ast.Str)
assert args[0] == Union(STR)
if args[1] == Union.EMPTY:
context.log_error("no metadata specified")
return Union.EMPTY
assert args[1] == Union(MetaData.instance()), (args[1].display(),
def _load(e, fn):
generated = {}
type_map = {
"int64": Union(INT),
"int32": Union(INT),
"string": Union(STR),
"bytes": Union(STR),
"double": Union(FLOAT),
"bool": Union(BOOL),
}
with open(fn) as f:
stack = []
type_stack = []
field_names = []
for l in f:
if '//' in l:
l = l[:l.find('//')]
sp = l.split()
if not sp:
continue
if sp[0] == "message":
cls = Union(UserClassType(sp[1], (ObjectClass, )))
if stack:
type_stack[-1][sp[1]] = cls
stack[-1].setattr(sp[1], cls)
else:
generated[sp[1]] = cls
stack.append(cls)
type_stack.append({})
field_names.append([])
elif sp[0] in ("required", "optional", "repeated"):
t = None
for types in [type_map] + list(
reversed(type_stack)) + [generated]:
t = types.get(sp[1])
if t:
break
assert t, sp[1]
assert isinstance(t, Union)
name = sp[2]
if sp[0] == "repeated":
t = Union(InstanceType(ListClass, [t]))
stack[-1].setattr(name, t)
field_names[-1].append(name)
elif sp[0] == "enum":
assert stack
# stack[-1].setattr(sp[1], Union(INT))
type_stack[-1][sp[1]] = Union(INT)
stack.append(None)
type_stack.append(None)
field_names.append(None)
elif len(sp) >= 2 and sp[1] == '=':
assert stack[-1] is None
stack[-2].setattr(sp[0], Union(INT))
elif sp[0] == "}":
fields = field_names.pop()
c = stack.pop()
if isinstance(c, Union):
[c] = c.types()
field_types = [c._attributes[f] for f in fields]
args = []
for u in field_types:
assert len(u.types()) == 1
[t] = u.types()
if isinstance(t, UserClassType):
args.append(FixedArg(Union(t.instance())))
else:
args.append(FixedArg(u))
c.setattr(
"__init__",
Union(
FixedFunction([InstanceArg(c, [])] + args,
NONE,
ndefaults=len(field_types),
arg_names=["self"] + fields)))
type_stack.pop()
else:
raise Exception(l)
assert not stack
assert not type_stack
e.add_overrides(generated)
translate_call,
_FuncArgsError,
get_iter_type,
Subtype,
InstanceArg,
Var,
FixedArg,
ANY,
BOT,
)
from icbd.type_analyzer.builtins import (BUILTINS, KNOWN_MODULES, make_class)
pylons = Module("pylons", "__builtin__")
controllers = Module("controllers", "__builtin__")
pylons.setattr("controllers", Union(controllers))
WSGIController = UserClassType("WSGIController", (ObjectClass, ))
controllers.setattr("WSGIController", Union(WSGIController))
StackedObjectProxy = UserClassType("StackedObjectProxy", (ObjectClass, ))
class StackedObjectProxyType(CustomInstance):
def __init__(self):
super(StackedObjectProxyType, self).__init__(StackedObjectProxy, [])
def getattr(self, attr, context):
u = super(StackedObjectProxyType, self).get_name(attr, context)
if u:
return u