def test_symbols_str():
int_sym = Symbol("foo", IntType.instance())
string_sym = Symbol("bar", StringType.instance())
symbols = Symbols()
symbols.insert(int_sym)
symbols.insert(string_sym)
assert str(symbols) == "Symbols(foo,bar)"
def test_mutation_pretty_b():
args = {
"a": Symbol("a", IntType.instance()),
"b": Symbol("b", StringType.instance()),
}
fn = MutationFunction("foo", args, AnyType.instance(), desc="")
assert fn.pretty() == "foo(a:`int` b:`string`)"
def test_mutation_pretty_b():
args = {
'a': Symbol('a', IntType.instance()),
'b': Symbol('b', StringType.instance())
}
fn = MutationFunction('foo', args, AnyType.instance())
assert fn.pretty() == 'foo a:`int` b:`string`'
def test_symbols_pretty():
int_sym = Symbol("foo", IntType.instance())
string_sym = Symbol("bar", StringType.instance())
symbols = Symbols()
symbols.insert(int_sym)
symbols.insert(string_sym)
assert symbols.pretty() == "foo: int\nbar: string\n"
assert symbols.pretty(indent=" ") == " foo: int\n bar: string\n"
def test_symbols_pretty():
int_sym = Symbol('foo', IntType.instance())
string_sym = Symbol('bar', StringType.instance())
symbols = Symbols()
symbols.insert(int_sym)
symbols.insert(string_sym)
assert symbols.pretty() == 'foo: int\nbar: string\n'
assert symbols.pretty(indent=' ') == ' foo: int\n bar: string\n'
def test_api_loads_with_scope():
"""
Ensures Api.load functions return errors
"""
scope = Scope.root()
symbol = Symbol("a", IntType.instance())
scope.insert(symbol)
story = Api.loads("foo = a", backend="semantic", scope=scope)
story.check_success()
def instantiate(self, type_):
"""
Instantiate a mutation and resolve all symbols with their actual types.
Returns an instantiated function.
"""
# resolve all input symbols
if not isinstance(self._ti, GenericType):
symbols = {}
else:
symbols = self._ti.build_type_mapping(type_)
# instantiate all types
arguments = {}
for arg_name, arg_type in self._args.items():
arguments[arg_name] = Symbol(arg_name, instantiate(symbols,
arg_type))
output = instantiate(symbols, self._output)
return MutationFunction(self._name, arguments, output)
def get_type_instance(cls, ty):
"""
Maps a type class from the hub SDK to its corresponding TypeClass
in the compiler.
"""
assert isinstance(ty, OutputBase), ty
if isinstance(ty, OutputBoolean):
return BooleanType.instance()
if isinstance(ty, OutputInt):
return IntType.instance()
if isinstance(ty, OutputFloat):
return FloatType.instance()
if isinstance(ty, OutputString):
return StringType.instance()
if isinstance(ty, OutputAny):
return AnyType.instance()
if isinstance(ty, OutputObject):
return ObjectType(
{
k: Symbol(
k,
cls.get_type_instance(v),
storage_class=StorageClass.read(),
desc=v.help(),
)
for k, v in ty.properties().items()
}
)
if isinstance(ty, OutputList):
return ListType(cls.get_type_instance(ty.elements()),)
if isinstance(ty, OutputNone):
return NoneType.instance()
if isinstance(ty, OutputRegex):
return RegExpType.instance()
if isinstance(ty, OutputEnum):
return StringType.instance()
assert isinstance(ty, OutputMap), f"Unknown Hub Type: {ty!r}"
return MapType(
cls.get_type_instance(ty.keys()),
cls.get_type_instance(ty.values()),
)
def test_mutation_pretty_a():
args = {"a": Symbol("a", IntType.instance())}
fn = MutationFunction("foo", args, AnyType.instance(), desc="")
assert fn.pretty() == "foo(a:`int`)"
def test_symbol_str_int():
sym = Symbol("bar", IntType.instance())
assert str(sym) == "Symbol('bar', int, wa)"
def test_symbol_pretty_int():
sym = Symbol("foo", IntType.instance())
assert sym.pretty() == "int"
def test_mutation_pretty_a():
args = {'a': Symbol('a', IntType.instance())}
fn = MutationFunction('foo', args, AnyType.instance())
assert fn.pretty() == 'foo a:`int`'
def test_symbol_pretty_int():
sym = Symbol('foo', IntType.instance())
assert sym.pretty() == 'int'
def test_symbol_pretty_string():
sym = Symbol('foo', StringType.instance())
assert sym.pretty() == 'string'
def test_symbol_str_ro_string():
sym = Symbol("foo",
StringType.instance(),
storage_class=StorageClass.read())
assert str(sym) == "Symbol('foo', string, r-)"
def test_symbol_desc_string():
sym = Symbol("foo", StringType.instance(), desc=".desc.")
assert sym.desc() == ".desc."
def test_symbol_pretty_string():
sym = Symbol("foo", StringType.instance())
assert sym.pretty() == "string"
def test_function_args():
args = {"a": Symbol("a", IntType.instance())}
fn = Function("foo", args, AnyType.instance())
assert fn.args() == args
def test_symbol_str_string():
sym = Symbol("foo", StringType.instance())
assert str(sym) == "Symbol('foo', string, wa)"