relationalai 1.0.0a2__py3-none-any.whl → 1.0.0a4__py3-none-any.whl

relationalai/shims/executor.py

@@ -10,7 +10,10 @@ from v0.relationalai.semantics.rel.executor import RelExecutor
 from v0.relationalai.semantics.metamodel import ir as v0, factory as v0_factory
 from v0.relationalai.semantics.metamodel.visitor import collect_by_type
 from v0.relationalai.semantics.snowflake import Table as v0Table
-from v0.relationalai.clients.snowflake import Provider as v0Provider
+try:
+    from v0.relationalai.clients.snowflake import Provider as v0Provider #type: ignore
+except ImportError:
+    from v0.relationalai.clients.resources.snowflake import Provider as v0Provider
 from v0.relationalai.clients.config import Config
 
 # from ..config import Config

relationalai/shims/hoister.py

@@ -130,6 +130,15 @@ class Hoister(ContainerWalker):
                     self.hoists[child] = parent_hoists
                     self.allowed_vars[child] = allowed
             self.allowed_vars[container] = allowed
+            # this might be a match/union that just acts as a filter for some sibling logical,
+            # so we need to create an artificial demand for the allowed vars in the parent container
+            # to hoist them up if there's no other output providing them.
+            # ex: define(foo(Person)).where(union(Person.age > 10, Person.age < 5))
+            # parent = self.scope.parent.get(container, None)
+            # if parent:
+            #     for allowed_var in allowed:
+            #         self._register_use(allowed_var, input=True, container=parent)
+            #         self.scope.var_refs[allowed_var]
 
         if container.scope:
             # when leaving the scope, compute hoisted vars

relationalai/shims/mm2v0.py

@@ -217,7 +217,7 @@ class Translator():
         "like": "like_match",
         "regex_escape": "escape_regex_metachars",
     }
-    for lib in ["core", "aggregates", "common", "datetime", "floats", "math", "numbers", "strings", "re", "lqp"]:
+    for lib in ["core", "aggregates", "constraints", "common", "datetime", "floats", "math", "numbers", "strings", "re", "lqp"]:
         for x in b._libraries[lib].data.values():
             v0_name = RENAMES.get(x.name, x.name)
             if v0_name in v0_builtins.builtin_relations_by_name:
@@ -320,7 +320,13 @@ class Translator():
 
     def translate_annotation(self, a: mm.Annotation, parent, ctx) -> v0.Annotation:
         if a.relation.name in v0_builtins.builtin_annotations_by_name:
-            return getattr(v0_builtins, a.relation.name + "_annotation")  # type: ignore
+            if not a.args:
+                return getattr(v0_builtins, a.relation.name + "_annotation")  # type: ignore
+            else:
+                return v0.Annotation(
+                    relation=getattr(v0_builtins, a.relation.name),  # type: ignore
+                    args=tuple(self.translate_value(arg, a, ctx) for arg in a.args)
+                )
 
         return v0.Annotation(
             relation=self.translate_node(a.relation, a, Context.MODEL), # type: ignore
@@ -335,7 +341,7 @@ class Translator():
         # Abstract types (should be removed once our typer is done because they should not
         # show up in the typed metamodel.)
         b.core.Any: v0_types.Any,
-        # b.core.AnyEntity: v0_types.AnyEntity,
+        b.core.AnyEntity: v0_types.AnyEntity,
         b.core.Number: v0_types.Number, # v0 typer can figure the rest out
         # Concrete types
         b.core.Boolean: v0_types.Bool,
@@ -362,6 +368,7 @@ class Translator():
                 annotations.append(v0_builtins.external_annotation)
                 name = self.translate_table_name(t)
                 fields.insert(0, v0.Field(name="symbol", type=v0_types.Symbol, input=False)) # type: ignore
+            annotations.extend(self.translate_seq(t.annotations, t, ctx))  # type: ignore
 
             type_relation = v0.Relation(
                 name=name,
@@ -372,9 +379,8 @@ class Translator():
             )
             for super_type in t.super_types:
                 super_rel = self.translate_node(super_type, t, Context.TASK)
-                if not super_rel:
+                if not isinstance(super_rel, v0.Relation):
                     continue
-                assert isinstance(super_rel, v0.Relation)
                 v = v0.Var(type=actual_type, name=type_relation.name.lower())
                 self.maintenance_rules.append(v0.Logical(
                     engine=None,
@@ -456,6 +462,17 @@ class Translator():
     def translate_table(self, t: mm.Table, parent, ctx):
         return self.translate_scalartype(t, parent, ctx)
 
+    def rewrite_cdc_args(self, l: mm.Lookup, args, parent, ctx):
+        # If this is a lookup for an external table column,
+        # we have to prepend the column symbol to the args
+        root_type = l.relation.fields[0].type
+        if isinstance(root_type, mm.Table):
+            self.used_tables.add(root_type)
+            is_table = l.relation == root_type
+            if is_table or l.relation in root_type.columns:
+                sym = "METADATA$KEY" if is_table else l.relation.name
+                args = (v0.Literal(type=v0_types.Symbol, value=sym), *args)
+        return args
 
     # -----------------------------------------------------------------------------
     # Values
@@ -734,7 +751,6 @@ class Translator():
         assert isinstance(r.domain, mm.Logical)
         assert isinstance(r.check, mm.Logical)
         if not r.domain.body and all(isinstance(c, mm.Lookup) and c.relation is b.constraints.unique_fields for c in r.check.body):
-            return
             v0_reqs = []
             # v0 expects a check with both the domain and the relation in it followed by the unique
             # constraint, so we construct a logical with all of that in it
@@ -743,7 +759,7 @@ class Translator():
                 fields = c.args[0] # tuple of fields
                 assert isinstance(fields, tuple) and all(isinstance(f, mm.Field) for f in fields)
                 first_field = fields[0]
-                if isinstance(first_field.type, mm.Table):
+                if isinstance(first_field.type, mm.Table): #type: ignore
                     # skip union types for now
                     continue
                 assert isinstance(first_field, mm.Field)
@@ -768,17 +784,17 @@ class Translator():
                 ))
             return v0_reqs # type: ignore
 
-        # check = v0.Check(
-        #     check=self.translate_node(r.check, r, ctx), # type: ignore
-        #     error=self.translate_node(r.error, r, ctx) if r.error else None, # type: ignore
-        #     annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
-        # )
-        # return v0.Require(
-        #     engine=self.translate_reasoner(r.reasoner, r, Context.MODEL),
-        #     domain=self.translate_node(r.domain, r, ctx), # type: ignore
-        #     checks=(check,), # type: ignore
-        #     annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
-        # )
+        check = v0.Check(
+            check=self.translate_node(r.check, r, ctx), # type: ignore
+            error=self.translate_node(r.error, r, ctx) if r.error else None, # type: ignore
+            annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
+        )
+        return v0.Require(
+            engine=self.translate_reasoner(r.reasoner, r, Context.MODEL),
+            domain=self.translate_node(r.domain, r, ctx), # type: ignore
+            checks=(check,), # type: ignore
+            annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
+        )
         return None
 
     # -----------------------------
@@ -851,19 +867,11 @@ class Translator():
         if relation is None:
             return None
 
-        # External Table Column lookups
-        # we have to prepend the column symbol to the args
-        root_type = l.relation.fields[0].type
-        if isinstance(root_type, mm.Table):
-            self.used_tables.add(root_type)
-            is_table = l.relation == root_type
-            if is_table or l.relation in root_type.columns:
-                sym = "METADATA$KEY" if is_table else l.relation.name
-                args = (v0.Literal(type=v0_types.Symbol, value=sym), *args)
 
         # Specific rewrites
         rewrite = self.rewrite_lookup(l, parent, ctx)
         if rewrite is None:
+            args = self.rewrite_cdc_args(l, args, parent, ctx)
             # General translation
             rewrite = v0.Lookup(
                 engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
@@ -1100,16 +1108,18 @@ class Translator():
             else:
                 replaced_args.append(arg)
         # translate the lookup
+        args = tuple(self.translate_value(arg, l, ctx) for arg in replaced_args)
+        args = self.rewrite_cdc_args(l, args, l, ctx)
         lookup = v0.Lookup(
             engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
             relation=self.translate_node(l.relation), # type: ignore
-            args=tuple(self.translate_value(arg, l, ctx) for arg in replaced_args),
+            args=args,
             annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
         )
         # subtract 1 from the index to convert from 1-based to 0-based
         tasks = []
         for index in indices:
-            arg = args[index]
+            arg = l.args[index]
             if isinstance(arg, mm.Literal):
                 if l.relation.fields[index].input:
                     new = mm.Literal(arg.type, arg.value + 1) # type: ignore
@@ -1117,7 +1127,7 @@ class Translator():
                     new = mm.Literal(arg.type, arg.value + 1) # type: ignore
                 tasks.append(v0.Lookup(
                         engine=None,
-                        relation=v0_builtins.eq, # type: ignore
+                        relation=v0_builtins.eq,
                         args=(
                             self.translate_value(tmps[index], lookup, ctx),
                             self.translate_value(new, lookup, ctx),
@@ -1126,9 +1136,9 @@ class Translator():
             elif l.relation.fields[index].input:
                 tasks.append(v0.Lookup(
                         engine=None,
-                        relation=v0_builtins.plus, # type: ignore
+                        relation=v0_builtins.plus,
                         args=(
-                            self.translate_value(args[index], lookup, ctx),
+                            self.translate_value(arg, lookup, ctx),
                             v0.Literal(v0_types.Int128, 1),
                             self.translate_value(tmps[index], lookup, ctx),
                         ),
@@ -1141,7 +1151,7 @@ class Translator():
                         args=(
                             self.translate_value(tmps[index], lookup, ctx),
                             v0.Literal(v0_types.Int128, 1),
-                            self.translate_value(args[index], lookup, ctx),
+                            self.translate_value(arg, lookup, ctx),
                         ),
                     )
                 )
@@ -1212,7 +1222,10 @@ class Translator():
             if target_type is None or not isinstance(arg, (v0.Var, v0.Literal)) or arg.type == target_type:
                 args.append(arg)
                 continue
-            if field.input:
+            if isinstance(arg, v0.Literal):
+                # for literals, we can just create a new literal with the target type
+                args.append(v0.Literal(type=target_type, value=arg.value))
+            elif field.input:
                 cast_var = v0.Var(type=target_type, name="cast_var")
                 args.append(cast_var)
                 inputs.append(v0.Lookup(

relationalai/tools/cli/cli.py

@@ -5,6 +5,7 @@ For more documentation on these commands, visit: https://docs.relationalai.com
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
 import click
@@ -86,5 +87,142 @@ def test():
     console.print("test")
 
 
+@cli.group()
+def docs():
+    """Generate and serve documentation site."""
+    pass
+
+
+@docs.command()
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    help="Output directory for generated documentation (defaults to docs/dist)",
+)
+def generate(output: str | None):
+    """Generate static documentation site from models."""
+    from .docs import generate_docs
+
+    try:
+        generate_docs(output_dir=output)
+    except click.ClickException as e:
+        # Print formatted error message and exit
+        console.print(f"[red]✗ Failed to generate documentation: {e.message}[/red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]✗ Failed to generate documentation: {e}[/red]")
+        sys.exit(1)
+
+
+@docs.command()
+@click.option(
+    "--port",
+    "-p",
+    default=8000,
+    type=int,
+    help="Port to serve documentation on (default: 8000)",
+)
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    help="Host to bind to (default: 127.0.0.1)",
+)
+@click.option(
+    "--build-dir",
+    default=None,
+    help="Directory containing built documentation (defaults to docs/dist)",
+)
+@click.option(
+    "--no-open",
+    is_flag=True,
+    help="Don't open browser automatically",
+)
+def serve(port: int, host: str, build_dir: str | None, no_open: bool):
+    """Serve generated documentation site."""
+    from .docs import find_docs_dir, serve_docs
+
+    # Determine build directory
+    if build_dir is None:
+        docs_dir = find_docs_dir()
+        build_dir = str(docs_dir / "dist")
+
+    try:
+        serve_docs(
+            build_dir=build_dir,
+            host=host,
+            port=port,
+            open_browser=not no_open,
+        )
+    except click.ClickException as e:
+        # Print formatted error message and exit
+        console.print(f"[red]✗ Failed to start server: {e.message}[/red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]✗ Failed to start server: {e}[/red]")
+        sys.exit(1)
+
+
+@docs.command()
+@click.option(
+    "--port",
+    "-p",
+    default=5173,
+    type=int,
+    help="Port to serve development server on (default: 5173)",
+)
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    help="Host to bind to (default: 127.0.0.1)",
+)
+@click.option(
+    "--no-open",
+    is_flag=True,
+    help="Don't open browser automatically",
+)
+def dev(port: int, host: str, no_open: bool):
+    """Start development server with hot module replacement (HMR).
+
+    This command runs Vite's dev server which provides:
+    - Hot module replacement - changes reflect instantly
+    - Fast refresh - no need to rebuild on every change
+    - Source maps for debugging
+
+    Use this for development instead of 'rai docs generate' + 'rai docs serve'.
+    """
+    from .docs import dev_docs
+
+    try:
+        dev_docs(
+            host=host,
+            port=port,
+            open_browser=not no_open,
+        )
+    except click.ClickException as e:
+        # Print formatted error message and exit
+        console.print(f"[red]✗ Failed to start dev server: {e.message}[/red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]✗ Failed to start dev server: {e}[/red]")
+        sys.exit(1)
+
+
+@docs.command(name="clean")
+def clean_docs():
+    """Remove auto generated files and directories."""
+    from .docs import cleanup_docs
+
+    try:
+        cleanup_docs()
+    except click.ClickException as e:
+        # Print formatted error message and exit
+        console.print(f"[red]✗ Failed to cleanup: {e.message}[/red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]✗ Failed to cleanup: {e}[/red]")
+        sys.exit(1)
+
+
 if __name__ == "__main__":
     cli()