def visit_Str(self, node):
"""
Args:
node:
Returns:
"""
if node.s == "":
return StrType(True)
else:
return StrType(False)
def test_assert_type_custom_record_passes(self):
Dog = DictType(literals=[LiteralStr("Name")], values=[StrType()])
with Execution(
'Dog = {"Name": str}\ndef pet(d: Dog) -> str: return d["Name"]\npet({"Name": "Fido"})'
) as e:
f = ensure_function('pet', parameters=('Dog', ), returns=str)
self.assertFalse(f)
self.assertFeedback(e, SUCCESS_MESSAGE)
def test_assert_type_custom_record_fails(self):
Dog = DictType(literals=[LiteralStr("Name")], values=[StrType()])
with Execution('def pet(d: str) -> str: return d\npet("Fido")') as e:
f = ensure_function('pet', parameters=('Dog', ), returns=str)
self.assertTrue(f)
self.assertFeedback(
e, "Wrong Parameter Type\n"
"The function named pet has a parameter named d"
" that is a string, but should be Dog.")
def get_pedal_type_from_json(val):
"""
Args:
val:
Returns:
"""
if val['type'] == 'DictType':
values = [get_pedal_type_from_json(v) for v in val['values']]
empty = val.get('empty', None)
if 'literals' in val:
literals = [
get_pedal_literal_from_json(l) for l in val['literals']
]
return DictType(empty, literals=literals, values=values)
else:
keys = [get_pedal_type_from_json(k) for k in val['keys']]
return DictType(empty, keys=keys, values=values)
elif val['type'] == 'ListType':
return ListType(get_pedal_type_from_json(val.get('subtype', None)),
val.get('empty', None))
elif val['type'] == 'StrType':
return StrType(val.get('empty', None))
elif val['type'] == 'BoolType':
return BoolType()
elif val['type'] == 'NoneType':
return NoneType()
elif val['type'] == 'NumType':
return NumType()
elif val['type'] == 'ModuleType':
submodules = {
name: get_pedal_type_from_json(m)
for name, m in val.get('submodules', {}).items()
}
fields = {
name: get_pedal_type_from_json(m)
for name, m in val.get('fields', {}).items()
}
return ModuleType(name=val.get('name'),
submodules=submodules,
fields=fields)
elif val['type'] == 'FunctionType':
returns = get_pedal_type_from_json(
val.get('returns', {'type': 'NoneType'}))
return FunctionType(name=val.get('name'), returns=returns)
def get_pedal_type_from_value(value, type_space=None) -> Type:
""" Converts the Python value to a Pedal Type """
if isinstance(value, bool):
return BoolType()
if isinstance(value, (int, float, complex)):
return NumType()
if isinstance(value, str):
return StrType()
if isinstance(value, type(None)):
return NoneType()
if isinstance(value, tuple):
return TupleType(
(get_pedal_type_from_value(t, type_space) for t in value))
if isinstance(value, set):
return SetType(
(get_pedal_type_from_value(t, type_space) for t in value))
if isinstance(value, frozenset):
return FrozenSetType(
(get_pedal_type_from_value(t, type_space) for t in value))
if isinstance(value, list):
if value:
return ListType(empty=False,
subtype=get_pedal_type_from_value(value[0]))
else:
return ListType(empty=True)
if isinstance(value, dict):
if not value:
return DictType(empty=True)
if all(isinstance(value, str) for k in value.keys()):
return DictType(literals=[LiteralStr(s) for s in value.keys()],
values=[
get_pedal_type_from_value(vv, type_space)
for vv in value.values()
])
return DictType(keys=[
get_pedal_type_from_ast(k, type_space) for k in value.keys()
],
values=[
get_pedal_type_from_ast(vv, type_space)
for vv in value.values()
])
return UnknownType()
def visit_FormattedValue(self, node):
value = self.visit(node.value)
if isinstance(value, StrType):
return value
else:
return StrType(empty=False)
def visit_JoinedStr(self, node):
values = [self.visit(expr) for expr in node.values]
# The result will be all StrType
return StrType(empty=all(n.empty for n in values))
def StrType_any(*x):
""" Ignores all parameters to return a StrType """
return StrType()
def get_builtin_function(name):
"""
Args:
name:
Returns:
"""
# Void Functions
if name == "print":
return FunctionType(name="print", returns=NoneType())
# Math Functions
elif name in ("int", "abs", "float", "len", "ord", "pow", "round", "sum"):
return FunctionType(name=name, returns=NumType())
# Boolean Functions
elif name in ("bool", "all", "any", "isinstance"):
return FunctionType(name=name, returns=BoolType())
# String Functions
elif name in ("str", 'chr', 'bin', 'repr', 'input'):
return FunctionType(name=name, returns=StrType())
# File Functions
elif name == "open":
return FunctionType(name="open", returns=FileType())
# List Functions
elif name == "map":
return FunctionType(name="map", returns=ListType(empty=False))
elif name == "list":
return FunctionType(name="list",
definition=_builtin_sequence_constructor(ListType))
# Set Functions
elif name == "set":
return FunctionType(name="set",
definition=_builtin_sequence_constructor(SetType))
# Dict Functions
elif name == "dict":
return FunctionType(name="dict", returns=DictType())
# Pass through
elif name == "sorted":
return FunctionType(name="sorted", returns='identity')
elif name == "reversed":
return FunctionType(name="reversed", returns='identity')
elif name == "filter":
return FunctionType(name="filter", returns='identity')
# Special Functions
elif name == "type":
return FunctionType(name="type", returns=UnknownType())
elif name == "range":
return FunctionType(name="range",
returns=ListType(NumType(), empty=False))
elif name == "dir":
return FunctionType(name="dir",
returns=ListType(StrType(), empty=False))
elif name == "max":
return FunctionType(name="max", returns='element')
elif name == "min":
return FunctionType(name="min", returns='element')
elif name == "zip":
return FunctionType(name="zip", returns=_builtin_zip)
elif name == "__import__":
return FunctionType(name="__import__", returns=ModuleType())
elif name == "globals":
return FunctionType(name="globals",
returns=DictType(keys=StrType(),
values=UnknownType(),
empty=False))
elif name in ("classmethod", "staticmethod"):
return FunctionType(name=name, returns='identity')
elif name in ("__name__", ):
return StrType()
from pedal.types.definitions import (UnknownType, FunctionType, NumType,
NoneType, BoolType, TupleType, ListType,
StrType, FileType, DictType, ModuleType,
SetType, DayType, TimeType, LiteralNum)
BUILTIN_MODULES = {
'pprint':
ModuleType(
'pprint',
fields={'pprint': FunctionType(name='pprint', returns=NoneType())}),
'json':
ModuleType('json',
fields={
'loads': FunctionType(name='loads', returns=UnknownType()),
'dumps': FunctionType(name='dumps', returns=StrType())
}),
'random':
ModuleType(
'random',
fields={'randint': FunctionType(name='randint', returns=NumType())}),
'string':
ModuleType('string',
fields={
'letters': StrType(empty=False),
'digits': StrType(empty=False),
'ascii_letters': StrType(empty=False),
'punctuation': StrType(empty=False),
'printable': StrType(empty=False),
'whitespace': StrType(empty=False),
'ascii_uppercase': StrType(empty=False),
def get_pedal_type_from_ast(value: ast.AST, type_space=None) -> Type:
"""
Determines the Pedal Type from this ast node.
Args:
value (ast.AST): An AST node.
Returns:
Type: A Pedal Type
"""
try:
if isinstance(value, ast.Constant):
return get_pedal_type_from_value(value.value, type_space)
except AttributeError as e:
pass
if isinstance(value, ast.Name):
return get_pedal_type_from_str(value.id, type_space)
elif isinstance(value, ast.Str):
return StrType(bool(value.s))
elif isinstance(value, ast.List):
return ListType(subtype=(get_pedal_type_from_ast(
value.elts[0], type_space) if value.elts else None),
empty=not bool(value.elts))
elif isinstance(value, ast.Set):
return SetType(subtype=(get_pedal_type_from_ast(
value.elts[0], type_space) if value.elts else None),
empty=not bool(value.elts))
elif isinstance(value, ast.Tuple):
return TupleType(subtypes=[
get_pedal_type_from_ast(e, type_space) for e in value.elts
])
elif isinstance(value, ast.Dict):
if not value.keys:
return DictType(empty=True)
if all(isinstance(k, ast.Str) for k in value.keys):
return DictType(literals=[LiteralStr(s.s) for s in value.keys],
values=[
get_pedal_type_from_ast(vv, type_space)
for vv in value.values
])
return DictType(
keys=[get_pedal_type_from_ast(k, type_space) for k in value.keys],
values=[
get_pedal_type_from_ast(vv, type_space) for vv in value.values
])
# Support new style subscripts (e.g., ``list[int]``)
elif ((IS_PYTHON_39 and isinstance(value, ast.Subscript))
or isinstance(value, ast.Subscript)
and isinstance(value.slice, ast.Index)):
if IS_PYTHON_39:
slice = value.slice
else:
slice = value.slice.value
if isinstance(value.value, ast.Name):
if isinstance(slice, ast.Name):
subtype = get_pedal_type_from_str(slice.id)
if value.value.id == "list":
return ListType(subtype=subtype, empty=False)
if value.value.id == "set":
return SetType(subtype=subtype, empty=False)
if value.value.id == "tuple":
return TupleType(subtypes=(subtype, ))
if value.value.id == "frozenset":
return FrozenSetType(subtype=subtype, empty=False)
elif isinstance(slice, ast.Tuple):
subtypes = [
get_pedal_type_from_ast(e, type_space) for e in slice.elts
]
if value.value.id == "tuple":
return TupleType(subtypes=subtypes)
elif value.value.id == "dict" and len(subtypes) == 2:
return DictType(keys=subtypes[0], values=subtypes[1])
# Top-level Module, parse it and get it back
if isinstance(value, ast.Module) and value.body:
if isinstance(value.body[0], ast.Expr):
return get_pedal_type_from_ast(value.body[0].value, type_space)
return UnknownType()