relationalai 1.0.0a2__tar.gz → 1.0.0a4__tar.gz

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 1.0.0a2
+Version: 1.0.0a4
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 Requires-Python: >=3.10
@@ -15,10 +15,9 @@ Requires-Dist: numpy<2
 Requires-Dist: pandas
 Requires-Dist: colorama
 Requires-Dist: inquirerpy
-Requires-Dist: click==8.2.1
+Requires-Dist: click
 Requires-Dist: gravis
 Requires-Dist: toml
-Requires-Dist: tomlkit
 Requires-Dist: requests
 Requires-Dist: pyarrow
 Requires-Dist: websockets
@@ -35,6 +34,9 @@ Requires-Dist: sqlglot
 Requires-Dist: pyyaml
 Requires-Dist: pydantic<2.12.0,>=2.0.0
 Requires-Dist: pydantic-settings<2.11.0,>=2.0.0
+Requires-Dist: tomlkit
+Requires-Dist: fastapi
+Requires-Dist: uvicorn[standard]
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/README.md

@@ -15,6 +15,29 @@ make install
 make sync
 ```
 
+### Running Tests
+
+The repository includes two test suites that can be run using Make commands:
+
+**Unified tests** (general test suite):
+```bash
+make test              # run all unified tests
+make test unions          # run tests matching "q03"
+make test "unions or strings"  # run tests matching pattern with spaces
+make test unions --update # run tests and update snapshots
+make test --update     # update snapshots for all tests
+```
+
+**TPCH tests** (TPC-H benchmark queries):
+```bash
+make tpch              # run all TPCH tests
+make tpch q01          # run only q01
+make tpch q22 --update # run q22 and update snapshots
+make tpch --update     # update snapshots for all TPCH tests
+```
+
+The `--update` flag (or `-u` for short) can be placed before or after the pattern.
+
 ### Docstrings
 
 API reference documentation is generated from docstrings in the code.

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '1.0.0a2'
+version = '1.0.0a4'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [
@@ -18,10 +18,9 @@ dependencies = [
     "pandas",
     "colorama",
     "inquirerpy",
-    "click==8.2.1",
+    "click",
     "gravis",
     "toml",
-    "tomlkit",
     "requests",
     "pyarrow",
     "websockets",
@@ -40,6 +39,9 @@ dependencies = [
     # "confocal @ git+https://github.com/joshuafcole/confocal.git",
     "pydantic>=2.0.0,<2.12.0",
     "pydantic-settings>=2.0.0,<2.11.0",
+    "tomlkit",
+    "fastapi",
+    "uvicorn[standard]",
 ]
 [project.optional-dependencies]
 dev = [

relationalai-1.0.0a4/src/relationalai/config/shims.py

@@ -0,0 +1,2 @@
+DRY_RUN=False
+ENFORCE_TYPE_CORRECT=False

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/__init__.py

@@ -120,6 +120,7 @@ Date = core.Date
 DateTime = core.DateTime
 # RawSource = core.RawSource
 # Hash = core.Hash
+Error = core.Error
 
 #------------------------------------------------------
 # Convenience aggregates
@@ -147,7 +148,12 @@ per = aggs.per
 __all__ = [
     "Alias", "CoreLibrary", "Concept", "Data", "Distinct", "Expression", "Field", "FieldRef", "Fragment",
     "Library", "Literal", "Match", "Model", "New", "Not", "Chain", "Property", "Reading", "Relationship",
-    "Table", "Union", "Value", "Variable", "core",
+    "Table", "Union", "Value", "Variable", "core", "Error",
+    "Any", "AnyEntity", "TypeVar", "EntityTypeVar",
+    "Number", "String", "Integer", "Int", "Int64", "Int128", "Float", "Decimal", "Bool", "Boolean", "Date", "DateTime",
+
+    "rank", "limit", "asc", "desc",
+    "count", "sum", "min", "max", "avg", "string_join", "per",
 
     "select", "define", "where", "require", "union", "data", "not_",
 ]

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/frontend/base.py

@@ -6,7 +6,7 @@ import decimal
 import math
 import re
 import datetime as dt
-from typing import TYPE_CHECKING, Any, Generic, Iterable, Iterator, NoReturn, Optional, Sequence, Tuple, Type, TypeGuard, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Iterator, NoReturn, Optional, Sequence, Tuple, Type, TypeGuard, cast
 import itertools
 from more_itertools import peekable
 from pandas import DataFrame
@@ -19,7 +19,7 @@ from ...util.naming import Namer, sanitize
 from ...util.python import pytype_to_concept_name
 from ...util.source import SourcePos
 from ...util.tracing import get_tracer
-from ...util.error import err, exc, warn, source
+from ...util.error import exc, warn, source
 from ...util.docutils import include_in_docs
 from ..metamodel.builtins import builtins
 from ..metamodel.metamodel import Model as mModel
@@ -236,16 +236,16 @@ class Variable(DSLBase):
         invalid = next((bool_check for bool_check in ["if ", "while ", " and ", " or "] if bool_check in cur_source), "bool check").strip()
         mapped = {"and": "`&` or `,`", "or": "`|`", "if": "`where`"}
         if m := mapped.get(invalid):
-            exc(f"Invalid operator", f"Cannot use python's `{invalid}` in model expressions. Use {m} instead.", [source(self)])
+            exc("Invalid operator", f"Cannot use python's `{invalid}` in model expressions. Use {m} instead.", [source(self)])
         else:
-            exc(f"Invalid operator", f"Cannot use python's `{invalid}` in model expressions.", [source(self)])
+            exc("Invalid operator", f"Cannot use python's `{invalid}` in model expressions.", [source(self)])
 
     if not TYPE_CHECKING:
         def __iter__(self):
             common_incorrect = ["sum", "min", "max"]
             for agg in common_incorrect:
                 if agg in self._source.block.source:
-                    exc(f"Invalid built-in", f"The Python built-in `{agg}()` was used instead of the RAI equivalent.", [
+                    exc("Invalid built-in", f"The Python built-in `{agg}()` was used instead of the RAI equivalent.", [
                         source(self),
                         f"Use [cyan]`relationalai.semantics.std.aggregates.{agg}`[/cyan] instead.",
                     ])
@@ -405,7 +405,7 @@ class Ref(Variable):
     def _to_concept(self) -> Concept:
         return self._concept
 
-    def FilterBy(self, **kwargs: Any) -> Expression:
+    def filter_by(self, **kwargs: Any) -> Expression:
         return FilterBy(self, kwargs)
 
 #------------------------------------------------------
@@ -741,7 +741,7 @@ class Reading(Relationship):
                         precision = fields[part].type._precision
                         scale = fields[part].type._scale
                         if scale == 0:
-                            correct_type_name = f"Integer"
+                            correct_type_name = "Integer"
                         else:
                             correct_type_name = f"Number.size({precision},{scale})"
                     if type_name.lower() != fields[part].name and correct_type_name.lower() != fields[part].name:
@@ -782,7 +782,13 @@ class Literal(Variable):
         if type(value) is float and (math.isnan(value) or math.isinf(value)):
             return CoreConcepts["Float"]
         if type(value) is float:
-            fractional_digits = 0 if math.isnan(value) else min(len(str(value).split(".")[1]), 14)
+            if math.isnan(value):
+                fractional_digits = 0
+            else:
+                str_value = str(value)
+                if 'e' in str_value:
+                    str_value = format(decimal.Decimal(value), 'f')
+                fractional_digits = min(len(str_value.split('.')[1]) if '.' in str_value else 1, 14)
             return CoreConcepts["Decimal"].size(38, fractional_digits) # type: ignore
         if type(value) is decimal.Decimal:
             str_value = format(value, 'f')
@@ -1000,17 +1006,17 @@ class AsBool(Variable):
 class Alias(Variable):
     def __init__(self, source: Variable, alias: str):
         super().__init__(source._model)
-        self._source = source
+        self._source_item = source
         self._alias = alias
 
     def _to_concept(self) -> Concept|None:
-        return self._source._to_concept()
+        return self._source_item._to_concept()
 
     def __format__(self, format_spec: str) -> str:
-        if isinstance(self._source, Concept):
+        if isinstance(self._source_item, Concept):
             if format_spec:
                 exc("Invalid alias", f"Alias already specifies an alias for this concept, you can remove `:{format_spec}`")
-            return self._source.__format__(self._alias)
+            return self._source_item.__format__(self._alias)
         return super().__format__(format_spec)
 
 #------------------------------------------------------
@@ -1157,7 +1163,7 @@ class Aggregate(Variable):
         return None
 
 
-    def where(self, *args: Value) -> Aggregate:
+    def where(self, *args: Statement) -> Aggregate:
         new = self._clone()
         new._where = new._where.where(*args)
         return new

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/frontend/core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from .base import CoreLibrary as Core, Concept, NumberConcept, Field as dslField, Relationship
+from .base import CoreLibrary as Core, Concept, NumberConcept, Field as dslField, Relationship, Library
 from ..metamodel.builtins import builtins as b
 from ..metamodel import metamodel as mm
 from typing import cast
@@ -102,6 +102,26 @@ DateTime = Core.Type("DateTime")
 Float = Core.Type("Float", super_types=[Numeric])
 Hash = Core.Type("Hash") # TODO: we shouldn't really need this?
 
+def is_primitive_concept(concept: Concept) -> bool:
+    """ Check if the given concept is one of the core primitive concepts. """
+    if isinstance(concept, NumberConcept):
+        return True
+    if (concept is Boolean
+            or concept is Number
+            or concept is Float
+            or concept is String
+            or concept is Date
+            or concept is DateTime
+            or concept is Hash):
+        return True
+    return any(is_primitive_concept(a) for a in concept._extends)
+
+def extends(concept: Concept, super_concept: Concept) -> bool:
+    """ Check if the given concept extends the given super_concept (directly or indirectly). """
+    if concept is super_concept:
+        return True
+    return any(extends(a, super_concept) for a in concept._extends)
+
 #------------------------------------------------------
 # Aliases for Types
 #------------------------------------------------------
@@ -176,4 +196,12 @@ Core.Relation("unique", [dslField.input("fields", Any, is_list=True)])
 # Downstream annotations
 #------------------------------------------------------
 
-Core.Relation("output_value_is_key", [dslField.input("is_key", Integer)])
+Core.Relation("output_value_is_key", [dslField.input("is_key", Integer)])
+
+#------------------------------------------------------
+# Core Entities
+#------------------------------------------------------
+
+CoreEntities = Library("CoreEntities")
+
+Error = CoreEntities.Concept("Error")

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/frontend/front_compiler.py

@@ -56,6 +56,8 @@ def find_keys(item: Value | Statement, root_only: bool = False) -> list[Value]:
             keys.append(item)
         keys.extend(find_keys(item._start, root_only))
         return keys
+    if isinstance(item, New) and root_only:
+        return [item]
     if isinstance(item, Relationship):
         if root_only:
             return [item]
@@ -135,6 +137,14 @@ def is_core_concept(concept):
         return True
     return any(is_core_concept(a) for a in concept._extends)
 
+def is_primitive_concept(concept: Concept) -> bool:
+    core = _get_core()
+    return core.is_primitive_concept(concept)
+
+def is_entity_concept(concept: Concept) -> bool:
+    core = _get_core()
+    return not is_core_concept(concept) or core.extends(concept, core.AnyEntity)
+
 def concept_var_name(concept: Concept|Relationship) -> str:
     if isinstance(concept, Relationship):
         return sanitize(concept._short_name).lower()
@@ -289,11 +299,13 @@ def normalize_branch_keys(compiler:FrontCompiler, ctx:Context, branch_keys:list[
     for key, var in branch_keys:
         if var not in ctx.frame_vars:
             source = branch._source if isinstance(branch, DSLBase) else var.source
-            if not isinstance(key, (Concept, Ref)):
-                return ctx.err("Invalid branch", "Branch key must be a concept or reference.", [err_source(source)])
+            if not isinstance(key, (Variable)):
+                return ctx.err("Invalid branch", "Branch key must resolve to a concept.", [err_source(source)])
             concept = key._to_concept()
-            if is_core_concept(concept):
+            if not is_entity_concept(concept):
                 return ctx.err("Invalid branch", "Branch key must be an entity, not a primitive.", [err_source(source)])
+            elif concept is None:
+                return ctx.err("Invalid branch", "Branch key must resolve to a concept.", [err_source(source)])
             else:
                 ctx.add(Construct((ctx.to_value(concept._name + "_NONE_SENTINEL"),), var, source=key._source))
 
@@ -453,6 +465,8 @@ class Context:
             node = mLiteral(type=value_type, value=value._value, source=value._source)
         elif isinstance(value, AsBool):
             node = Var(bt.core.Boolean, f"v", source=value._source)
+        elif isinstance(value, Alias):
+            node = self.to_value(value._source_item)
         elif isinstance(value, MetaRef):
             if isinstance(value._target, Concept):
                 node = self.compiler.to_type(value._target)
@@ -542,10 +556,14 @@ class FrontCompiler:
 
     def to_annotation(self, node: Expression | Relationship) -> Annotation:
         if isinstance(node, Expression):
+            if not isinstance(node._op, Relationship):
+                exc("Invalid annotation", f"Annotation operation must be a Relationship, got `{type(node._op).__name__}`.", [
+                    err_source(node._source)
+                ])
             args = []
-            for arg in node._args:
+            for arg, field in zip(node._args, node._op._fields):
                 if isinstance(arg, Literal):
-                    args.append(mLiteral(type=self.to_type(arg._type), value=arg._value, source=arg._source))
+                    args.append(mLiteral(type=self.to_type(field.type), value=arg._value, source=arg._source))
                 elif isinstance(arg, Concept) or isinstance(arg, Relationship):
                     args.append(self.to_relation(arg))
                 elif isinstance(arg, Chain):
@@ -597,7 +615,7 @@ class FrontCompiler:
                 rel = UnresolvedRelation(name=name, fields=tuple(fields), source=node._source, readings=readings, annotations=annos, overloads=tuple(overloads))
             else:
                 rel = Relation(name=name, fields=tuple(fields), source=node._source, readings=readings, annotations=annos, overloads=tuple(overloads))
-            if isinstance(node, Property):
+            if isinstance(node, Property) and not node._is_unresolved and len(fields) > 1:
                 # Add a uniqueness constraint for properties
                 _get_constraints()
                 self.relation_constraints.add(Lookup(bt.constraints.unique_fields, (tuple(fields[:-1]),)))
@@ -779,7 +797,9 @@ class FrontCompiler:
             # the root vars, since all of them behave like keys. For Properties,
             # we ignore the last field since it's functionally determined by the others.
             # Expressions use their args
-            if isinstance(root, Property):
+            if is_distinct:
+                root_vars.add(root_v)
+            elif isinstance(root, Property):
                 root_vars.update(ctx.to_value(field) for field in root._fields[:-1])
             elif isinstance(root, Relationship):
                 root_vars.update(ctx.to_value(field) for field in root._fields)
@@ -855,6 +875,13 @@ class FrontCompiler:
 
     def define(self, ctx: Context, fragment:Fragment, exprs: list[Value]):
         with ctx.updating():
+            roots = KeyedSet(dsl_key)
+            for expr in exprs:
+                roots.update(find_keys(expr))
+            # look the roots up in the outer scope
+            for root in roots:
+                self.lookup(ctx, root)
+
             for expr in exprs:
                 source = expr._source if isinstance(expr, DSLBase) else fragment._source
                 with ctx.subcontext():
@@ -899,13 +926,13 @@ class FrontCompiler:
 
         if isinstance(node, Concept):
             final_var = ctx.to_value(node)
-            if not is_core_concept(node):
+            if is_entity_concept(node):
                 ctx.add_lookup(node, [final_var], source=source)
             return final_var
 
         elif isinstance(node, Ref):
             final_var = ctx.to_value(node)
-            if not is_core_concept(node._concept):
+            if is_entity_concept(node._concept):
                 ctx.add_lookup(node._concept, [final_var], source=source)
             return final_var
 
@@ -956,7 +983,7 @@ class FrontCompiler:
                 return args[-1]
             # if we are casting e.g. with something like `Discount(0.6)` we should return a literal with that
             # type
-            elif isinstance(node._op, Concept) and is_core_concept(node._op):
+            elif isinstance(node._op, Concept) and is_primitive_concept(node._op):
                 if isinstance(node._args[0], Literal):
                     return mLiteral(type=self.to_type(node._op), value=node._args[0]._value, source=source)
                 else:
@@ -1143,7 +1170,7 @@ class FrontCompiler:
             return self.lookup(ctx, node._compile_lookup())
 
         elif isinstance(node, Alias):
-            return self.lookup(ctx, node._source)
+            return self.lookup(ctx, node._source_item)
 
         elif isinstance(node, AsBool):
             # we need to create a match with two branches that returns true/false

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/frontend/pprint.py

@@ -124,7 +124,7 @@ class PrettyPrinter:
         return repr(v)
 
     def _fmt_Alias(self, a: Alias, level: int) -> str:
-        src = self.format(a._source, level)
+        src = self.format(a._source_item, level)
         return f"{src} AS {a._alias}"
 
     def _fmt_FieldRef(self, fr: FieldRef, level: int) -> str:

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/metamodel/rewriter.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Dict, Type
 
 from relationalai.util.structures import OrderedSet
 from .metamodel import (
-    Node, Model, NumberType, ScalarType, Task, Logical, Sequence, Union, Match, Until, Wait, Loop, Break, Require,
+    Node, Model, Relation, UnresolvedRelation, NumberType, ScalarType, Task, Logical, Sequence, Union, Match, Until, Wait, Loop, Break, Require,
     Not, Exists, Lookup, Update, Aggregate, Construct, Var, Annotation, Field, Literal, UnionType, ListType, TupleType
 )
 import datetime as _dt
@@ -17,7 +17,11 @@ NO_WALK = object()
 
 WALK_FIELDS: Dict[Type[Node], tuple[str, ...]] = {
     # Top-level
-    Model: ("root",),
+    Model: ("root", "relations",),
+
+    # Relation
+    Relation: ("fields",),
+    UnresolvedRelation: ("fields",),
 
     # Control flow
     Logical: ("body",),

{relationalai-1.0.0a2 → relationalai-1.0.0a4}/src/relationalai/semantics/metamodel/typer.py

@@ -13,6 +13,33 @@ from . import metamodel as mm, builtins as bt
 from .rewriter import Walker, Rewriter, NO_WALK
 from .builtins import builtins as b
 
+from contextlib import contextmanager
+
+
+#--------------------------------------------------
+# Typer Testing
+#--------------------------------------------------
+COLLECTED_ERRORS = None
+@contextmanager
+def errors(error_type):
+    """
+    Check that this type error is raised within the context.
+
+    :param error_type: the type of the expected error.
+    """
+    global COLLECTED_ERRORS
+    COLLECTED_ERRORS = []
+    try:
+        yield
+    except:
+        # we expect the typer to raise an error
+        pass
+    finally:
+        if not any(isinstance(error, error_type) for error in COLLECTED_ERRORS):
+            exc("ExpectedWarning", f"Expected warning of type {error_type.__name__} but none was raised.")
+        COLLECTED_ERRORS = None
+
+
 #--------------------------------------------------
 # Typer
 #--------------------------------------------------
@@ -68,12 +95,18 @@ class Typer:
             replacer = Replacer(net)
             final = replacer.rewrite(node)
 
-        # report any errors found during typing
+        # report any errors found during type inference
         if net.errors:
-            for error in net.errors:
-                error.report()
-            if self.enforce:
-                exc("TyperError", "Type errors detected during type inference.")
+            if COLLECTED_ERRORS is not None:
+                # collecting errors for tests, just add them to the list
+                COLLECTED_ERRORS.extend(net.errors)
+                # raise to avoid further processing
+                raise Exception("Typer errors collected.")
+            else:
+                for error in net.errors:
+                    error.report()
+                if self.enforce:
+                    exc("TyperError", "Type errors detected during type inference.")
         return final
 
 
@@ -146,10 +179,8 @@ class PropagationNetwork():
         # TODO - consider renaming this to UnresolvedReference
         self.errors.append(UnresolvedOverload(node, [self.resolve(a) for a in node.args]))
 
-    def unresolved_type(self, node: Node):
-        # TODO - this is not being used yet, we need a pass at the end to check for any node
-        # that we could not resolve
-        self.errors.append(UnresolvedType(node))
+    def unresolved_type(self, node: mm.Lookup|mm.Aggregate, arg: mm.Var):
+        self.errors.append(UnresolvedType(node, arg))
 
     def has_errors(self, node: Node) -> bool:
         for mismatch in self.errors:
@@ -264,7 +295,7 @@ class PropagationNetwork():
 
         # limit the number of iterations to avoid infinite loops
         i = 0
-        max_iterations = 100 * len(self.edges)
+        max_iterations = 100 * (len(self.edges) + len(work_list))
 
         # propagate types until we reach a fixed point
         while work_list:
@@ -409,6 +440,9 @@ class PropagationNetwork():
                 for field, field_type, arg in zip(relation.fields, resolved_fields, task.args):
                     if not field.input and isinstance(arg, mm.Var):
                         self.add_resolved_type(arg, field_type)
+                        # this can be the way to learn the specialized number type for the field
+                        if bt.is_abstract(field.type):
+                            self.add_resolved_type(field, field_type)
 
             elif b.core.TypeVar in types:
                 # this relation contains type vars, so we have to make sure that all args
@@ -446,13 +480,27 @@ class PropagationNetwork():
 
             else:
                 # no typevar or number specialization shenanigans, just propagate field types to args
+                is_population_lookup = isinstance(relation, mm.TypeNode)
                 for field, field_type, arg, arg_type in zip(relation.fields, resolved_fields, task.args, resolved_args):
-                    # add a resolved type if we learned more about the arg's type
-                    if isinstance(arg, mm.Var) and (bt.is_abstract(arg_type) or bt.extends(field_type, arg_type)):
-                        self.add_resolved_type(arg, field_type)
-                    elif not type_matches(arg_type, field_type) and not conversion_allowed(arg_type, field_type):
-                        self.type_mismatch(task, field_type, arg_type)
-
+                    # if the arg does not match the declared field type, and cannot be converted into it, it's a mismatch
+                    # note that we use the declared field type here, field.type, not the resolved field type, which may
+                    # have been refined by updates
+                    if not type_matches(arg_type, field.type, accept_expected_super_types=is_population_lookup) and not conversion_allowed(arg_type, field.type):
+                        # if the field is an output and the arg is still abstract, we may be able to refine it later,
+                        # as long as they are compatible, so skip reporting as it will come back later
+                        # TODO - replace this with the analyzer reversing an edge for this case
+                        if not field.input and bt.is_abstract(arg_type) and type_matches(field.type, arg_type, accept_expected_super_types=is_population_lookup) or conversion_allowed(field.type, arg_type):
+                            continue
+                        self.type_mismatch(task, field.type, arg_type)
+                    elif isinstance(arg, mm.Var):
+                        if bt.is_abstract(field_type) and bt.is_abstract(arg_type):
+                            # if the resolved field type is still abstract, we cannot resolve the type of the arg
+                            self.unresolved_type(task, arg)
+                        elif bt.is_abstract(arg_type) or bt.extends(field_type, arg_type):
+                            # we learned something about this arg, so store it
+                            self.add_resolved_type(arg, field_type)
+                        elif not type_matches(arg_type, field.type) and is_population_lookup:
+                            self.add_resolved_type(arg, field_type)
 
     # we try to preserve types for relations that are functions (i.e. potentially multiple
     # input but a single output) and where all types are the same. However, there are some
@@ -526,7 +574,8 @@ class PropagationNetwork():
             if isinstance(x, mm.NumberType):
                 if number is None or x.scale > number.scale or (x.scale == number.scale and x.precision > number.precision):
                     number = x
-        assert(number is not None)
+        if number is None:
+            number = b.core.DefaultNumber
         return number, [number if bt.is_number(t) else t for t in field_types]
 
 
@@ -642,10 +691,6 @@ class Analyzer(Walker):
     def analyze(self, node: mm.Node):
         self(node)
 
-    # TODO - ignoring requires for now because the typing of constraints seems incorrect
-    def enter_require(self, require: mm.Require):
-        return NO_WALK
-
     def compute_potential_targets(self, relation: mm.Relation):
         # register potential targets for placeholders
         if bt.is_placeholder(relation):
@@ -729,8 +774,6 @@ class Replacer(Rewriter):
     #--------------------------------------------------
 
     def field(self, node: mm.Field):
-        # TODO - this is only modifying the relation in the model, but then we have a new
-        # relation there, which is different than the object referenced by tasks.
         if node in self.net.resolved_types:
             return mm.Field(node.name, self.net.resolved_types[node], node.input, _relation = node._relation)
         return node
@@ -1187,7 +1230,7 @@ class TypeMismatch(TyperError):
     actual: mm.Type
 
     def message(self) -> str:
-        return f"Expected {get_name(self.expected)}, got {get_name(self.actual)}"
+        return f"Expected '{get_name(self.expected)}', got '{get_name(self.actual)}'"
 
 @dataclass
 class InvalidType(TyperError):
@@ -1204,10 +1247,11 @@ class UnresolvedOverload(TyperError):
         assert isinstance(self.node, (mm.Lookup, mm.Update, mm.Aggregate))
         rel = get_relation(self.node)
         types = ', '.join([get_name(t) for t in self.arg_types])
-        return f"Unresolved overload: {rel.name}({types})"
+        return f"Unresolved overload: '{rel.name}({types})'"
 
 @dataclass
 class UnresolvedType(TyperError):
+    arg: mm.Var
 
     def message(self) -> str:
-        return "Unable to determine concrete type."
+        return f"Unable to determine concrete type for argument '{self.arg.name}'."

relationalai-1.0.0a4/src/relationalai/semantics/reasoners/__init__.py

@@ -0,0 +1,11 @@
+"""
+The RelationalAI Semantics Reasoners Module.
+"""
+
+# Mark this package's docstrings for inclusion
+# in automatically generated web documentation,
+# by default as early access.
+# TODO: Remove dependency on v0, once this functionality is supported.
+from v0.relationalai.docutils import ProductStage
+__include_in_docs__ = True
+__rai_product_stage__ = ProductStage.EARLY_ACCESS

relationalai-1.0.0a4/src/relationalai/semantics/reasoners/graph/__init__.py

@@ -0,0 +1,38 @@
+"""
+RelationalAI Graph Library
+"""
+
+__version__ = "0.0.0"
+
+import warnings
+# TODO: Remove dependency on v0, once this functionality is supported.
+from v0.relationalai.docutils import ProductStage
+from .core import Graph
+
+# Mark this package's docstrings for inclusion
+# in automatically generated web documentation.
+__include_in_docs__ = True
+__rai_product_stage__ = ProductStage.EARLY_ACCESS
+
+# Warn on import that this package is at an early stage of development,
+# intended for internal consumers only, and ask those internal consumers
+# to contact the symbolic reasoning team such that we can track usage,
+# get feedback, and help folks through breaking changes.
+warnings.warn(
+    (
+        "\n\nThis library is still in early stages of development and is intended "
+        "for internal use only. Among other considerations, interfaces will change, "
+        "and performance is appropriate only for exploring small graphs. Please "
+        "see this package's README for additional information.\n\n"
+        "If you are an internal user seeing this, please also contact "
+        "the symbolic reasoning team such that we can track usage, get "
+        "feedback, and help you through breaking changes.\n"
+    ),
+    FutureWarning,
+    stacklevel=2
+)
+
+# Finally make this package's core functionality publicly available.
+__all__ = [
+    "Graph",
+]