relationalai 0.13.3__tar.gz → 0.13.4__tar.gz

{relationalai-0.13.3 → relationalai-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 0.13.3
+Version: 0.13.4
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: colorama
 Requires-Dist: cryptography
 Requires-Dist: gravis
 Requires-Dist: inquirerpy
-Requires-Dist: lqp==0.2.1
+Requires-Dist: lqp==0.2.3
 Requires-Dist: nicegui==2.16.1
 Requires-Dist: numpy<2
 Requires-Dist: opentelemetry-api

{relationalai-0.13.3 → relationalai-0.13.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '0.13.3'
+version = '0.13.4'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [
@@ -8,7 +8,7 @@ authors = [
 ]
 requires-python = ">= 3.10"
 dependencies = [
-    "lqp==0.2.1",
+    "lqp==0.2.3",
     "snowflake-connector-python[secure-local-storage]",
     "snowflake-snowpark-python>=1.38.0",
     "typing-extensions",

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/clients/resources/snowflake/snowflake.py

@@ -105,6 +105,9 @@ TXN_ABORT_REASON_TIMEOUT = "transaction timeout"
 GUARDRAILS_ABORT_REASON = "guard rail violation"
 
 PRINT_TXN_PROGRESS_FLAG = "print_txn_progress"
+ENABLE_GUARD_RAILS_FLAG = "enable_guard_rails"
+
+ENABLE_GUARD_RAILS_HEADER = "X-RAI-Enable-Guard-Rails"
 
 #--------------------------------------------------
 # Helpers
@@ -113,6 +116,9 @@ PRINT_TXN_PROGRESS_FLAG = "print_txn_progress"
 def should_print_txn_progress(config) -> bool:
     return bool(config.get(PRINT_TXN_PROGRESS_FLAG, False))
 
+def should_enable_guard_rails(config) -> bool:
+    return bool(config.get(ENABLE_GUARD_RAILS_FLAG, False))
+
 #--------------------------------------------------
 # Resources
 #--------------------------------------------------
@@ -1800,6 +1806,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                     request_headers['user-agent'] = get_pyrel_version(self.generation)
                     request_headers['gi_setup_skipped'] = str(gi_setup_skipped)
                     request_headers['pyrel_program_id'] = debugging.get_program_span_id() or ""
+                    request_headers[ENABLE_GUARD_RAILS_HEADER] = str(should_enable_guard_rails(self.config))
 
                     # Create the transaction
                     result = self._create_v2_txn(

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/clients/resources/snowflake/use_index_poller.py

@@ -66,7 +66,7 @@ ERP_CHECK_FREQUENCY = 15
 
 # Polling behavior constants
 POLL_OVERHEAD_RATE = 0.1  # Overhead rate for exponential backoff
-POLL_MAX_DELAY = 2.5  # Maximum delay between polls in seconds
+POLL_MAX_DELAY = 0  # Maximum delay between polls in seconds
 
 # SQL query template for getting stream column hashes
 # This query calculates a hash of column metadata (name, type, precision, scale, nullable)

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/internal/snowflake.py

@@ -214,6 +214,7 @@ class Table():
         self._col_names = cols
         self._iceberg_config = config
         self._is_iceberg = config is not None
+        self._skip_cdc = False
         info = self._schemas.get((self._database, self._schema))
         if not info:
             info = self._schemas[(self._database, self._schema)] = SchemaInfo(self._database, self._schema)
@@ -303,7 +304,10 @@ class Table():
 
     def _compile_lookup(self, compiler:b.Compiler, ctx:b.CompilerContext):
         self._lazy_init()
-        Table._used_sources.add(self)
+        if not self._skip_cdc:
+            # Don't do CDC if the underlying data has been loaded
+            # directly via `api.load_data`.
+            Table._used_sources.add(self)
         compiler.lookup(self._rel, ctx)
         return compiler.lookup(b.RelationshipFieldRef(None, self._rel, 0), ctx)
 

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/lqp/executor.py

@@ -10,8 +10,9 @@ from snowflake.snowpark import Session
 
 from relationalai import debugging
 from relationalai.errors import NonDefaultLQPSemanticsVersionWarning
-from relationalai.semantics.lqp import result_helpers
+from relationalai.semantics.lqp import result_helpers, export_rewriter
 from relationalai.semantics.metamodel import ir, factory as f, executor as e
+from relationalai.semantics.metamodel.visitor import collect_by_type
 
 if TYPE_CHECKING:
     from relationalai.semantics.internal.internal import Model as InternalModel
@@ -368,7 +369,7 @@ class LQPExecutor(e.Executor):
             meta=None,
         )
 
-    def compile_lqp(self, model: ir.Model, task: ir.Task):
+    def compile_lqp(self, model: ir.Model, task: ir.Task, format: Optional[Literal["pandas", "snowpark", "csv"]] = "pandas"):
         configure = self._construct_configure()
         # Merge the epochs into a single transaction. Long term the query bits should all
         # go into a WhatIf action and the intrinsics could be fused with either of them. But
@@ -394,6 +395,21 @@ class LQPExecutor(e.Executor):
             result, final_model = self.compiler.compile_inner(query, options)
             export_info, query_epoch = result
 
+            if format == "csv":
+                # Extract original column names from Output
+                outputs = collect_by_type(ir.Output, task)
+                assert outputs, "No Output found in the task"
+                assert len(outputs) == 1, "Multiple Outputs found in the task"
+                output = outputs[0]
+                original_cols = []
+                for alias, _ in output.aliases:
+                    if not alias:
+                        continue
+                    original_cols.append(alias)
+                # Use rewriter to filter data_columns
+                column_filter = export_rewriter.ExtraColumnsFilter(original_cols)
+                query_epoch = column_filter.filter_epoch(query_epoch)
+
             epochs.append(query_epoch)
             epochs.append(self._compile_undefine_query(query_epoch))
 
@@ -417,8 +433,7 @@ class LQPExecutor(e.Executor):
     ) -> DataFrame:
         self.prepare_data()
         previous_model = self._last_model
-
-        final_model, export_info, txn_proto = self.compile_lqp(model, task)
+        final_model, export_info, txn_proto = self.compile_lqp(model, task, format=format)
 
         if self.dry_run:
             return DataFrame()
@@ -440,7 +455,9 @@ class LQPExecutor(e.Executor):
             nowait_durable=True,
             headers=headers,
         )
-        assert isinstance(raw_results, TransactionAsyncResponse)
+        assert isinstance(raw_results, TransactionAsyncResponse), "Expected TransactionAsyncResponse from LQP execution"
+        assert raw_results.transaction is not None, "Transaction result is missing"
+        txid = raw_results.transaction['id']
 
         try:
             cols, extra_cols = self._compute_cols(task, final_model)
@@ -453,7 +470,6 @@ class LQPExecutor(e.Executor):
 
             if export_to:
                 assert cols, "No columns found in the output"
-                assert raw_results.transaction, "Invalid transaction result"
                 assert export_info, "Export info should be populated if we are exporting results"
                 result_cols = export_to._col_names
                 if result_cols is not None:
@@ -461,11 +477,15 @@ class LQPExecutor(e.Executor):
                 else:
                     result_cols = [col for col in cols if col not in extra_cols]
                 assert result_cols
-                self._export(raw_results.transaction['id'], export_info, export_to, cols, result_cols, update)
+                self._export(txid, export_info, export_to, cols, result_cols, update)
 
             if format == "csv":
                 if export_info is not None and isinstance(export_info, tuple) and isinstance(export_info[0], str):
-                    return DataFrame([export_info[0]], columns=["path"])
+                    # The full CSV path has two parts. The first part is chosen by the frontend, while
+                    # the second part is chosen by the backend to avoid collisions. We need to ensure
+                    # the second part is synchronized with the future changes in the backend.
+                    full_path = export_info[0] + f"/data_{txid}.gz"
+                    return DataFrame([full_path], columns=["path"])
                 else:
                     raise ValueError("The CSV export was not successful!")
             

relationalai-0.13.4/src/relationalai/semantics/lqp/export_rewriter.py

@@ -0,0 +1,40 @@
+#----------------------------------------------------------------------------------------------
+# This is a custom LQP rewriter that filters extra columns from CSV export. It is used in the
+# LQP executor, when the format="csv", to ensure only intended columns are being exported.
+#----------------------------------------------------------------------------------------------
+
+from dataclasses import replace
+from lqp import ir as lqp_ir
+
+class ExtraColumnsFilter:
+
+    def __init__(self, original_cols: list[str]):
+        self.original_cols = set(original_cols)
+
+    def filter_epoch(self, query_epoch: lqp_ir.Epoch) -> lqp_ir.Epoch:
+
+        # Only process epochs with a single read which is dedicated to Export
+        if not (query_epoch.reads and len(query_epoch.reads) == 1):
+            return query_epoch
+
+        old_read = query_epoch.reads[0]
+        if not isinstance(old_read.read_type, lqp_ir.Export):
+            return query_epoch
+
+        config = old_read.read_type.config
+        assert isinstance(config, lqp_ir.ExportCSVConfig) and config.data_columns is not None, \
+            "Expected ExportCSVConfig with data_columns in the read type"
+
+        data_columns = config.data_columns
+
+        # Filter data_columns to only include columns in original_cols
+        new_data_columns = [col for col in data_columns if col.column_name in self.original_cols]
+
+        # Reconstruct the nested structure with filtered data_columns
+        new_config = replace(old_read.read_type.config, data_columns=new_data_columns)
+        new_read_type = replace(old_read.read_type, config=new_config)
+        new_read = replace(old_read, read_type=new_read_type)
+
+        # Return new epoch with updated read
+        remaining_reads = list(query_epoch.reads[1:])
+        return replace(query_epoch, reads=[new_read] + remaining_reads)

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/lqp/model2lqp.py

@@ -142,8 +142,11 @@ def _translate_to_constraint_decls(ctx: TranslationCtx, rule: ir.Logical) -> lis
         lqp_guard = mk_abstraction(lqp_typed_vars, mk_and(lqp_guard_atoms))
         lqp_keys:list[lqp.Var] = [var for (var, _) in lqp_typed_keys] # type: ignore
         lqp_values:list[lqp.Var] = [var for (var, _) in lqp_typed_values] # type: ignore
+        lqp_id = utils.lqp_hash(fd.canonical_str)
+        lqp_name:lqp.RelationId = lqp.RelationId(id=lqp_id, meta=None)
 
         fd_decl = lqp.FunctionalDependency(
+            name=lqp_name,
             guard=lqp_guard,
             keys=lqp_keys,
             values=lqp_values,

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/lqp/rewrite/annotate_constraints.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-
+from dataclasses import dataclass, field
+from relationalai.clients.config import Config
 from relationalai.semantics.metamodel import builtins
 from relationalai.semantics.metamodel.ir import Node, Model, Require
 from relationalai.semantics.metamodel.compiler import Pass
@@ -10,8 +11,6 @@ from relationalai.semantics.lqp.rewrite.functional_dependencies import (
     is_valid_unique_constraint, normalized_fd
 )
 
-_DISABLE_CONSTRAINT_DECLARATIONS = True
-
 class AnnotateConstraints(Pass):
     """
     Extends `DischargeConstraints` pass by discharging only those Require nodes that cannot
@@ -29,24 +28,37 @@ class AnnotateConstraints(Pass):
     def rewrite(self, model: Model, options: dict = {}) -> Model:
         return AnnotateConstraintsRewriter().walk(model)
 
-
+@dataclass
 class AnnotateConstraintsRewriter(DischargeConstraintsVisitor):
+    emit_constraints: bool = field(default=False)
     """
-    Visitor marks all nodes which should be removed from IR model with `discharge` annotation.
+    Visitor marks Require nodes with
+    - `discharge` if they should be discharged from the metamodel
+    - `declare_constraint` if they should be kept and emitted as LQP constraint declarations
+
+    By default, all constraints are discharged. To enable emitting constraints, set the
+    `reasoner.rule.emit_constraints` flag to True in the config file.
+    ```toml
+    [reasoner.rule]
+    emit_constraints = true
+    ```
     """
 
-    def _should_be_declarable_constraint(self, node: Require) -> bool:
-        if _DISABLE_CONSTRAINT_DECLARATIONS:
+    def __post_init__(self):
+        from relationalai.semantics.internal.internal import overridable_flag
+        self.emit_constraints = overridable_flag('reasoner.rule.emit_constraints', Config(), None, False)
+
+    def _should_declare_constraint(self, node: Require) -> bool:
+        if not self.emit_constraints:
             return False
         if not is_valid_unique_constraint(node):
             return False
         # Currently, we only declare non-structural functional dependencies.
         fd = normalized_fd(node)
-        assert fd is not None  # already checked by _is_valid_unique_constraint
-        return not fd.is_structural
+        return fd is not None and not fd.is_structural
 
     def handle_require(self, node: Require, parent: Node):
-        if self._should_be_declarable_constraint(node):
+        if self._should_declare_constraint(node):
             return node.reconstruct(
                 node.engine,
                 node.domain,

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/lqp/rewrite/functional_dependencies.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Optional, Sequence
 from relationalai.semantics.internal import internal
 from relationalai.semantics.metamodel.ir import (
-    Node, Require, Logical, Var, Relation, Lookup, ScalarType
+    Node, Require, Logical, Var, Relation, Lookup, ScalarType, Literal
 )
 from relationalai.semantics.metamodel import builtins
 
@@ -13,7 +13,7 @@ dependencies. The main functionalities provided are:
     1. Check whether a `Require` node is a valid unique constraint representation
     2. Represent the uniqueness constraint as a functional dependency
     3. Check if the functional dependency is structural i.e., can be represented with
-         `@function(k)` annotation on a single relation.
+       `@function(k)` annotation on a single relation.
 
 =========================== Structure of unique constraints ================================
 A `Require` node represents a _unique constraint_ if it meets the following criteria:
@@ -234,6 +234,9 @@ class FunctionalDependency:
 
         self._determine_is_structural()
 
+        # compute canonical string representation of the fd
+        self._canonical_str = self._compute_canonical_str()
+
     # A functional dependency `φ: X → Y` is _k-functional_ if `φ` consists of a single atom
     # `R(x1,...,xm,y1,...,yk)` and `X = {x1,...,xm}`. Not all functional dependencies are
     # k-functional. For instance, `R(x, y, z): {y, z} → {x}` cannot be expressed with
@@ -291,6 +294,32 @@ class FunctionalDependency:
         values_str = ", ".join([str(var) for var in self.values]).strip()
         return f"{guard_str}: {{{keys_str}}} -> {{{values_str}}}"
 
+    # computes a canonical string representation of the functional dependency
+    def _compute_canonical_str(self) -> str:
+        # we construct a stable tuple-term representation of the fd
+        fd_term = ("fd",)
+        for atom in sorted(self.guard, key=lambda x: x.relation.name):
+            atom_term = (atom.relation.name,)
+            for arg in atom.args:
+                if isinstance(arg, Var):
+                    atom_term += (("var", arg.name, str(arg.type)),)
+                elif isinstance(arg, Literal):
+                    atom_term += (("lit", arg.value, str(arg.type)),)
+                else:
+                    atom_term += (("arg", str(arg)),)
+            fd_term += (atom_term,)
+        keys_term = tuple(sorted((("var", v.name, str(v.type)) for v in self.keys)))
+        values_term = tuple(sorted((("var", v.name, str(v.type)) for v in self.values)))
+        fd_term += (("keys", keys_term), ("values", values_term))
+        return str(fd_term)
+
+    @property
+    def canonical_str(self) -> str:
+        """
+        A canonical string representation (depends on guard atoms, keys, and values).
+        """
+        return self._canonical_str
+
 def contains_only_declarable_constraints(node: Node) -> bool:
     """
     Checks whether the input `Logical` node contains only `Require` nodes annotated with

{relationalai-0.13.3 → relationalai-0.13.4}/src/relationalai/semantics/tests/test_snapshot_abstract.py

@@ -20,7 +20,7 @@ class AbstractSnapshotTest(ABC):
     provider:Provider = cast(SFProvider, Provider()) # type: ignore
 
     def run_snapshot_test(self, snapshot, script_path, db_schema=None, use_sql=False, use_lqp=True, use_rel=False,
-                          use_direct_access=False, e2e=False, use_csv=True, e2e_only=False):
+                          use_direct_access=False, e2e=False, use_csv=True, e2e_only=False, emit_constraints=False):
         # Resolve use_lqp
         use_lqp = use_lqp and (not use_rel) # use_rel overrides because use_lqp is default.
 
@@ -47,6 +47,7 @@ class AbstractSnapshotTest(ABC):
                 'model_suffix': "" if not e2e else f"_{unique_name}",
                 'use_sql': use_sql,
                 'reasoner.rule.use_lqp': use_lqp,
+                'reasoner.rule.emit_constraints': emit_constraints,
                 'keep_model': False,
                 # fix the current time to keep snapshots stable
                 'datetime_now': datetime.datetime.fromisoformat("2025-12-01T12:00:00+00:00"),