relationalai 1.0.0a4__tar.gz → 1.0.0a5__tar.gz

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 1.0.0a4
+Version: 1.0.0a5
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: lqp==0.1.19
+Requires-Dist: lqp
 Requires-Dist: snowflake-connector-python[secure-local-storage]
 Requires-Dist: snowflake-snowpark-python>=1.38.0
 Requires-Dist: typing-extensions
@@ -32,6 +32,7 @@ Requires-Dist: pyjwt
 Requires-Dist: more-itertools
 Requires-Dist: sqlglot
 Requires-Dist: pyyaml
+Requires-Dist: confocal
 Requires-Dist: pydantic<2.12.0,>=2.0.0
 Requires-Dist: pydantic-settings<2.11.0,>=2.0.0
 Requires-Dist: tomlkit

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = 'relationalai'
-version = '1.0.0a4'
+version = '1.0.0a5'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [
     { name="RelationalAI", email="support@relational.ai" },
 ]
-requires-python = ">= 3.10"
+requires-python = ">= 3.10, <3.14"
 dependencies = [
-    "lqp==0.1.19",
+    "lqp",
     "snowflake-connector-python[secure-local-storage]",
     "snowflake-snowpark-python>=1.38.0",
     "typing-extensions",
@@ -35,8 +35,7 @@ dependencies = [
     "more-itertools",
     "sqlglot",
     "pyyaml",
-    # TODO: Add back when confocal is published to PyPI
-    # "confocal @ git+https://github.com/joshuafcole/confocal.git",
+    "confocal",
     "pydantic>=2.0.0,<2.12.0",
     "pydantic-settings>=2.0.0,<2.11.0",
     "tomlkit",
@@ -63,10 +62,22 @@ exclude = []
 
 [tool.pyright]
 include = ["src", "tests", "example"]
-exclude = ["**/node_modules", "**/__pycache__", "**/.*"]
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", "src/v0/**", "src/relationalai/shims/**", "tests/unified/tests/dry_run/**", "tests/unified/tests/pragmas/**", "tests/unified/tests/tables/**", "tests/unified/tests/warnings/**", "tests/reasoners/graphs/**", "tests/shims/**", "tests/tpch/**", "tests/unified/test_all.py"]
 useLibraryCodeForTypes = true
 reportMissingImports = true
 reportMissingTypeStubs = false
-pythonVersion = "3.10"
+pythonVersion = "3.13"
+venvPath = "."
+venv = ".venv"
 typeCheckingMode = "standard"
 reportUnusedExpression = false
+
+[tool.pytest.ini_options]
+markers = [
+    "experimental: marks tests as experimental/loopy (deselect with '-m \"not experimental\"')",
+]
+addopts = "-m 'not experimental'"
+filterwarnings = [
+  "ignore:Type google\\._upb\\._message\\.MessageMapContainer uses PyType_Spec:DeprecationWarning",
+  "ignore:Type google\\._upb\\._message\\.ScalarMapContainer uses PyType_Spec:DeprecationWarning",
+]

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/src/relationalai/config/config.py

@@ -6,32 +6,28 @@ Main configuration class for PyRel (YAML-based).
 from __future__ import annotations
 
 from abc import ABC
-from typing import Any, TypeVar, overload, Literal, TYPE_CHECKING
+from typing import Any, TypeVar, overload, Literal, TYPE_CHECKING, cast
 from pydantic import Field, model_validator
 from pydantic_settings import SettingsConfigDict
-
-try:
-    from confocal import BaseConfig
-except ImportError:
-    # Confocal not yet published to PyPI - use pydantic_settings as fallback
-    # Config system not actively used yet, this is just to prevent import errors
-    from pydantic_settings import BaseSettings as BaseConfig  # type: ignore[misc, assignment]
+from confocal import BaseConfig
 
 if TYPE_CHECKING:
     import snowflake.snowpark
-    import duckdb
+    import duckdb  # type: ignore[import-not-found]
+    import requests
 
-from .connections import ConnectionConfig, BaseConnection, SnowflakeConnection, DuckDBConnection
+from .connections import ConnectionConfig, BaseConnection, SnowflakeConnection, DuckDBConnection, LocalConnection
 from .config_fields import EngineConfig, DataConfig, CompilerConfig, ModelConfig, ReasonerConfig, DebugConfig
 from .external.dbt_converter import convert_dbt_to_rai
 from .external.snowflake_converter import convert_snowflake_to_rai
-from .external.utils import find_dbt_profiles_file, find_snowflake_config_file
+from .external.raiconfig_converter import convert_raiconfig_to_rai
+from .external.utils import find_dbt_profiles_file, find_snowflake_config_file, find_raiconfig_toml_file
 
 # TypeVar for generic connection retrieval
 T = TypeVar('T', bound=BaseConnection)
 
 
-class _Config(BaseConfig, ABC): # type: ignore for now until we publish confocal
+class _Config(BaseConfig, ABC):
     """Base configuration class with common fields and methods."""
 
     active_profile: str | None = Field(
@@ -171,6 +167,8 @@ class _Config(BaseConfig, ABC): # type: ignore for now until we publish confocal
                 connection_class = "SnowflakeConnection"
             elif isinstance(connection, DuckDBConnection):
                 connection_class = "DuckDBConnection"
+            elif isinstance(connection, LocalConnection):
+                connection_class = "LocalConnection"
             else:
                 connection_class = actual_type
 
@@ -179,18 +177,15 @@ class _Config(BaseConfig, ABC): # type: ignore for now until we publish confocal
                 f"Got: {connection_class} (actual: {actual_type})"
             )
 
-        return connection
-
-    @overload
-    def get_session(self, connection_type: type[SnowflakeConnection]) -> snowflake.snowpark.Session: ...
+        return cast(T, connection)
 
     @overload
-    def get_session(self, connection_type: type[DuckDBConnection]) -> duckdb.DuckDBPyConnection: ...
+    def get_session(self) -> snowflake.snowpark.Session | duckdb.DuckDBPyConnection | requests.Session: ...
 
     @overload
-    def get_session(self, connection_type: None = None) -> snowflake.snowpark.Session | duckdb.DuckDBPyConnection: ...
+    def get_session(self, connection_type: type[SnowflakeConnection] | type[DuckDBConnection] | type[LocalConnection]) -> snowflake.snowpark.Session | duckdb.DuckDBPyConnection | requests.Session: ...
 
-    def get_session(self, connection_type: type[SnowflakeConnection] | type[DuckDBConnection] | None = None) -> snowflake.snowpark.Session | duckdb.DuckDBPyConnection:
+    def get_session(self, connection_type: type[SnowflakeConnection] | type[DuckDBConnection] | type[LocalConnection] | None = None) -> snowflake.snowpark.Session | duckdb.DuckDBPyConnection | requests.Session:
         if connection_type is None:
             connection = self.get_default_connection()
             return connection.get_session()
@@ -250,6 +245,35 @@ class ConfigFromDBT(_Config):
         return convert_dbt_to_rai(data)
 
 
+class ConfigFromRAIConfigToml(_Config):
+    """Config loaded from deprecated raiconfig.toml (for backwards compatibility)"""
+
+    source: Literal["raiconfig_toml"] = Field(default="raiconfig_toml", exclude=True)
+
+    model_config = SettingsConfigDict(
+        toml_file=find_raiconfig_toml_file(),
+        extra="ignore",
+        nested_model_default_partial_update=True,
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def convert_raiconfig_structure(cls, data: Any):
+        """Convert deprecated raiconfig.toml format to new format."""
+        if not isinstance(data, dict):
+            return data
+
+        # Add deprecation warning
+        import warnings
+        warnings.warn(
+            "raiconfig.toml is deprecated. Please migrate to raiconfig.yaml.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        return convert_raiconfig_to_rai(data)
+
+
 # =============================================================================
 # Config Factory - Tries each source in order
 # =============================================================================
@@ -258,11 +282,13 @@ def Config(**data) -> _Config:
     """
     Create Config by trying multiple sources in priority order:
     1. RAIConfig (raiconfig.yaml) - or direct data if provided
-    2. ConfigFromSnowflake (config.toml) - only if no data provided
-    3. ConfigFromDBT (profiles.yml) - only if no data provided
+    2. ConfigFromRAIConfigToml (raiconfig.toml - DEPRECATED) - only if no data provided
+    3. ConfigFromSnowflake (config.toml) - only if no data provided
+    4. ConfigFromDBT (profiles.yml) - only if no data provided
     """
     sources = [
         ("RAIConfig (raiconfig.yaml)", RAIConfig, True),      # passes **data
+        ("ConfigFromRAIConfigToml (raiconfig.toml - DEPRECATED)", ConfigFromRAIConfigToml, False),
         ("ConfigFromSnowflake (config.toml)", ConfigFromSnowflake, False),
         ("ConfigFromDBT (profiles.yml)", ConfigFromDBT, False),
     ]

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/src/relationalai/config/connections/__init__.py

@@ -5,8 +5,9 @@ This module exports:
 - BaseConnection: Base class for all connections
 - Snowflake authenticators: UsernamePasswordAuth, UsernamePasswordMFAAuth, etc.
 - DuckDBConnection: DuckDB connection
+- LocalConnection: Local RAI server connection
 - SnowflakeConnection: Discriminated union of Snowflake authenticators
-- ConnectionConfig: Top-level discriminated union (Snowflake | DuckDB)
+- ConnectionConfig: Top-level discriminated union (Snowflake | DuckDB | Local)
 """
 
 from __future__ import annotations
@@ -26,9 +27,10 @@ from .snowflake import (
     SnowflakeAuthenticator,
 )
 from .duckdb import DuckDBConnection
+from .local import LocalConnection
 
 ConnectionConfig = Annotated[
-    Union[SnowflakeAuthenticator, DuckDBConnection],
+    Union[SnowflakeAuthenticator, DuckDBConnection, LocalConnection],
     Field(discriminator="type")
 ]
 
@@ -42,5 +44,6 @@ __all__ = [
     "ProgrammaticAccessTokenAuth",
     "SnowflakeConnection",
     "DuckDBConnection",
+    "LocalConnection",
     "ConnectionConfig",
 ]

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/src/relationalai/config/connections/duckdb.py

@@ -4,7 +4,7 @@ from typing import Literal, Any, TYPE_CHECKING
 from pydantic import Field
 
 if TYPE_CHECKING:
-    import duckdb
+    import duckdb  # type: ignore[import-not-found]
 
 from .base import BaseConnection
 
@@ -17,7 +17,7 @@ class DuckDBConnection(BaseConnection):
     config: dict[str, Any] | None = Field(None, description="Additional DuckDB configuration options")
 
     def get_session(self) -> duckdb.DuckDBPyConnection:
-        import duckdb
+        import duckdb  # type: ignore[import-not-found]
 
         if self._cached_session is None:
             self._cached_session = duckdb.connect(

relationalai-1.0.0a5/src/relationalai/config/connections/local.py

@@ -0,0 +1,31 @@
+"""Local server connection configuration."""
+
+from __future__ import annotations
+
+from typing import Literal, TYPE_CHECKING
+from pydantic import Field
+
+if TYPE_CHECKING:
+    import requests
+
+from .base import BaseConnection
+
+
+class LocalConnection(BaseConnection):
+    """Connection to a local RAI server."""
+
+    type: Literal["local"] = "local"
+
+    host: str = Field(default="localhost", description="Local server host")
+    port: int = Field(default=8010, description="Local server port")
+    engine: str | None = Field(default=None, description="Engine name")
+
+    def get_session(self) -> requests.Session:
+        """Return a requests.Session instance for the local server."""
+        # Should we migrate to using LocalClient to PyRel V1?
+        from v0.relationalai.clients.local import LocalClient  # type: ignore[import-not-found]
+
+        if self._cached_session is None:
+            self._cached_session = LocalClient(host=self.host, port=self.port).http_session
+
+        return self._cached_session

{relationalai-1.0.0a4 → relationalai-1.0.0a5}/src/relationalai/config/connections/snowflake.py

@@ -71,7 +71,6 @@ class UsernamePasswordAuth(SnowflakeConnectionBase):
             "password": cast(SecretStr, self.password).get_secret_value(),
             "account": self.account,
             "warehouse": self.warehouse,
-            "authenticator": self.authenticator,
         }
 
 

relationalai-1.0.0a5/src/relationalai/config/external/raiconfig_converter.py

@@ -0,0 +1,235 @@
+"""
+Converter for deprecated raiconfig.toml to RAI Config format.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .raiconfig_models import RAIConfigFile, RAIConfigSnowflakeProfile, RAIConfigLocalProfile
+
+
+# Central field mapping configuration
+# Format: "old_field_name": ("new_section", "new_field_name")
+# where section=None means top-level field
+FIELD_MAPPINGS = {
+    # Top-level fields (stay at top level)
+    "use_graph_index": (None, "use_graph_index"),
+    "use_direct_access": (None, "use_direct_access"),
+    "enable_otel_handler": (None, "enable_otel_handler"),
+    "use_package_manager": (None, "use_package_manager"),
+    "reuse_model": (None, "reuse_model"),
+    "skip_invalid_data": (None, "skip_invalid_data"),
+
+    # Engine fields
+    "engine": ("engine", "name"),
+    "engine_size": ("engine", "size"),
+    "auto_suspend_mins": ("engine", "auto_suspend_mins"),
+
+    # Data fields
+    "wait_for_stream_sync": ("data", "wait_for_stream_sync"),
+    "ensure_change_tracking": ("data", "ensure_change_tracking"),
+    "data_freshness_mins": ("data", "data_freshness_mins"),
+    "query_timeout_mins": ("data", "query_timeout_mins"),
+    "download_url_type": ("data", "download_url_type"),
+
+    # Debug fields
+    "debug": ("debug", "enabled"),  # Note: maps to "enabled"!
+    "show_full_traces": ("debug", "show_full_traces"),
+
+    # Compiler fields
+    "use_monotype_operators": ("compiler", "use_monotype_operators"),
+    "show_corerel_errors": ("compiler", "show_corerel_errors"),
+    "dry_run": ("compiler", "dry_run"),
+    "inspect_df": ("compiler", "inspect_df"),
+    "use_value_types": ("compiler", "use_value_types"),
+    "debug_hidden_keys": ("compiler", "debug_hidden_keys"),
+    "wide_outputs": ("compiler", "wide_outputs"),
+    "strict": ("compiler", "strict"),
+    "use_inlined_intermediates": ("compiler", "use_inlined_intermediates"),
+    "inline_value_maps": ("compiler", "inline_value_maps"),
+    "inline_entity_maps": ("compiler", "inline_entity_maps"),
+
+    # Model fields
+    "keep": ("model", "keep"),
+    "isolated": ("model", "isolated"),
+    "nowait_durable": ("model", "nowait_durable"),
+}
+
+# Connection fields (stay in connection dict)
+CONNECTION_FIELDS = {
+    "account", "warehouse", "user", "password", "role", "database", "schema",
+    "authenticator", "rai_app_name", "passcode",
+    "private_key_path", "private_key_passphrase", "token",
+}
+
+# Old -> New field name mappings for connection fields
+# Old field names from deprecated raiconfig.toml are mapped to new names
+# These are accessed via model_extra in RAIConfigSnowflakeProfile.convert()
+CONNECTION_FIELD_MAPPINGS = {
+    "private_key_file": "private_key_path",
+    "private_key_file_pwd": "private_key_passphrase",
+    "token_file_path": "token",
+}
+
+
+def map_fields_to_nested_structure(merged: dict[str, Any]) -> dict[str, Any]:
+    """
+    Map flat config fields to nested structure using FIELD_MAPPINGS.
+
+    This replaces all the manual if statements!
+
+    Args:
+        merged: Flat dictionary with all config fields
+
+    Returns:
+        Nested dictionary structured according to new config format
+    """
+    result = {}
+    nested_sections = {}  # Collect fields for each section
+
+    for old_field, (section, new_field) in FIELD_MAPPINGS.items():
+        if old_field not in merged or merged[old_field] is None:
+            continue  # Skip missing or None values
+
+        value = merged[old_field]
+
+        if section is None:
+            # Top-level field
+            result[new_field] = value
+        else:
+            # Nested section field
+            if section not in nested_sections:
+                nested_sections[section] = {}
+            nested_sections[section][new_field] = value
+
+    # Add nested sections to result
+    for section, fields in nested_sections.items():
+        if fields:  # Only add non-empty sections
+            result[section] = fields
+
+    return result
+
+
+def merge_profile_with_toplevel(
+    config_file: RAIConfigFile,
+    profile: RAIConfigSnowflakeProfile | RAIConfigLocalProfile
+) -> dict[str, Any]:
+    """
+    Merge profile over top-level config (profile takes precedence).
+
+    This matches the v0 behavior where profile-specific settings override
+    global defaults.
+    """
+    # Start with top-level config
+    merged = config_file.model_dump(
+        exclude={"profile", "active_profile"},
+        exclude_none=True
+    )
+
+    # Overlay profile fields (they take precedence)
+    profile_dict = profile.model_dump(exclude_none=True)
+
+    # Merge profile into config (profile overrides top-level)
+    merged.update(profile_dict)
+
+    return merged
+
+
+def convert_raiconfig_to_rai(
+    rai_config: dict[str, Any],
+    profile_name: str | None = None
+) -> dict[str, Any]:
+    """
+    Convert deprecated raiconfig.toml to new RAI Config format.
+
+    Flow:
+    1. Validate with RAIConfigFile model
+    2. Select active profile (parameter > active_profile > single profile)
+    3. Merge profile over top-level config (profile takes precedence)
+    4. Extract connection from profile
+    5. Map flat fields to nested structure
+
+    Args:
+        rai_config: Parsed TOML config dict
+        profile_name: Profile name to use (overrides active_profile)
+
+    Returns:
+        Dict in new config format ready for RAIConfig model
+    """
+    config_file = RAIConfigFile(**rai_config)
+
+    # Profile selection logic
+    if not profile_name:
+        profile_name = config_file.active_profile
+
+    # Supported platforms
+    supported_platforms = {"snowflake", "local"}
+
+    # Filter to supported profiles (Snowflake and Local)
+    supported_profiles = {
+        name: data for name, data in config_file.profile.items()
+        if data.get("platform", "snowflake") in supported_platforms
+    }
+
+    if not profile_name and len(supported_profiles) == 1:
+        # Auto-select single supported profile
+        profile_name = next(iter(supported_profiles.keys()))
+
+    if not profile_name:
+        if not supported_profiles:
+            raise ValueError(
+                "No supported profiles found in raiconfig.toml. "
+                "Supported platforms: snowflake, local. "
+                "Please add a supported profile or migrate to raiconfig.yaml."
+            )
+        raise ValueError(
+            f"No profile specified. Either set 'active_profile' in config, "
+            f"provide profile_name parameter, or ensure only one supported profile exists. "
+            f"Available profiles: {list(supported_profiles.keys())}"
+        )
+
+    if profile_name not in config_file.profile:
+        available = list(config_file.profile.keys())
+        raise ValueError(
+            f"Profile '{profile_name}' not found. Available profiles: {available}"
+        )
+
+    # Get profile data
+    profile_data = config_file.profile[profile_name]
+    platform = profile_data.get("platform", "snowflake")
+
+    # Validate and convert based on platform
+    if platform == "local":
+        profile = RAIConfigLocalProfile(**profile_data)
+        connection = profile.convert()
+        connection_name = "local"
+    elif platform == "snowflake":
+        profile = RAIConfigSnowflakeProfile(**profile_data)
+        connection = profile.convert()
+        connection_name = "snowflake"
+    else:
+        raise ValueError(
+            f"Profile '{profile_name}' uses platform '{platform}'. "
+            f"Supported platforms: snowflake, local. "
+            f"Please use a supported profile or migrate to raiconfig.yaml."
+        )
+
+    # Merge profile with top-level config
+    merged = merge_profile_with_toplevel(config_file, profile)
+
+    # Build base result
+    result = {
+        "connections": {connection_name: connection},
+        "default_connection": connection_name,
+    }
+
+    # Map all config fields automatically using FIELD_MAPPINGS
+    mapped_fields = map_fields_to_nested_structure(merged)
+    result.update(mapped_fields)
+
+    # Handle reasoner separately (nested dict structure)
+    if "reasoner" in merged and merged["reasoner"]:
+        result["reasoner"] = merged["reasoner"]
+
+    return result