relationalai 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

relationalai/experimental/solvers.py

@@ -261,20 +261,7 @@ class SolverModel:
         remaining_timeout_minutes = calc_remaining_timeout_minutes(
             start_time, query_timeout_mins, config_file_path=config_file_path
         )
-        try:
-            job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
-        except Exception as e:
-            err_message = str(e).lower()
-            if isinstance(e, ResponseStatusException):
-                err_message = e.response.json().get("message", "")
-            if any(kw in err_message.lower() for kw in ENGINE_ERRORS + WORKER_ERRORS + ENGINE_NOT_READY_MSGS):
-                solver._auto_create_solver_async()
-                remaining_timeout_minutes = calc_remaining_timeout_minutes(
-                    start_time, query_timeout_mins, config_file_path=config_file_path
-                )
-                job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
-            else:
-                raise e
+        job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
 
         # 3. Extract result.
         remaining_timeout_minutes = calc_remaining_timeout_minutes(
@@ -660,12 +647,24 @@ class Solver:
         if self.engine is None:
             raise Exception("Engine not initialized.")
 
-        # Make sure the engine is ready.
-        if self.engine["state"] != "READY":
-            poll_with_specified_overhead(lambda: self._is_solver_ready(), 0.1)
-
         with debugging.span("job") as job_span:
-            job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+            # Retry logic. If creating a job fails with an engine
+            # related error we will create/resume/... the engine and
+            # retry.
+            try:
+                job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+            except Exception as e:
+                err_message = str(e).lower()
+                if isinstance(e, ResponseStatusException):
+                    err_message = e.response.json().get("message", "")
+                if any(kw in err_message.lower() for kw in ENGINE_ERRORS + WORKER_ERRORS + ENGINE_NOT_READY_MSGS):
+                    self._auto_create_solver_async()
+                    # Wait until the engine is ready.
+                    poll_with_specified_overhead(lambda: self._is_solver_ready(), 0.1)
+                    job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+                else:
+                    raise e
+
             job_span["job_id"] = job_id
             debugging.event("job_created", job_span, job_id=job_id, engine_name=self.engine["name"], job_type=ENGINE_TYPE_SOLVER)
             if not isinstance(job_id, str):

relationalai/semantics/lqp/executor.py

@@ -300,6 +300,27 @@ class LQPExecutor(e.Executor):
                 meta=None,
             )
 
+    def _compile_undefine_query(self, query_epoch: lqp_ir.Epoch) -> lqp_ir.Epoch:
+        fragment_ids = []
+
+        for write in query_epoch.writes:
+            if isinstance(write.write_type, lqp_ir.Define):
+                fragment_ids.append(write.write_type.fragment.id)
+
+        # Construct new Epoch with Undefine operations for all collected fragment IDs
+        undefine_writes = [
+            lqp_ir.Write(
+                write_type=lqp_ir.Undefine(fragment_id=frag_id, meta=None),
+                meta=None
+            )
+            for frag_id in fragment_ids
+        ]
+
+        return lqp_ir.Epoch(
+            writes=undefine_writes,
+            meta=None,
+        )
+
     def compile_lqp(self, model: ir.Model, task: ir.Task):
         configure = self._construct_configure()
 
@@ -334,7 +355,11 @@ class LQPExecutor(e.Executor):
         if model_txn is not None:
             epochs.append(model_txn.epochs[0])
 
-        epochs.append(query_txn.epochs[0])
+        query_txn_epoch = query_txn.epochs[0]
+
+        epochs.append(query_txn_epoch)
+
+        epochs.append(self._compile_undefine_query(query_txn_epoch))
 
         txn = lqp_ir.Transaction(epochs=epochs, configure=configure, meta=None)
 

relationalai/semantics/lqp/rewrite/extract_common.py

@@ -265,10 +265,12 @@ class ExtractCommon(Pass):
         for child in common_body:
             body_output_vars.update(ctx.info.task_outputs(child))
 
-        # Compute the union of input vars across all composites, intersected with output
+        # Compute the union of input vars across all non-extracted tasks (basically
+        # composites and binders left behind), intersected with output
         # vars of the common body
         exposed_vars = OrderedSet.from_iterable(ctx.info.task_inputs(sample)) & body_output_vars
-        for composite in composites:
+        non_extracted_tasks = (binders - common_body) | composites
+        for composite in non_extracted_tasks:
             if composite is sample:
                 continue
             # compute common input vars

relationalai/semantics/metamodel/builtins.py

@@ -112,12 +112,12 @@ log10 = f.relation(
 
 log = f.relation(
     "log",
-    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Float)],
+    [f.input_field("base", types.Number), f.input_field("value", types.Number), f.field("result", types.Float)],
     overloads=[
-        f.relation("log", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Int64), f.input_field("value", types.Int64), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Int128), f.input_field("value", types.Int128), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Float), f.input_field("value", types.Float), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.GenericDecimal), f.input_field("value", types.GenericDecimal), f.field("result", types.Float)]),
 
     ],
 )
@@ -496,7 +496,7 @@ function = f.relation("function", [f.input_field("code", types.Symbol)])
 function_checked_annotation = f.annotation(function, [f.lit("checked")])
 function_annotation = f.annotation(function, [])
 
-# Indicates this relation should be tracked in telemetry. Only supported for Relationships.
+# Indicates this relation should be tracked in telemetry. Supported for Relationships and Concepts.
 # `RAI_BackIR.with_relation_tracking` produces log messages at the start and end of each
 # SCC evaluation, if any declarations bear the `track` annotation.
 track = f.relation("track", [

relationalai/semantics/metamodel/dependency.py

@@ -627,11 +627,13 @@ class BindingAnalysis(visitor.Visitor):
                         x, y = child.args[0], child.args[1]
                         if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
                             grounds.add(x)
+                            self.output(child, x)
                         elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
                             grounds.add(y)
+                            self.output(child, y)
                         elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
                             # mark as potentially grounded, if any is grounded in other atoms then we later ground both
-                            potentially_grounded.add((x, y))
+                            potentially_grounded.add((child, x, y))
                     else:
                         # grounds only outputs
                         for idx, f in enumerate(child.relation.fields):
@@ -654,23 +656,33 @@ class BindingAnalysis(visitor.Visitor):
                 # grounds the output var
                 grounds.add(child.id_var)
 
+        # add child hoisted vars to grounded so that they can be picked up by the children
+        for child in node.body:
+            if isinstance(child, helpers.COMPOSITES):
+                grounds.update(helpers.hoisted_vars(child.hoisted))
+
+        # equalities where both sides are already grounded mean that both sides are input
+        for child, x, y in potentially_grounded:
+            if x in grounds and y in grounds:
+                self.input(child, x)
+                self.input(child, y)
+
         # deal with potentially grounded vars up to a fixpoint
         changed = True
         while changed:
             changed = False
-            for x, y in potentially_grounded:
+            for child, x, y in potentially_grounded:
                 if x in grounds and y not in grounds:
+                    self.input(child, x)
+                    self.output(child, y)
                     grounds.add(y)
                     changed = True
                 elif y in grounds and x not in grounds:
+                    self.input(child, y)
+                    self.output(child, x)
                     grounds.add(x)
                     changed = True
 
-        # add child hoisted vars to grounded so that they can be picked up by the children
-        for child in node.body:
-            if isinstance(child, helpers.COMPOSITES):
-                grounds.update(helpers.hoisted_vars(child.hoisted))
-
         # now visit the children
         self._grounded.append(grounds)
         super().visit_logical(node, parent)
@@ -765,20 +777,28 @@ class BindingAnalysis(visitor.Visitor):
                     self.output(node, arg)
 
         if builtins.is_eq(node.relation):
-            # special case eq because it can be input or output
-            x, y = node.args[0], node.args[1]
-            if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
-                self.output(node, x)
-            elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                self.output(node, y)
-            elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                # in this case it's possible that both are outputs (if both are grounded), else both are inputs
-                grounds = self._grounded[-1] if self._grounded else ordered_set()
-                for var in (x, y):
-                    if var in grounds:
-                        self.output(node, var)
+            # Most cases are covered already at the parent level if the equality is part of
+            # a Logical. The remaining cases are when the equality is a child of a
+            # non-Logical.
+            if self.info.task_inputs(node) or self.info.task_outputs(node):
+                # already covered
+                pass
+            else:
+                x, y = node.args[0], node.args[1]
+                if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
+                    self.output(node, x)
+                elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
+                    self.output(node, y)
+                elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
+                    grounds = self._grounded[-1] if self._grounded else ordered_set()
+                    if x in grounds:
+                        self.input(node, x)
+                    else:
+                        self.output(node, x)
+                    if y in grounds:
+                        self.input(node, y)
                     else:
-                        self.input(node, var)
+                        self.output(node, y)
         else:
             # register variables depending on the input flag of the relation bound to the lookup
             for idx, f in enumerate(node.relation.fields):

relationalai/semantics/metamodel/helpers.py

@@ -348,12 +348,13 @@ def clone_task(task: T) -> T:
         # if no childrean were stacked, we rewrote all fields of curr, so we can pop it and rewrite it
         if not stacked_children:
             stack.pop()
-            children = []
-            for f in curr_fields:
-                children.append(from_cache(getattr(curr, f.name)))
-            # create a new prev_node with the cloned children
-            prev_node = curr.__class__(*children)
-            cache[curr.id] = prev_node
+            if curr.id not in cache:
+                children = []
+                for f in curr_fields:
+                    children.append(from_cache(getattr(curr, f.name)))
+                # create a new prev_node with the cloned children
+                prev_node = curr.__class__(*children)
+                cache[curr.id] = prev_node
 
     # the last node we processed is the rewritten original node
     assert(isinstance(prev_node, type(task)))

relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py

@@ -58,10 +58,7 @@ class LogicalExtractor(Rewriter):
         # compute the vars to be exposed by the extracted logical; those are keys (what
         # makes the values unique) + the values (the hoisted variables)
         exposed_vars = ordered_set()
-        # start with all the inputs to this logical as keys
-        # TODO - in the future we can analyze better these inputs to see if we can drop
-        # some and have narrower intermediate relations
-        exposed_vars.update(self.info.task_inputs(logical))
+
         # if there are aggregations, make sure we don't expose the projected and input vars,
         # but expose groupbys
         for child in node.body: