relationalai 1.0.0a3__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

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, 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",),
@@ -131,7 +135,7 @@ class Walker:
             ns = {"NO_WALK": NO_WALK}
             lines =      ["def walker(self, node):"]
             lines.append(f"    no_walk = self.{enter_name}(node)")
-            lines.append(f"    if no_walk is not NO_WALK:")
+            lines.append("    if no_walk is not NO_WALK:")
             lines.extend(f"        self._walk(node.{fld})" for fld in WALK_FIELDS.get(node, ()))
             lines.append(f"        self.{exit_name}(node)")
             exec("\n".join(lines), ns)
@@ -240,8 +244,8 @@ class Rewriter:
 
             # pre-order hook: enter_<name>(node) -> optional replacement
             lines.append(f"    tmp = self.{enter_name}(node)")
-            lines.append(f"    if tmp is not None and tmp is not node:")
-            lines.append(f"        new = tmp")
+            lines.append("    if tmp is not None and tmp is not node:")
+            lines.append("        new = tmp")
             # rewrite children in WALK_FIELDS, track changes
             lines.extend(f"    v_{fld} = self._rewrite(new.{fld})" for fld in fields)
 
@@ -253,8 +257,8 @@ class Rewriter:
 
             # post-order hook: <name>(node) -> optional replacement
             lines.append(f"    tmp = self.{exit_name}(new)")
-            lines.append(f"    if tmp is not None and tmp is not new:")
-            lines.append(f"        new = tmp")
+            lines.append("    if tmp is not None and tmp is not new:")
+            lines.append("        new = tmp")
 
             lines.append("    return new")
 

relationalai/semantics/metamodel/typer.py

@@ -10,9 +10,36 @@ from ...util.naming import sanitize
 from ...util.structures import OrderedSet
 
 from . import metamodel as mm, builtins as bt
-from .rewriter import Walker, Rewriter, NO_WALK
+from .rewriter import Walker, Rewriter
 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 Exception:
+        # 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
 #--------------------------------------------------
@@ -59,7 +86,7 @@ class Typer:
             Analyzer(net).analyze(node)
 
         # propagate the types through the network
-        with tracing.span("typer.propagate") as span:
+        with tracing.span("typer.propagate"): # as span:
             net.propagate()
             # span["type_graph"] = net.to_mermaid()
 
@@ -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:
@@ -259,12 +290,12 @@ class PropagationNetwork():
         # start with the loaded roots + all literals + sources of edges without back edges
         work_list.extend(self.loaded_roots)
         for source in self.edges.keys():
-            if isinstance(source, (mm.Literal)) or not source in self.back_edges:
+            if isinstance(source, (mm.Literal)) or source not in self.back_edges:
                 work_list.append(source)
 
         # 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:
@@ -388,7 +419,7 @@ class PropagationNetwork():
             # this is only attempted if all input types match the field types, i.e. no
             # conversions are needed
             resolved_fields = types
-            if bt.is_function(relation) and len(set(resolved_fields)) == 1 and not relation in self.NON_TYPE_PRESERVERS and\
+            if bt.is_function(relation) and len(set(resolved_fields)) == 1 and relation not in self.NON_TYPE_PRESERVERS and\
                 all(type_matches(arg_type, field_type) for arg_type, field_type, field in zip(resolved_args, types, relation.fields) if field.input):
 
                 input_types = set([arg_type for field, arg_type
@@ -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]
 
 
@@ -537,15 +586,15 @@ class PropagationNetwork():
     # draw the network as a mermaid graph for the debugger
     def to_mermaid(self, max_edges=500) -> str:
         # add links for edges while collecting nodes
-        nodes = OrderedSet()
+        nodes = dict()
         link_strs = []
         # edges
         for src, dsts in self.edges.items():
-            nodes.add(src)
+            nodes[src.id] = src
             for dst in dsts:
                 if len(link_strs) > max_edges:
                     break
-                nodes.add(dst)
+                nodes[dst.id] = dst
                 link_strs.append(f"n{src.id} --> n{dst.id}")
             if len(link_strs) > max_edges:
                 break
@@ -568,7 +617,7 @@ class PropagationNetwork():
 
         resolved = self.resolved_types
         node_strs = []
-        for node in nodes:
+        for _, node in nodes.items():
             klass = ""
             if isinstance(node, mm.Var):
                 ir_type = resolved.get(node) or self.resolve(node)
@@ -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):
@@ -681,7 +726,7 @@ class Analyzer(Walker):
         is_placeholder = bt.is_placeholder(relation)
         for field, arg in zip(relation.fields, task.args):
             if isinstance(arg, (mm.Var, mm.Literal)):
-                if field.input:
+                if field.input or isinstance(arg, mm.Literal):
                     # we need to resolve all inputs before resolving the relation
                     self.net.add_edge(arg, task)
                 else:
@@ -708,9 +753,34 @@ class Replacer(Rewriter):
     def __init__(self, net:PropagationNetwork):
         super().__init__()
         self.net = net
+        # map from relation id to rewritten relation, to make sure that lookups/updates
+        # point to the correct object in case we refined the relation field types
+        self.relations:dict[int, mm.Relation] = {}
+        # logicals created during rewriting (to inline only the ones we created)
+        self.logicals = set()
+
+    def rewrite(self, node: T) -> T:
+        try:
+            if isinstance(node, mm.Model):
+                # first rewrite all relations to update their field types
+                relations = self(node.relations) # type: ignore
+                assert isinstance(relations, tuple)
+                # index the rewritten relations
+                self.relations = {r.id: r for r in relations}
+                # then rewrite the root with the updated relations
+                root = self(node.root) # type: ignore
+                return node.mut(relations = relations, root = root)
+            else:
+                return self(node)  # type: ignore
+        finally:
+            self.relations = {}
+            self.logicals = set()
 
-    def rewrite(self, model: T) -> T:
-        return self(model) # type: ignore
+    def wrap(self, body: tuple) -> mm.Logical:
+        """ Wrap the given body in a logical and track it for inlining later. """
+        logical = mm.Logical(body)
+        self.logicals.add(logical.id)
+        return logical
 
     def logical(self, logical: mm.Logical):
         if len(logical.body) == 0:
@@ -718,7 +788,7 @@ class Replacer(Rewriter):
         # inline logicals that are just there to group other nodes during rewrite
         body = []
         for child in logical.body:
-            if isinstance(child, mm.Logical) and not child.optional and not child.scope:
+            if isinstance(child, mm.Logical) and not child.optional and not child.scope and child.id in self.logicals:
                 body.extend(child.body)
             else:
                 body.append(child)
@@ -729,8 +799,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
@@ -781,7 +849,7 @@ class Replacer(Rewriter):
             args = get_lookup_args(node, target)
             types = [f.type for f in get_relation_fields(resolved_relations[0], node.relation.name)]
             # adding this logical to avoid issues in the old backend
-            branches.append(mm.Logical((self.convert_arguments(node, target, args, types=types, force_copy=True),)))
+            branches.append(self.wrap((self.convert_arguments(node, target, args, types=types, force_copy=True),)))
         return mm.Union(tuple(branches))
 
     def convert_arguments(self, node: mm.Lookup|mm.Update, relation: mm.Relation, args: Iterable[mm.Value]|None=None, types: Iterable[mm.Type]|None=None, force_copy=False) -> mm.Logical|mm.Lookup|mm.Update:
@@ -789,6 +857,9 @@ class Replacer(Rewriter):
         have these types. Convert any arguments as needed and return a new node with the
         proper relation and converted args. If multiple conversions are needed, return a
         logical that contains all the conversion tasks plus the final node. """
+        # ensure we use the rewritten relation if available
+        if relation.id in self.relations:
+            relation = self.relations[relation.id]
         args = args or node.args
         types = types or [self.net.resolve(f) for f in relation.fields]
         number_type = self.net.resolved_number.get(node.id)
@@ -820,7 +891,7 @@ class Replacer(Rewriter):
         # if we need conversion tasks, wrap in a logical
         if len(tasks) == 1:
             return tasks[0]
-        return mm.Logical(tuple(tasks))
+        return self.wrap(tuple(tasks))
 
     def visit_eq_lookup(self, node: mm.Lookup):
         (left, right) = node.args
@@ -842,7 +913,7 @@ class Replacer(Rewriter):
             return node
 
         tasks.append(mm.Lookup(b.core.eq, tuple(final_args)))
-        return mm.Logical(tuple(tasks))
+        return self.wrap(tuple(tasks))
 
 #--------------------------------------------------
 # Helpers
@@ -929,6 +1000,9 @@ def to_type(value: mm.Value|mm.Field|mm.Literal) -> mm.Type:
     if isinstance(value, mm.Field):
         return b.core.Field
 
+    if isinstance(value, mm.Relation):
+        return b.core.Relation
+
     if isinstance(value, tuple):
         return mm.TupleType(element_types=tuple(to_type(v) for v in value))
 
@@ -1187,7 +1261,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 +1278,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/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  # type: ignore[import-not-found]
+__include_in_docs__ = True
+__rai_product_stage__ = ProductStage.EARLY_ACCESS

relationalai/semantics/reasoners/graph/__init__.py

@@ -0,0 +1,35 @@
+"""
+RelationalAI Graph Library
+"""
+
+__version__ = "0.0.0"
+
+import warnings
+from .core import Graph
+
+# Mark this package's docstrings for inclusion
+# in automatically generated web documentation.
+__include_in_docs__ = True
+
+# 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",
+]