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

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,
@@ -745,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
@@ -754,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)
@@ -779,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
 
     # -----------------------------
@@ -1114,7 +1119,7 @@ class Translator():
         # 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
@@ -1122,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),
@@ -1131,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),
                         ),
@@ -1146,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),
                         ),
                     )
                 )
@@ -1217,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()