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

relationalai/util/runtime.py

@@ -1,156 +0,0 @@
-import os
-import sys
-import warnings
-import more_itertools
-from .tracing import get_tracer
-from .error import Diagnostic, RAIWarning, RichEmitter, HTMLEmitter, RAIException
-import traceback
-
-#------------------------------------------------------
-# Base Env
-#------------------------------------------------------
-
-class EnvBase:
-    """Decides renderer and how to deliver the string. Override to suit your runtime."""
-    # Which renderer to use for this env
-    prefers_html: bool = False
-    seen_diagnostics: set[str] = set()
-
-    def is_active(self) -> bool:  # override
-        return False
-
-    def renderer(self):
-        return HTMLEmitter() if self.prefers_html else RichEmitter()
-
-    # Delivery hooks — override as needed
-    def warn(self, diag: Diagnostic):
-        """Default: integrate with Python warnings and also print to stderr if terminal."""
-        category = RAIWarning
-        rendered = self.renderer().emit(diag)
-        if rendered in self.seen_diagnostics:
-            return  # avoid duplicate output
-        # If not HTML and we have a TTY, echo the pretty string too
-        if not self.prefers_html and sys.stderr and sys.stderr.isatty():
-            sys.stderr.write(rendered.rstrip() + "\n")
-        # route control via warnings package
-        warnings.warn(f"[{diag.name}] {diag.message}", category=category, stacklevel=3)
-        self._trace(diag)
-        self.seen_diagnostics.add(rendered)
-
-
-    def err(self, diag: Diagnostic, exception: bool = False):
-        """Default: print (or display) and raise DiagnosticException."""
-        # Echo before raising for better UX in terminals/CI
-        rendered = self.renderer().emit(diag)
-        if rendered in self.seen_diagnostics:
-            return  # avoid duplicate output
-        if self.prefers_html:
-            # In notebook-y envs, try to display inline
-            try:
-                from IPython.display import display, HTML as _HTML
-                display(_HTML(rendered))
-            except Exception:
-                sys.stderr.write("[HTML diagnostic suppressed]\n")
-        else:
-            sys.stderr.write(rendered.rstrip() + "\n")
-
-        self._trace(diag, error=True)
-        self.seen_diagnostics.add(rendered)
-        if exception:
-            raise RAIException(diag)
-
-    def _trace(self, diag: Diagnostic, error: bool = False):
-        try:
-            tracer = get_tracer()
-            payload = diag.to_dict()
-            tracer.add_event("diagnostic", diagnostic=payload)
-            if error:
-                tracer.set_status(ok=False, message=diag.message)
-        except Exception:
-            pass
-
-#------------------------------------------------------
-# Envs
-#------------------------------------------------------
-
-class CI(EnvBase):
-    def is_active(self) -> bool:
-        return any(os.getenv(k) for k in ("CI", "GITHUB_ACTIONS", "BUILD_NUMBER", "TEAMCITY_VERSION"))
-
-    def warn(self, diag: Diagnostic):
-        # keep CI logs plain and controllable via warnings
-        rendered = self.renderer().emit(diag)
-        warnings.warn(f"[{diag.name}] {diag.message}", category=RAIWarning, stacklevel=3)
-        sys.stderr.write(rendered.rstrip() + "\n")
-        self._trace(diag)
-
-    def err(self, diag: Diagnostic, exception: bool = False):
-        rendered = self.renderer().emit(diag)
-        sys.stderr.write(rendered.rstrip() + "\n")
-        self._trace(diag)
-        if exception:
-            raise RAIException(diag)
-
-class Terminal(EnvBase):
-    def is_active(self) -> bool:
-        try:
-            return sys.stderr.isatty()
-        except Exception:
-            return False
-
-class File(EnvBase):
-    """Non-interactive file/script run."""
-    def is_active(self) -> bool:
-        # If stderr is not a TTY and not a known notebook/colab/hex, treat as file
-        return (not sys.stderr.isatty()) and ("ipykernel" not in sys.modules) and ("google.colab" not in sys.modules)
-
-    def warn(self, diag: Diagnostic):
-        # just warnings integration (no fancy output)
-        warnings.warn(f"[{diag.name}] {diag.message}", category=RAIWarning, stacklevel=3)
-        self._trace(diag)
-
-    def err(self, diag: Diagnostic, exception: bool = False):
-        self._trace(diag)
-        if exception:
-            raise RAIException(diag)
-
-class Jupyter(EnvBase):
-    prefers_html = True
-    def is_active(self) -> bool:
-        try:
-            from IPython import get_ipython #type: ignore
-            ip = get_ipython()
-            return bool(ip and ip.__class__.__name__.lower().endswith("zmqinteractiveshell"))
-        except Exception:
-            return False
-
-class Colab(EnvBase):
-    prefers_html = True
-    def is_active(self) -> bool:
-        return "google.colab" in sys.modules
-
-class Hex(EnvBase):
-    prefers_html = True
-    def is_active(self) -> bool:
-        # Hex notebooks expose 'HEX_RUN' env or similar; keep flexible
-        return bool(os.getenv("HEX_RUN") or "hex" in sys.modules)
-
-#------------------------------------------------------
-# find env
-#------------------------------------------------------
-
-def find_env():
-    return more_itertools.first_true(
-        [
-            CI(),
-            Terminal(),
-            File(),
-            Jupyter(),
-            Colab(),
-            Hex(),
-        ],
-        pred=lambda k: k.is_active(),
-        default=File(),
-    )
-
-ENV = find_env()

relationalai/util/schema.py

@@ -1,197 +0,0 @@
-from collections import defaultdict
-from functools import lru_cache
-import json
-from pathlib import Path
-import re
-import textwrap
-
-from relationalai.util.error import warn
-from ..config import Config
-from ..config.connections.snowflake import SnowflakeConnection
-
-# config = Config()
-# conn = config.get_connection(SnowflakeConnection, name="snowflake")
-
-# print(conn.get_session().sql("SELECT CURRENT_VERSION()").collect())
-
-#------------------------------------------------------
-# General
-#------------------------------------------------------
-
-CACHE_PATH = Path("build/cache/schemas.json")
-CACHE = {}
-
-def fetch(fqn: str) -> dict[str, str]:
-    """
-    Fetch Concept metadata for a fully-qualified table name.
-
-    - Cache file may or may not exist.
-    - Cache structure is assumed to be { "<db>.<schema>.<table>": { ...Concepts... } }
-    - If the requested FQN is missing from the cache, fetch_snowflake is called and
-      the result is stored back into the cache.
-    """
-    global CACHE
-    database, schema, table = fqn.split(".")
-
-    # Load or initialize cache
-    if not CACHE and CACHE_PATH.exists():
-        with CACHE_PATH.open("r", encoding="utf-8") as f:
-            str_cache: dict[str, dict[str, str]] = json.load(f)
-            CACHE = {k: {ck: cv for ck, cv in v.items()} for k, v in str_cache.items()}
-
-    # If already cached, return it
-    if fqn in CACHE:
-        return CACHE[fqn]
-
-    # Not in cache → fetch from Snowflake
-    result = fetch_snowflake(database, schema, [table])
-    if table not in result:
-        return {}
-
-    CACHE[fqn] = result[table]
-
-    # Write updated cache
-    CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
-    with CACHE_PATH.open("w", encoding="utf-8") as f:
-        str_cache = {k: {ck: cv for ck, cv in v.items()} for k, v in CACHE.items()}
-        json.dump(str_cache, f, indent=2)
-
-    return CACHE[fqn]
-
-#------------------------------------------------------
-# Snowflake
-#------------------------------------------------------
-
-SUPPORTED_SNOWFLAKE_TYPES = [
-    'CHAR', 'STRING', 'VARCHAR', 'BINARY', 'NUMBER', 'FLOAT', 'REAL',
-    'BOOLEAN', 'DATE', 'FIXED', 'TEXT', 'TIME', 'TIMESTAMP_LTZ',
-    'TIMESTAMP_NTZ', 'TIMESTAMP_TZ'
-]
-
-SFTypes = {
-    "TEXT": "String",
-    "FIXED": "Decimal",
-    "DATE": "Date",
-    "TIME": "DateTime",
-    "TIMESTAMP": "DateTime",
-    "TIMESTAMP_LTZ": "DateTime",
-    "TIMESTAMP_TZ": "DateTime",
-    "TIMESTAMP_NTZ": "DateTime",
-    "FLOAT": "Float",
-    "REAL": "Float",
-    "BOOLEAN": "Bool",
-}
-
-SF_ID_REGEX = re.compile(r'^[A-Za-z_][A-Za-z0-9_$]*$')
-
-def quoted(ident: str) -> str:
-    return ident if SF_ID_REGEX.match(ident) or ident.startswith('"') else f'"{ident}"'
-
-@lru_cache()
-def get_provider():
-    from ..shims.executor import get_provider
-    return get_provider()
-
-def fetch_snowflake(database:str, schema:str, table_names:list[str]) -> dict[str, dict[str, str]]:
-    name_lookup = {name.upper(): name for name in table_names}
-
-    tables = ", ".join(f"'{name.upper()}', '{name}'" for name in table_names)
-
-    query = textwrap.dedent(f"""
-        begin
-            SHOW COLUMNS IN SCHEMA {quoted(database)}.{quoted(schema)};
-            let r resultset := (
-                select "table_name", "column_name", "data_type"
-                from table(result_scan(-1)) as t
-                where "table_name" in ({tables})
-            );
-            return table(r);
-        end;
-    """)
-
-    # with debugging.span("fetch_schema", sql=query):
-    try:
-        columns = get_provider().sql(query)
-    except Exception as e:
-        columns = []
-    assert isinstance(columns, list)
-
-    unsupported_columns: dict[str, dict[str, str]] = defaultdict(dict)
-
-    schemas: dict[str, dict[str, str]] = defaultdict(dict)
-    for row in columns:
-        table_name, column_name, data_type = row
-        table_name = name_lookup.get(table_name, table_name)
-        assert table_name is not None
-
-        sf_type_info = json.loads(data_type)
-        typ = sf_type_info.get("type")
-
-        if typ not in SUPPORTED_SNOWFLAKE_TYPES:
-            unsupported_columns[table_name][column_name] = typ
-            continue
-
-        if typ == "FIXED":
-            concept_name = sf_numeric_to_type_str(column_name, sf_type_info)
-        else:
-            concept_name = SFTypes[typ]
-        schemas[table_name][column_name] = concept_name
-
-    for table_name, cols in unsupported_columns.items():
-        col_str = ", ".join(f"{col}({typ})" for col, typ in cols.items())
-        warn("Unsupported Column",
-            f"The following columns in '{database}.{schema}.{table_name}' have unsupported types: {col_str}",
-            [
-                "These columns will not be accessible in your model.",
-                "For the list of supported column types see: https://docs.relational.ai/api/cli/imports/stream/#supported-column-types"
-            ])
-
-    return schemas
-
-
-def digits_to_bits(precision)-> int:
-    """
-    Transform from a number of base 10 digits to the number of bits necessary to represent
-    that. If the precision is larger than 38, return None as that is not supported.
-
-    For example, a number with 38 digits requires 128 bits.
-    """
-    if precision <= 2:
-        return 8
-    elif precision <= 4:
-        return 16
-    elif precision <= 9:
-        return 32
-    elif precision <= 18:
-        return 64
-    elif precision <= 38:
-        return 128
-    raise ValueError(f"Invalid numeric precision '{precision}'")
-
-def sf_numeric_to_type_str(column_name: str, sf_type_info: dict) -> str:
-    """
-    Computes the appropriate type to use for this column. This code reflects exactly
-    the logic currently used by RAI's CDC implementation to ensure we map to the exact
-    same number types.
-    """
-    if "scale" not in sf_type_info or "precision" not in sf_type_info:
-        raise ValueError(
-            f"Invalid definition for column '{column_name}': "
-            "'scale' or 'precision' missing"
-        )
-
-    precision = sf_type_info["precision"]
-    scale = sf_type_info["scale"]
-
-    if scale > precision or scale < 0 or scale > 37:
-        raise ValueError(
-            f"Invalid numeric scale '{scale}' for column '{column_name}'"
-        )
-
-    if scale == 0:
-        # Integers (load_csv only supports these two (and not 8/16/32 bit ints)
-        bits = digits_to_bits(precision)
-        # return Int128 if bits == 128 else Int64
-        return f"Decimal(38,0)" if bits == 128 else f"Decimal(18,0)"
-
-    return f"Decimal({precision},{scale})"

relationalai/util/source.py

@@ -1,185 +0,0 @@
-from __future__ import annotations
-import ast
-from dataclasses import dataclass, field
-from functools import lru_cache
-import os
-import sys
-import textwrap
-import dis
-from bisect import bisect_right
-from types import CodeType
-
-cwd = os.getcwd()
-
-#------------------------------------------------------
-# Path utilities
-#------------------------------------------------------
-
-# relpath is a shockingly slow operation, so caching it
-@lru_cache(maxsize=128)
-def relative_path(path: str) -> str:
-    try:
-        return os.path.relpath(path, cwd)
-    except ValueError:
-        return path
-
-#------------------------------------------------------
-# Frame utilities
-#------------------------------------------------------
-
-_line_map_cache = {}
-
-def instruction_line(code, lasti):
-    pairs = _line_map_cache.get(code)
-    if pairs is None:
-        pairs = list(dis.findlinestarts(code))  # (addr, line_number)
-        _line_map_cache[code] = pairs
-
-    idx = bisect_right(pairs, (lasti, float("inf"))) - 1
-    if idx < 0:
-        return code.co_firstlineno
-    return pairs[idx][1]
-
-def first_non_relationalai_frame():
-    frame = sys._getframe(2)  # skip this function and the previous one
-    while frame and frame.f_back:
-        mod_name = frame.f_globals.get("__name__", "")
-        if mod_name.startswith("relationalai") or mod_name.startswith("v0.relationalai"):
-            frame = frame.f_back
-            continue
-        return frame
-    return frame
-
-#------------------------------------------------------
-# Source utilities
-#------------------------------------------------------
-
-@lru_cache(maxsize=128)
-def get_source_code(filename: str) -> str|None:
-    """Get the source code of a file."""
-    try:
-        with open(filename, "r") as f:
-            return f.read()
-    except Exception:
-        return None
-
-parses = {}
-def find_root_expression(source_code: str, target_line: int, relative_filename: str):
-    # Parse the source code into an AST
-    if relative_filename not in parses:
-        parses[relative_filename] = ast.parse(source_code)
-    tree = parses[relative_filename]
-
-    class ExpressionChainFinder(ast.NodeVisitor):
-        def __init__(self, target_line):
-            self.target_line = target_line
-            self.candidates = []
-
-        def visit(self, node):
-            # Consider all expression nodes, including Call nodes
-            is_expr_node = isinstance(node, (ast.Expr, ast.Call, ast.Attribute, ast.BinOp,
-                                          ast.UnaryOp, ast.IfExp, ast.Compare, ast.Subscript,
-                                          ast.Dict, ast.List, ast.Tuple, ast.Set))
-
-            if hasattr(node, "lineno") and is_expr_node:
-                end_lineno = getattr(node, "end_lineno", node.lineno)
-
-                # Check if this node contains our target line
-                if node.lineno <= self.target_line <= end_lineno:
-                    # Store the node with its line span information
-                    self.candidates.append((node, node.lineno, end_lineno))
-
-            # Continue visiting children
-            for child in ast.iter_child_nodes(node):
-                self.visit(child)
-
-    finder = ExpressionChainFinder(target_line)
-    finder.visit(tree)
-
-    if finder.candidates:
-        # Sort candidates by their starting line (ascending) and then by span size (descending)
-        # This prioritizes expressions that start earlier and cover more lines
-        sorted_candidates = sorted(finder.candidates,
-                                  key=lambda x: (x[1], -(x[2] - x[1])))
-
-        # Find the outermost expression that contains our target line
-        # This will capture the entire multi-line function call
-        outermost_candidates = []
-        for node, start_line, end_line in sorted_candidates:
-            # Check if this is a new candidate or extends an existing one
-            if not outermost_candidates or start_line < outermost_candidates[0][1]:
-                outermost_candidates = [(node, start_line, end_line)]
-
-            # If we have a node that starts at the same line but ends later, prefer it
-            elif start_line == outermost_candidates[0][1] and end_line > outermost_candidates[0][2]:
-                outermost_candidates = [(node, start_line, end_line)]
-
-        if outermost_candidates:
-            node, start_line, end_line = outermost_candidates[0]
-
-            # Extract the lines from the source code
-            block_lines = source_code.splitlines()[start_line - 1:end_line]
-            block_code = "\n".join(block_lines)
-            return SourcePos(relative_filename, _line=start_line, _source=textwrap.dedent(block_code))
-
-    # If no nodes were found, return the single line
-    lines = source_code.splitlines()
-    if target_line > len(lines):
-        return SourcePos(relative_filename, _line=target_line)
-    return SourcePos(relative_filename, _line=target_line, _source=lines[target_line - 1])
-
-#------------------------------------------------------
-# SourcePos
-#------------------------------------------------------
-
-counts = 0
-
-@dataclass(slots=True)
-class SourcePos:
-    file: str = field(default="Unknown")
-    _block:SourcePos|None = None
-    _lasti: int|None = field(default=0)
-    _pycode: CodeType|None = field(default=None)
-    _source: str|None = field(default=None)
-    _line: int|None = field(default=None)
-
-    @classmethod
-    def new(cls):
-        caller_frame = first_non_relationalai_frame()
-        if not caller_frame:
-            return cls()
-
-        filename = caller_frame.f_code.co_filename
-        lasti = caller_frame.f_lasti
-        pycode = caller_frame.f_code
-
-        return cls(filename, _lasti=lasti, _pycode=pycode)
-
-    @property
-    def line(self):
-        if self._line is None and self._pycode:
-            self._line = instruction_line(self._pycode, self._lasti)
-        return self._line or 0
-
-    @property
-    def source(self):
-        if self._source is None and self.file:
-            self._source = get_source_code(self.file)
-        return self._source or ""
-
-    @property
-    def block(self):
-        if not self.source or not self.line:
-            return SourcePos()
-        if not self._block:
-            self._block = find_root_expression(self.source, self.line, self.file)
-        return self._block
-
-    def transform(self, transformer:ast.NodeTransformer) -> SourcePos|None:
-        if not self.block or not self.block.source:
-            return
-
-        new_ast = transformer.visit(ast.parse(self.block.source))
-        new_source = ast.unparse(new_ast)
-        new = SourcePos(self.file, _line=self.line, _source=new_source)
-        return new

relationalai/util/structures.py

@@ -1,163 +0,0 @@
-from __future__ import annotations
-from collections.abc import Iterable, Iterator, MutableSet
-from typing import Callable, Generic, Hashable, TypeVar
-
-T = TypeVar("T")
-
-#------------------------------------------------------
-# OrderedSet
-#------------------------------------------------------
-
-class OrderedSet(Generic[T], MutableSet[T]):
-    __slots__ = ("_dict",)
-    _dict: dict[T, None]
-
-    def __init__(self, iterable: Iterable[T] | None = None) -> None:
-        self._dict = {}
-        if iterable is not None:
-            self.update(iterable)
-
-    def __contains__(self, item: object) -> bool:  # type: ignore[override]
-        return item in self._dict
-
-    def __iter__(self) -> Iterator[T]:
-        return iter(self._dict.keys())
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def __getitem__(self, index: int) -> T:
-        if index < 0:
-            index += len(self._dict)
-        if index < 0 or index >= len(self._dict):
-            raise IndexError("OrderedSet index out of range")
-        for i, key in enumerate(self._dict):
-            if i == index:
-                return key
-        # This point should never be reached
-        raise IndexError("OrderedSet index out of range")
-
-    def add(self, value: T) -> None:
-        if value not in self._dict:
-            self._dict[value] = None
-
-    def discard(self, value: T) -> None:
-        self._dict.pop(value, None)
-
-    def update(self, iterable: Iterable[T]) -> None:
-        for x in iterable:
-            self.add(x)
-
-    def first(self) -> T | None:
-        for x in self._dict:
-            return x
-        return None
-
-    def try_replace(self, old: T, new: T) -> None:
-        """Replace a potentially existing item with a new one, keeping its position if possible."""
-        if new in self._dict or old not in self._dict:
-            return
-        self._dict = { (new if k == old else k): None for k in self._dict }
-
-    def __repr__(self) -> str:
-        items = ", ".join(repr(x) for x in self._dict)
-        return f"OrderedSet([{items}])"
-
-#------------------------------------------------------
-# KeyedDict
-#------------------------------------------------------
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-class KeyedDict(Generic[K, V]):
-    __slots__ = ("_dict", "_key")
-    _dict: dict[Hashable, tuple[K, V]]
-    _key: Callable[[K], Hashable]
-
-    def __init__(self, key: Callable[[K], Hashable], iterable: Iterable[tuple[K, V]] | None = None) -> None:
-        self._dict = {}
-        self._key = key
-        for k, v in iterable or ():
-            self._dict[self._key(k)] = (k, v)
-
-    def __setitem__(self, k: K, v: V) -> None:
-        self._dict[self._key(k)] = (k, v)
-
-    def __getitem__(self, k: K) -> V:
-        return self._dict[self._key(k)][1]
-
-    def __delitem__(self, k: K) -> None:
-        del self._dict[self._key(k)]
-
-    def __contains__(self, k: object) -> bool:
-        try: return self._key(k) in self._dict  # type: ignore[arg-type]
-        except Exception: return False
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def get(self, k: K, default: V | None = None) -> V | None:
-        entry = self._dict.get(self._key(k))
-        return default if entry is None else entry[1]
-
-    def items(self) -> Iterator[tuple[K, V]]:
-        yield from self._dict.values()
-
-    def values(self) -> Iterator[V]:
-        for _, v in self._dict.values():
-            yield v
-
-    def update(self, iterable: KeyedDict[K, V]|Iterable[tuple[K, V]]) -> None:
-        if isinstance(iterable, KeyedDict):
-            self._dict.update(iterable._dict)
-        else:
-            for k, v in iterable:
-                self._dict[self._key(k)] = (k, v)
-
-
-#------------------------------------------------------
-# KeyedSet
-#------------------------------------------------------
-
-class KeyedSet(Generic[K], MutableSet[K]):
-    __slots__ = ("_dict", "_key")
-    _dict: dict[Hashable, K]
-    _key: Callable[[K], Hashable]
-
-    def __init__(self, key: Callable[[K], Hashable], iterable: Iterable[K] | None = None) -> None:
-        self._dict = {}
-        self._key = key
-        if iterable is not None:
-            self.update(iterable)
-
-    def __contains__(self, item: K) -> bool:  # type: ignore[override]
-        return self._key(item) in self._dict
-
-    def __iter__(self) -> Iterator[K]:
-        return iter(self._dict.values())
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def add(self, value: K) -> None:
-        if self._key(value) not in self._dict:
-            self._dict[self._key(value)] = value
-
-    def discard(self, value: K) -> None:
-        self._dict.pop(self._key(value), None)
-
-    def update(self, iterable: Iterable[K]) -> None:
-        for x in iterable:
-            self.add(x)
-
-    def first(self) -> K | None:
-        for _, v in self._dict.items():
-            return v
-        return None
-
-    def __repr__(self) -> str:
-        items = ", ".join(repr(x) for x in self._dict)
-        return f"KeyedSet([{items}])"
-
-