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

v0/relationalai/semantics/metamodel/rewrite/flatten.py

@@ -13,7 +13,8 @@ class Flatten(Pass):
     """
     Traverses the model's root to flatten it as much as possible. The result of this pass is
     a Logical root where all nested tasks that represent a rule in Rel are extracted to the
-    top level.
+    top level. Additionally, any Sequence is promoted to the top level Logical (but
+    encapsulated by a Logical).
 
     - nested logical with updates becomes a top-level logical (a rule)
 
@@ -122,6 +123,35 @@ class Flatten(Pass):
             Logical
                 lookup tmp2
                 output
+
+    - a Sequence is promoted to the top level Logical, encapsulated by a Logical:
+    From:
+        Logical
+            Logical
+                lookup
+                derive foo
+            Sequence
+                Logical
+                    ...
+                Loop
+                    Sequence
+                        ...
+                Logical
+                    ...
+    To:
+        Logical
+            Logical
+                lookup
+                derive foo
+            Logical
+                Sequence
+                    Logical
+                        ...
+                    Loop
+                        Sequence
+                            ...
+                    Logical
+                        ...
     """
 
     def __init__(self, use_sql: bool=False):
@@ -181,11 +211,8 @@ class Flatten(Pass):
     def handle(self, task: ir.Task, ctx: Context) -> Flatten.HandleResult:
         if isinstance(task, ir.Logical):
             return self.handle_logical(task, ctx)
-        elif isinstance(task, ir.Union) and (task.hoisted or self._use_sql):
-            # Only flatten Unions which hoist variables. If there are no hoisted variables,
-            # then the Union acts as a filter, and it can be inefficient to flatten it.
-            #
-            # However, for the SQL backend, we always need to flatten Unions for correct SQL
+        elif isinstance(task, ir.Union) and self._use_sql:
+            # The SQL backend needs to flatten Unions for correct SQL
             # generation.
             return self.handle_union(task, ctx)
         elif isinstance(task, ir.Match):
@@ -194,6 +221,8 @@ class Flatten(Pass):
             return self.handle_require(task, ctx)
         elif isinstance(task, ir.Not):
             return self.handle_not(task, ctx)
+        elif isinstance(task, ir.Sequence):
+            return self.handle_sequence(task, ctx)
         else:
             return Flatten.HandleResult(task)
 
@@ -253,9 +282,9 @@ class Flatten(Pass):
 
             for output in groups["outputs"]:
                 assert(isinstance(output, ir.Output))
-                new_body = info.task_dependencies(output)
-                new_body.update(ctx.extra_tasks)
-                new_body.add(output)
+                new_body = OrderedSet.from_iterable(t.clone() for t in info.task_dependencies(output))
+                new_body.update(t.clone() for t in ctx.extra_tasks)
+                new_body.add(output.clone())
                 ctx.rewrite_ctx.top_level.append(ir.Logical(task.engine, task.hoisted, tuple(new_body), task.annotations))
 
             return Flatten.HandleResult(None)
@@ -263,9 +292,9 @@ class Flatten(Pass):
         # if there are updates, extract as a new top level rule
         if groups["updates"]:
             # add task dependencies to the body
-            body.prefix(ctx.info.task_dependencies(task))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(task))
             # potentially add context extra tasks
-            body.update(ctx.extra_tasks)
+            body.update(t.clone() for t in ctx.extra_tasks)
             ctx.rewrite_ctx.top_level.append(ir.Logical(task.engine, task.hoisted, tuple(body), task.annotations))
             return Flatten.HandleResult(None)
 
@@ -278,7 +307,7 @@ class Flatten(Pass):
             agg = cast(ir.Aggregate, groups["aggregates"].some())
 
             # add agg dependencies to the body
-            body.prefix(ctx.info.task_dependencies(agg))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(agg))
 
             # extract a new logical for the aggregate, exposing aggregate group-by and results
             exposed_vars = OrderedSet.from_iterable(list(agg.group) + helpers.aggregate_outputs(agg))
@@ -298,7 +327,7 @@ class Flatten(Pass):
             rank = cast(ir.Rank, groups["ranks"].some())
 
             # add rank dependencies to the body
-            body.prefix(ctx.info.task_dependencies(rank))
+            body.prefix(t.clone() for t in ctx.info.task_dependencies(rank))
             # for rank, we sort by the args, but the result includes the keys to preserve bag semantics.
             exposed_vars_raw = list(rank.projection) + list(rank.group) + list(rank.args) +[rank.result]
             # deduplicate vars
@@ -487,6 +516,14 @@ class Flatten(Pass):
                 task.annotations
             ))
 
+    def handle_sequence(self, task: ir.Sequence, ctx: Context):
+        new_logical = f.logical(
+            body = [task],
+            engine = task.engine
+        )
+        ctx.rewrite_ctx.top_level.append(new_logical)
+        return Flatten.HandleResult(None)
+
 #--------------------------------------------------
 # Helpers
 #--------------------------------------------------

v0/relationalai/semantics/metamodel/rewrite/format_outputs.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import Tuple
 
-from v0.relationalai.semantics.metamodel import builtins, ir, factory as f, types, visitor
+from v0.relationalai.semantics.metamodel import builtins, ir, factory as f, types, visitor, helpers
 from v0.relationalai.semantics.metamodel.compiler import Pass, group_tasks
 from v0.relationalai.semantics.metamodel.util import OrderedSet
 from v0.relationalai.semantics.metamodel.util import FrozenOrderedSet
@@ -63,7 +63,7 @@ def adjust_outputs(task: ir.Logical, outputs: OrderedSet[ir.Task], wide_outputs:
                 # Remove the original output. This is replaced by per-column outputs below
                 body.remove(output)
 
-                is_export = builtins.export_annotation in output.annotations
+                is_export = helpers.is_export(output)
 
                 # Generate an output for each "column"
                 # output looks like def output(:cols, :col000, key0, key1, value):
@@ -100,7 +100,13 @@ def _generate_output_column(output: ir.Output, idx: int, alias: tuple[str, ir.Va
         (not is_primitive(alias[1].type) or alias[1].type == types.Hash)):
 
         uuid = f.var(f"{alias[0]}_{idx}_uuid", types.String)
-        aliases.append((uuid.name, uuid))
+
+        if not is_primitive(alias[1].type):
+            # For non-primitive types, we keep the original alias
+            aliases.append((alias[0], uuid))
+        else:
+            # For Hash types, we use the uuid name as alias
+            aliases.append((uuid.name, uuid))
 
         return [
             ir.Lookup(None, builtins.uuid_to_string, (alias[1], uuid)),

v0/relationalai/semantics/metamodel/typer/checker.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from typing import Optional, List, Union as PyUnion, Tuple, cast
 
 from v0.relationalai.semantics.metamodel.util import OrderedSet, ordered_set
-from v0.relationalai.semantics.metamodel import ir, types, visitor, compiler
+from v0.relationalai.semantics.metamodel import ir, types, visitor, compiler, executor
 import rich
 
 
@@ -39,7 +39,8 @@ class CheckEnv:
 
     def _complain(self, node: ir.Node, msg: str):
         """Report an error."""
-        self.diags.append(CheckError(msg, node))
+        if not executor.SUPPRESS_TYPE_ERRORS:
+            self.diags.append(CheckError(msg, node))
 
 
 @dataclass
@@ -306,8 +307,9 @@ class CheckModel(visitor.DAGVisitor):
         for x in node.hoisted:
             if not CheckModel._variable_occurs_in(x, node.body):
                 self.env._complain(node, f"Variable {ir.node_to_string(x).strip()} is hoisted but not used in the body of {ir.node_to_string(node).strip()}.")
-        if not CheckModel._variable_occurs_in(node.iter, node.body):
-            self.env._complain(node, f"Variable {node.iter} is the loop iterator but is not used in the body of {ir.node_to_string(node).strip()}.")
+        for iter_var in node.iter:
+            if not CheckModel._variable_occurs_in(iter_var, node.body):
+                self.env._complain(node, f"Variable {iter_var} is the loop iterator but is not used in the body of {ir.node_to_string(node).strip()}.")
         return super().visit_loop(node, parent)
 
     def visit_update(self, node: ir.Update, parent: Optional[ir.Node]=None):

v0/relationalai/semantics/metamodel/typer/typer.py

@@ -6,7 +6,7 @@ import datetime
 from decimal import Decimal as PyDecimal
 from typing import Optional, Union, Tuple
 from v0.relationalai import debugging
-from v0.relationalai.semantics.metamodel import builtins, helpers, ir, types, visitor, compiler, factory as f
+from v0.relationalai.semantics.metamodel import builtins, helpers, ir, types, visitor, compiler, factory as f, executor
 from v0.relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 import rich
 import sys
@@ -1389,7 +1389,8 @@ class InferTypes(compiler.Pass):
         with debugging.span("type.replace"):
             final = Replacer(w.net).walk(model)
 
-        for err in w.net.errors:
-            rich.print(str(err), file=sys.stderr)
+        if not executor.SUPPRESS_TYPE_ERRORS:
+            for err in w.net.errors:
+                rich.print(str(err), file=sys.stderr)
 
         return final

v0/relationalai/semantics/metamodel/visitor.py

@@ -466,7 +466,8 @@ class Visitor(GenericVisitor[None]):
             self._walk_engine(node.engine, node)
         for h in node.hoisted:
             self._walk_var_or_default(h, node)
-        self._walk_var(node.iter, node)
+        for iter in node.iter:
+            self._walk_var(iter, node)
         self._walk_node(node.body, node)
         for a in node.annotations:
             self._walk_node(a, node)
@@ -935,9 +936,9 @@ class Rewriter():
     #
     def handle_loop(self, node: ir.Loop, parent: ir.Node):
         hoisted = rewrite_list(ir.VarOrDefault, lambda n: self.walk(n, node), node.hoisted)
-        iter_val = self.walk(node.iter, node)
+        iter = rewrite_list(ir.Var, lambda n: self.walk(n, node), node.iter)
         body = self.walk(node.body, node)
-        return node.reconstruct(node.engine, hoisted, iter_val, body, node.annotations)
+        return node.reconstruct(node.engine, hoisted, iter, body, node.concurrency, node.annotations)
 
     def handle_break(self, node: ir.Break, parent: ir.Node):
         check = self.walk(node.check, node)

v0/relationalai/semantics/reasoners/optimization/solvers_dev.py

@@ -333,7 +333,7 @@ class SolverModelDev:
         executor.execute_raw(textwrap.dedent(f"""
         def delete[:{self.point._name}]: {self.point._name}
         def insert(:{self.point._name}, var, val): {self.points._name}(int128[{i}], var, val)
-        """), readonly=False)
+        """))
         return None
 
     # print summary of the solver result