relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.1__py3-none-any.whl

relationalai/tools/cli/components/utils.py

@@ -1,58 +0,0 @@
-"""Utility functions for CLI controls."""
-
-from collections.abc import Iterable
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .progress_reader import Task
-
-
-def normalize_tasks(task_or_tasks: "Task | Iterable[Task]") -> list["Task"]:
-    """Convert a single task or iterable of tasks to a list.
-
-    This utility function normalizes task inputs, handling both single Task
-    objects and iterables of Task objects. Used by TaskRegistry and ProgressReader
-    to normalize task inputs consistently.
-
-    Args:
-        task_or_tasks: A Task object or iterable of Task objects
-
-    Returns:
-        List of Task objects (empty list if input is empty)
-
-    Raises:
-        TypeError: If input is not a Task and not iterable, or if iterable contains non-Task items
-
-    Example:
-        >>> task = Task(text="Example")
-        >>> normalize_tasks(task)
-        [Task(text="Example", ...)]
-        >>> normalize_tasks([task, task])
-        [Task(text="Example", ...), Task(text="Example", ...)]
-    """
-    # Import here to avoid circular dependency
-    from .progress_reader import Task
-
-    if isinstance(task_or_tasks, Task):
-        return [task_or_tasks]
-
-    # Try to convert to list, handling non-iterable inputs
-    try:
-        tasks = list(task_or_tasks)
-    except TypeError:
-        raise TypeError(
-            f"Expected Task or Iterable[Task], got {type(task_or_tasks).__name__}"
-        ) from None
-
-    if not tasks:
-        return []
-
-    # Validate all items are Task instances
-    for item in tasks:
-        if not isinstance(item, Task):
-            raise TypeError(
-                f"Expected Task instances, got {type(item).__name__}"
-            )
-
-    return tasks
-

relationalai/tools/cli/config_template.py

@@ -1,45 +0,0 @@
-"""Template for the raiconfig.yml file generated by the init command."""
-
-CONFIG_TEMPLATE = """
-active_profile: dev
-
-profiles:
-  dev:
-    # Default connection for this profile
-    default_connection: snowflake_dev
-
-    # Connections available in this profile
-    connections:
-      snowflake_dev:
-        type: snowflake
-        authenticator: username_password
-        account: ""
-        user: ""
-        password: ""
-        warehouse: ""
-        database: ""
-        schema_: ""
-        role: ""
-
-      duckdb_local:
-        type: duckdb
-        path: ":memory:"
-
-  prod:
-    # Default connection for this profile
-    default_connection: snowflake_prod
-
-    # Connections available in this profile
-    connections:
-      snowflake_prod:
-        type: snowflake
-        authenticator: username_password
-        account: ""
-        user: ""
-        password: ""
-        warehouse: ""
-        database: ""
-        schema_: ""
-        role: ""
-"""
-

relationalai/tools/cli/dev.py

@@ -1,19 +0,0 @@
-"""Minimal entry point for the ``rai-dev`` CLI."""
-
-from __future__ import annotations
-
-import click
-
-VERSION = "1.0.0a1"
-
-
-@click.command()
-@click.version_option(version=VERSION, prog_name="rai-dev")
-def cli() -> None:
-    """Display the CLI version."""
-    click.echo(f"rai-dev version {VERSION}")
-
-
-if __name__ == "__main__":
-    cli()
-

relationalai/tools/typer_debugger.py

@@ -1,93 +0,0 @@
-import os
-import re
-from nicegui import ui
-import json
-import dataclasses
-
-
-#--------------------------------------------------
-# Data
-#--------------------------------------------------
-last_mod_time = None
-current_content: dict[str, str] = dict()
-
-def parse_file(jsonl_content):
-    content = dict()
-    lines = jsonl_content.strip().split('\n')
-    for line in lines:
-        data = json.loads(line)
-        content[data['id']] = data['content']
-    return content
-
-def poll():
-    global last_mod_time
-    global current_content
-    # Check the last modification time of the file
-    try:
-        mod_time = os.path.getmtime('typer_debug.jsonl')
-        if last_mod_time is None or mod_time > last_mod_time:
-            last_mod_time = mod_time
-            # File has changed, read and parse the new content
-            with open('typer_debug.jsonl', 'r') as file:
-                content = file.read()
-                if content:
-                    current_content = parse_file(content)
-                    view.refresh()
-    except FileNotFoundError:
-        pass
-
-#--------------------------------------------------
-# UI
-#--------------------------------------------------
-
-@ui.refreshable
-def view():
-    with ui.column():
-        # model
-        with ui.row():
-            with ui.column():
-                ui.label("Model").style("font-weight: bold;")
-                code(current_content.get('model', ''), language='metamodel')
-            with ui.column():
-                ui.label("Typed Model").style("font-weight: bold;")
-                code(current_content.get('typed_model', ''), language='metamodel')
-        # typer
-        with ui.row():
-            ui.label("Type Propagation Network").style("font-weight: bold;")
-            ui.mermaid(current_content.get('model_net', ''),
-                       {"maxEdges":10000}
-            ).style("display:flex; padding:0px 0px 0px 15px; gap:30px; overflow: auto;").on('error', lambda e: print(e.args['message']))
-        # query
-        with ui.row():
-            with ui.column():
-                ui.label("Query").style("font-weight: bold;")
-                code(current_content.get('query', ''), language='rel')
-            with ui.column():
-                ui.label("Typed Query").style("font-weight: bold;")
-                code(current_content.get('typed_query', ''), language='rel')
-
-        # typer
-        with ui.row():
-            ui.label("Type Propagation Network").style("font-weight: bold;")
-            ui.mermaid(current_content.get('query_net', ''), {"maxEdges":10000}).style("display:flex; padding:0px 0px 0px 15px; gap:30px; overflow: auto;")
-
-def code(c, language="python"):
-    if language == "rel":
-        language = "ruby"
-    if language == "lqp":
-        language = "clojure"
-    c = re.sub(r"→", "->", c)
-    c = re.sub(r"⇑", "^", c)
-    return ui.code(c, language=language).style("border:none; margin:0; padding-right: 30px; ").classes("w-full")
-
-def main(host="0.0.0.0", port=8082):
-    global checkboxes
-    global toggles
-    ui.dark_mode(True)
-    view()
-
-    ui.timer(1, poll)
-    ui.run(reload=False, host=host, port=port)
-
-if __name__ in {"__main__", "__mp_main__"}:
-    main()

relationalai/util/dataclasses.py

@@ -1,43 +0,0 @@
-from dataclasses import dataclass, field, fields, is_dataclass
-from functools import lru_cache
-from typing import Tuple, Any
-
-def is_dataclass_instance(obj) -> bool:
-    """Checks if the object is a dataclass instance, excluding the class itself."""
-    return is_dataclass(obj) and not isinstance(obj, type)
-
-def print_tree(node, field_name=None, indent=0, hide_fields=[], seen=set()):
-    """Recursively print a dataclass tree structure.
-
-    Args:
-        node: The dataclass instance or value to print.
-        field_name: Optional name of the field (for nested calls).
-        indent: Current indentation level.
-        hide_fields: List of field names to hide in the output."""
-    if id(node) in seen:
-        _indent_print(indent, "<recursion>", field_name)
-        return
-    seen.add(id(node))
-    if is_dataclass_instance(node):
-        _indent_print(indent, f"{node.__class__.__name__}:", field_name)
-        next = indent + 2
-        for field in fields(node):
-            if field.name not in hide_fields:
-                print_tree(getattr(node, field.name), field.name, next, hide_fields)
-    elif isinstance(node, list) or isinstance(node, tuple):
-        # just ignore sequences that are empty
-        if node:
-            _indent_print(indent, f"[", field_name)
-            next = indent + 2
-            for item in node:
-                print_tree(item, None, next, hide_fields)
-            _indent_print(indent, f"]")
-    else:
-        _indent_print(indent, str(node), field_name)
-
-
-def _indent_print(indent, value, field_name=None):
-    if field_name:
-        print(" " * indent + f"{field_name}: {value}")
-    else:
-        print(" " * indent + value)

relationalai/util/docutils.py

@@ -1,40 +0,0 @@
-from typing import Any, TypeVar
-from typing import Optional
-
-T = TypeVar('T')
-def include_in_docs(obj: T) -> T:
-    """Marks an object for inclusion in documentation.
-
-    Parameters
-    ----------
-    obj : Any
-        The object to mark for inclusion in documentation.
-
-    Examples
-    --------
-    Use as a decorator to mark a function for inclusion in documentation:
-
-    >>> @include_in_docs
-    >>> def double(x: int):
-    >>>     return x * 2
-
-    Use as a decorator to mark classes and methods for inclusion in documentation:
-
-    >>> @include_in_docs
-    >>> class Dog:
-    >>>     def __init__(self, name: str):
-    >>>         self.name = name
-    >>>     @include_in_docs
-    >>>     def bark(self):
-    >>>         return "Woof!"
-
-    To mark a module for inclusion in the documentation, set the
-    `__include_in_docs__` attribute to True in the module itself.
-    You do not need to use this function for modules.
-
-    For attributes, module and class-level attributes, simply provide
-    a docstring and they will be included in the documentation. There is
-    no need to use this function for attributes.
-    """
-    setattr(obj, "__include_in_docs__", True)
-    return obj

relationalai/util/error.py

@@ -1,199 +0,0 @@
-from dataclasses import dataclass, field
-from io import StringIO
-from typing import Any, NoReturn, Optional
-import html
-
-from .source import SourcePos
-from .tracing import get_tracer
-
-from rich import box
-from rich.console import Console, Group
-from rich.panel import Panel
-from rich.rule import Rule
-from rich.syntax import Syntax
-from rich.table import Table as RichTable
-from rich.text import Text
-
-#------------------------------------------------------
-# Parts
-#------------------------------------------------------
-
-@dataclass
-class Source:
-    pos: SourcePos
-    orig_line: int
-
-    def __init__(self, pos: SourcePos):
-        self.orig_line = pos.line or 0
-        self.pos = pos.block
-
-
-@dataclass
-class Table:
-    headers: list[str]
-    rows: list[list[str]]
-
-Part = str|Source|Table
-
-#------------------------------------------------------
-# Diagnostic
-#------------------------------------------------------
-
-class Diagnostic():
-    def __init__(self, name: str, message:str, parts: list[Part] = [], severity: str = "error"):
-        self.name = name
-        self.message = message
-        self.parts = parts
-        self.severity = severity  # "error", "warning", "info"
-
-    def to_dict(self) -> dict:
-        parts_json: list[dict] = []
-        for p in self.parts:
-            if isinstance(p, str):
-                parts_json.append({"kind": "text", "text": p})
-            elif isinstance(p, Source):
-                parts_json.append({"kind": "source", "file": p.pos.file, "line": p.pos.line, "source": p.pos.source, "orig_line": p.orig_line})
-            elif isinstance(p, Table):
-                parts_json.append({"kind": "table", "headers": p.headers, "rows": p.rows})
-        return {"name": self.name, "message": self.message, "severity": self.severity, "parts": parts_json}
-
-#------------------------------------------------------
-# Emitters
-#------------------------------------------------------
-
-class RichEmitter:
-    """
-    Returns a pretty terminal string (no side effects).
-    """
-    def emit(self, diag: Diagnostic) -> str:
-        buf = StringIO()
-        # write to our buffer, not the real terminal
-        console = Console(file=buf, record=False, color_system="auto", soft_wrap=False, force_terminal=True)
-        sev_style = {"error": "bold red", "warning": "bold yellow", "info": "bold cyan"}.get(diag.severity, "bold")
-        sev_sub_style = {"error": "red", "warning": "yellow", "info": "cyan"}.get(diag.severity, "cyan")
-
-        # Title
-        title_text = Text(f"[{diag.name}] ", style=sev_style)
-        title_text.append(diag.message, style="bold")
-
-        # Collect all parts into a group
-        parts_renderables:list[Any] = [title_text]
-        loc = None
-            # parts_renderables.append(Rule(style=sev_style))
-
-        for i, part in enumerate(diag.parts):
-            parts_renderables.append(Text(""))  # spacer
-            if isinstance(part, str):
-                parts_renderables.append(Text.from_markup(part))
-            elif isinstance(part, Source) and part.pos.source:
-                # header = Text(f"› {part.pos.file}:{part.orig_line}")
-                if not loc:
-                    loc = Text(f">> {part.pos.file}:{part.orig_line}", style="dim")
-                lexer = "python" if str(part.pos.file).endswith(".py") else "text"
-                num_lines = part.pos.source.count("\n") + 1
-                highlight_lines = set([part.orig_line]) if num_lines > 1 else set()
-                start_line = part.pos.line or 0
-                parts_renderables.append(
-                    Syntax(part.pos.source.rstrip("\n"), lexer, line_numbers=True, background_color="default", word_wrap=True, start_line=start_line, highlight_lines=highlight_lines)
-                )
-            elif isinstance(part, Table):
-                t = RichTable(show_header=True, expand=False, show_lines=False, padding=(0,1), box=box.SIMPLE_HEAD, border_style=None)
-                for h in part.headers:
-                    t.add_column(h)
-                for row in part.rows:
-                    t.add_row(*[str(c) for c in row])
-                parts_renderables.append(t)
-
-        # One big group, inside one Panel
-        if loc:
-            parts_renderables.insert(1, loc)
-        group = Group(*parts_renderables)
-        console.print(Panel(group, border_style=sev_style))
-
-        return buf.getvalue()
-
-class HTMLEmitter:
-    """
-    Returns inline-CSS HTML string (no side effects).
-    """
-    def emit(self, diag: Diagnostic) -> str:
-        css = """
-<style>
-.diag { font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, Apple Color Emoji, Segoe UI Emoji; }
-.hdr { font-weight: 700; margin: 8px 0; }
-.hdr.err { color: #c62828 } .hdr.warn { color: #b26a00 } .hdr.info { color: #006064 }
-.block { margin: 8px 0 14px 0; }
-.code { background:#0b0d10; color:#e6edf3; padding:10px 12px; border-radius:8px; overflow:auto; white-space:pre; }
-.file { color:#9aa4b2; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; margin:4px 0; }
-.table { border-collapse: collapse; margin: 8px 0; }
-.table th, .table td { border: 1px solid #e0e0e0; padding: 6px 8px; font-size: 0.95rem; }
-.table th { background: #f7f7f7; text-align: left; }
-</style>
-"""
-        sev_cls = {"error": "err", "warning": "warn", "info": "info"}.get(diag.severity, "info")
-        hdr = f'<div class="hdr {sev_cls}">[{html.escape(diag.name)}] {html.escape(diag.message)}</div>'
-
-        parts_html: list[str] = []
-        for part in diag.parts:
-            if isinstance(part, str):
-                parts_html.append(f'<div class="block">{html.escape(part)}</div>')
-            elif isinstance(part, Source) and part.pos.source:
-                file_line = f'{html.escape(str(part.pos.file))}:{part.pos.line}'
-                code = html.escape(part.pos.source.rstrip("\n"))
-                parts_html.append(f'<div class="block"><div class="file">-- {file_line}</div><pre class="code"><code>{code}</code></pre></div>')
-            elif isinstance(part, Table):
-                head = "".join(f"<th>{html.escape(h)}</th>" for h in part.headers)
-                body = "".join("<tr>" + "".join(f"<td>{html.escape(str(c))}</td>" for c in row) + "</tr>" for row in part.rows)
-                parts_html.append(f'<div class="block"><table class="table"><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table></div>')
-
-        return f'<div class="diag">{css}{hdr}{"".join(parts_html)}</div>'
-
-#------------------------------------------------------
-# Custom Exception classes
-#------------------------------------------------------
-
-class RAIWarning(UserWarning):
-    """Warnings emitted by RAI."""
-
-class RAIException(Exception):
-    """Exception raised to signal a diagnostic error."""
-    def __init__(self, diag: Diagnostic):
-        self.diagnostic = diag
-        super().__init__(f"[{diag.name}] {diag.message}")
-
-#------------------------------------------------------
-# Funcs
-#------------------------------------------------------
-
-def warn(name: str, message: str, parts: Optional[list[Part]] = None) -> Diagnostic:
-    from .runtime import ENV  # avoid circular import
-    diag = Diagnostic(name, message, parts or [], severity="warning")
-    ENV.warn(diag)
-    return diag
-
-def err(name: str, message: str, parts: Optional[list[Part]] = None) -> Diagnostic:
-    from .runtime import ENV  # avoid circular import
-    diag = Diagnostic(name, message, parts or [], severity="error")
-    # Do not raise here; caller may choose to continue. Just route it.
-    ENV.err(diag)  # default raises; override ENV to change behavior
-    return diag  # (unreached in default env)
-
-def exc(name: str, message: str, parts: Optional[list[Part]] = None) -> NoReturn:
-    from .runtime import ENV  # avoid circular import
-    """Always raise after routing (handy for short-circuiting)."""
-    diag = Diagnostic(name, message, parts or [], severity="error")
-    ENV.err(diag, exception=True)  # raises DiagnosticException by default
-    raise RuntimeError("Unreachable")  # for type checkers
-
-def source(obj:Any) -> Source:
-    if isinstance(obj, SourcePos):
-        return Source(pos=obj)
-
-    source = getattr(obj, "_source", None) or getattr(obj, "source", None)
-    if source is None:
-        raise ValueError("Object has no source information")
-
-    return Source(source)
-
-def table(headers: list[str] = [], rows: list[list[str]] = []) -> Table:
-    return Table(headers=headers, rows=rows)

relationalai/util/naming.py

@@ -1,145 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Hashable
-import re
-
-#------------------------------------------------------
-# Naming helpers
-#------------------------------------------------------
-
-
-def sanitize(name:str) -> str:
-    """ Cleanup the name to make it more palatable to names. """
-    x = re.sub(r"[ ,\.\(\)\|\n]", "_", name)
-    return x[0:-1] if x[-1] == "_" else x
-
-#------------------------------------------------------
-# Namer and NameCache
-#------------------------------------------------------
-
-@dataclass(frozen=True)
-class Namer:
-    """ Simple namer that keeps a single scope/context. """
-    # in range mode, the first name will have a 0 suffix and the second will have a 1 suffix, etc.
-    # otherwise, the first name will have no suffix, the second will have a _2 suffix, etc.
-    range: bool = False
-    next_count: dict[str, int] = field(default_factory=dict)
-
-    def get_name(self, name: str) -> str:
-        if name in self.next_count:
-            c = self.next_count[name]
-            self.next_count[name] = c + 1
-            if self.range:
-                new_name = f"{name}{c}"
-            else:
-                new_name = f"{name}_{c}"
-            if new_name in self.next_count:
-                # if the modified name is also in use, recurse
-                return self.get_name(new_name)
-            return new_name
-        else:
-            if self.range:
-                self.next_count[name] = 1
-                return f"{name}0"
-            else:
-                self.next_count[name] = 2
-                return name
-
-@dataclass
-class NameCache:
-    # support to generate object names with a count when there's collision
-    # the next count to use as a suffix for an object with this name
-    name_next_count: dict[Hashable, dict[str, int]] = field(default_factory=dict)
-    # cache of the precomputed name for the object with this key
-    name_cache: dict[Hashable, str] =  field(default_factory=dict)
-    # whether to use _ or not
-    use_underscore: bool = True
-    # whether the first entry should start with a 1 or with nothing
-    start_from_one: bool = False
-
-    def get_name(self, key: Hashable, name: str, prefix: str = "") -> str:
-        """
-        Generate a unique name for the given key and base name, avoiding name collisions.
-
-        Names are tracked and deduplicated using an internal counter. If a name has already
-        been generated for the given key, the cached name is returned.
-
-        For tuple keys (e.g., (relation_id, var_id)), the first element is used as the scope
-        for counting name collisions. Only tuples of length 2 are supported; an assertion will
-        fail otherwise.
-
-        Parameters:
-            key (Hashable): A unique key identifying the object. Can be an int or a (scope_id, local_id) tuple.
-            name (str): Base name to use.
-            prefix (str): Optional prefix to prepend to the name.
-
-        Returns:
-            str: A unique name string for the given key.
-
-        Examples:
-            # Global naming
-            get_name(1, "var")           => "var"
-            get_name(2, "var")           => "var_2"
-            get_name(3, "var")           => "var_3"
-
-            # Scoped naming (e.g., per relation)
-            get_name((10, 1), "x")       => "x"
-            get_name((10, 2), "x")       => "x_2"
-            get_name((20, 1), "x")       => "x"     # Different scope, starts again
-            get_name((20, 2), "x")       => "x_2"
-
-            # With prefix and custom suffix start
-            n = NameCache()
-            n.get_name(1, "val", prefix="t_")                => "t_val"
-
-            n = NameCache(start_from_one=True)
-            n.get_name(1, "val", prefix="t_")                => "t_val_1"
-        """
-        if key in self.name_cache:
-            return self.name_cache[key]
-
-        # Derive the count scope from the key
-        scope = None
-        if isinstance(key, tuple):
-            assert len(key) == 2, f"Expected tuple key of length 2, got {len(key)}: {key}"
-            scope = key[0]  # e.g., relation_id
-
-        # get the dict specific for the scope, or create one
-        if scope in self.name_next_count:
-            next_count = self.name_next_count[scope]
-        else:
-            next_count = dict()
-            self.name_next_count[scope] = next_count
-
-        # find the next available name
-        name = self._find_next(f"{prefix}{name}", next_count)
-
-        # register it for the key
-        self.name_cache[key] = name
-        return name
-
-    def _find_next(self, name: str, next_count: dict):
-        if name in next_count:
-            # name is already in use, so append the next count
-            c = next_count[name]
-            next_count[name] = c + 1
-            new_name = self._concat(name, c)
-
-        else:
-            # name not in use yet, so register it
-            next_count[name] = 2
-            if self.start_from_one:
-                new_name = self._concat(name, 1)
-            else:
-                new_name = name
-
-        if new_name != name:
-            if new_name in next_count:
-                # if the modified name is also in use, recurse
-                return self._find_next(name, next_count)
-            else:
-                # otherwise, record that the modified name was used
-                next_count[new_name] = 2
-        return new_name
-
-    def _concat(self, name: str, c: int):
-        return f"{name}_{c}" if self.use_underscore else f"{name}{c}"

relationalai/util/python.py

@@ -1,35 +0,0 @@
-from datetime import date, datetime
-from decimal import Decimal as PyDecimal
-from types import NoneType
-import numpy as np
-import pandas as pd
-
-#--------------------------------------------------
-# Python types
-#--------------------------------------------------
-
-pytype_to_concept_name: dict[object, str] = {
-    NoneType:  "Any",
-    int: "Integer", float: "Number(38,14)", str: "String", bool: "Boolean",
-    date: "Date", datetime: "DateTime", PyDecimal: "Number(38,14)",
-    # Int128Dtype(): "Integer",
-
-    # NumPy dtypes
-    **{np.dtype(k): "Integer" for k in ("int8","int16","int32","int64","uint8","uint16","uint32","uint64")},
-    **{np.dtype(k): "Number(38,14)" for k in ("float32","float64")},
-    np.dtype("bool"): "Boolean",
-    np.dtype("object"): "String",
-    np.dtype("datetime64[ns]"): "DateTime",
-    np.dtype("datetime64[ms]"): "DateTime",
-    np.dtype("datetime64[s]"): "DateTime",
-
-    # Pandas extension dtypes
-    **{t(): "Integer" for t in (pd.Int8Dtype, pd.Int16Dtype, pd.Int32Dtype, pd.Int64Dtype,
-                        pd.UInt8Dtype, pd.UInt16Dtype, pd.UInt32Dtype, pd.UInt64Dtype)},
-    **{t(): "Number(38,14)" for t in (pd.Float32Dtype, pd.Float64Dtype)},
-    pd.StringDtype(): "String",
-    pd.BooleanDtype(): "Boolean",
-    "int": "Integer", "float": "Number(38,14)", "str": "String", "bool": "Boolean",
-    "date": "Date", "datetime": "DateTime", "decimal": "Number(38,14)",
-    "datetime.date": "Date", "datetime.datetime": "DateTime"
-}