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

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/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/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/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/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/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

relationalai/config/external/raiconfig_models.py

@@ -0,0 +1,202 @@
+"""
+Pydantic models for deprecated raiconfig.toml structure.
+
+These models validate the structure of deprecated raiconfig.toml files before
+converting them to RAI Config format.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def normalize_authenticator(authenticator: str | None) -> str:
+    """Normalize old authenticator names to new format."""
+    if not authenticator:
+        return "username_password"
+
+    auth = authenticator.lower()
+
+    mapping = {
+        "snowflake": "username_password",
+        "username_password": "username_password",
+        "username_password_mfa": "username_password_mfa",
+        "externalbrowser": "externalbrowser",
+        "jwt": "jwt",
+        "snowflake_jwt": "jwt",
+        "oauth": "oauth",
+        "programmatic_access_token": "programmatic_access_token",
+    }
+
+    return mapping.get(auth, "username_password")
+
+
+class RAIConfigSnowflakeProfile(BaseModel):
+    """Snowflake profile in deprecated raiconfig.toml."""
+    model_config = ConfigDict(extra="allow")
+
+    platform: Literal["snowflake"]
+
+    # Required connection fields
+    account: str
+    warehouse: str
+
+    # Auth fields (required by some authenticators)
+    user: str | None = None
+    password: str | None = None
+
+    # Optional connection fields
+    role: str | None = None
+    database: str | None = None
+    schema_: str | None = Field(default=None, alias="schema")
+    authenticator: str | None = None
+    rai_app_name: str = "RELATIONALAI"
+
+    # Auth-specific fields
+    passcode: str | None = None              # MFA
+    private_key_path: str | None = None      # JWT
+    private_key_passphrase: str | None = None
+    token: str | None = None                 # OAuth/PAT
+
+    # Optional override fields (can also be top-level)
+    engine: str | None = None
+    engine_size: str | None = None
+    auto_suspend_mins: int | None = None
+    data_freshness_mins: int | None = None
+    query_timeout_mins: int | None = None
+    download_url_type: Literal["internal", "external"] | None = None
+    wait_for_stream_sync: bool | None = None
+    ensure_change_tracking: bool | None = None
+
+    # Debug fields (can be in profile or top-level)
+    debug: bool | None = None
+    show_full_traces: bool | None = None
+
+    # Other top-level fields that can be in profiles
+    use_graph_index: bool | None = None
+    use_direct_access: bool | None = None
+    skip_invalid_data: bool | None = None
+    use_package_manager: bool | None = None
+    enable_otel_handler: bool | None = None
+    reuse_model: bool | None = None
+
+    # Compiler fields (can be in profile or top-level)
+    use_monotype_operators: bool | None = None
+    show_corerel_errors: bool | None = None
+    dry_run: bool | None = None
+    inspect_df: bool | None = None
+    use_value_types: bool | None = None
+    debug_hidden_keys: bool | None = None
+    wide_outputs: bool | None = None
+    strict: bool | None = None
+    use_inlined_intermediates: bool | None = None
+    inline_value_maps: bool | None = None
+    inline_entity_maps: bool | None = None
+
+    # Model fields (can be in profile or top-level)
+    keep: bool | None = None
+    isolated: bool | None = None
+    nowait_durable: bool | None = None
+
+    def convert(self) -> dict[str, Any]:
+        """Convert to new connection format."""
+        # Import here to avoid circular dependency
+        from .raiconfig_converter import FIELD_MAPPINGS, CONNECTION_FIELD_MAPPINGS
+
+        excluded_fields = set(FIELD_MAPPINGS.keys()) | {"platform"}
+
+        connection_dict = self.model_dump(
+            exclude_none=True,
+            by_alias=True,
+            exclude=excluded_fields
+        )
+
+        connection_dict["type"] = "snowflake"
+        connection_dict["authenticator"] = normalize_authenticator(self.authenticator)
+
+        # Map old field names to new field names (from model_extra, since old names aren't explicit fields)
+        extra = self.model_extra or {}
+        for old_name, new_name in CONNECTION_FIELD_MAPPINGS.items():
+            old_value = extra.get(old_name)
+            new_value = getattr(self, new_name, None)
+            # Use new name if set, otherwise fall back to old name
+            final_value = new_value if new_value is not None else old_value
+            if final_value is not None:
+                connection_dict[new_name] = final_value
+
+        return connection_dict
+
+
+class RAIConfigLocalProfile(BaseModel):
+    """Local profile in deprecated raiconfig.toml."""
+    model_config = ConfigDict(extra="allow")
+
+    platform: Literal["local"]
+
+    # Connection fields
+    host: str = "localhost"
+    port: int = 8010
+    engine: str | None = None
+
+    def convert(self) -> dict[str, Any]:
+        """Convert to new connection format."""
+        return {
+            "type": "local",
+            "host": self.host,
+            "port": self.port,
+            "engine": self.engine,
+        }
+
+
+class RAIConfigFile(BaseModel):
+    """Root model for deprecated raiconfig.toml."""
+    model_config = ConfigDict(extra="allow")
+
+    # Active profile selection
+    active_profile: str | None = None
+
+    # Top-level config fields (can be overridden by profile)
+    debug: bool = True
+    show_full_traces: bool = False
+    use_graph_index: bool = True
+    use_direct_access: bool = False
+    skip_invalid_data: bool | None = None
+    use_package_manager: bool = True
+    enable_otel_handler: bool = False
+    reuse_model: bool = True
+
+    # Engine config (top-level defaults)
+    auto_suspend_mins: int | None = None
+    engine_size: str | None = None
+
+    # Data config (top-level defaults)
+    wait_for_stream_sync: bool = True
+    ensure_change_tracking: bool = False
+    data_freshness_mins: int | None = None
+    query_timeout_mins: int | None = None
+    download_url_type: Literal["internal", "external"] | None = None
+
+    # Compiler config
+    use_monotype_operators: bool | None = None
+    show_corerel_errors: bool | None = None
+    dry_run: bool | None = None
+    inspect_df: bool | None = None
+    use_value_types: bool | None = None
+    debug_hidden_keys: bool | None = None
+    wide_outputs: bool | None = None
+    strict: bool | None = None
+    use_inlined_intermediates: bool | None = None
+    inline_value_maps: bool | None = None
+    inline_entity_maps: bool | None = None
+
+    # Model config
+    keep: bool | None = None
+    isolated: bool | None = None
+    nowait_durable: bool | None = None
+
+    # Reasoner config (nested [reasoner.rule] sections)
+    reasoner: dict[str, Any] | None = None
+
+    # Profiles (accept any structure, validate Snowflake profiles on-demand)
+    profile: dict[str, dict[str, Any]] = Field(default_factory=dict)

relationalai/config/external/utils.py

@@ -17,3 +17,34 @@ def find_snowflake_config_file() -> str | None:
     if os.path.exists(path):
         return path
     return None
+
+
+def find_raiconfig_toml_file() -> str | None:
+    """
+    Find raiconfig.toml file.
+
+    Search order:
+    1. Current directory upwards (project-level)
+    2. ~/.rai/raiconfig.toml (user-level)
+
+    Returns:
+        Path to raiconfig.toml if found, None otherwise.
+    """
+    # Search upwards from current directory
+    current_dir = os.path.abspath(os.getcwd())
+    while True:
+        file_path = os.path.join(current_dir, "raiconfig.toml")
+        if os.path.exists(file_path):
+            return file_path
+
+        parent_dir = os.path.dirname(current_dir)
+        if parent_dir == current_dir:  # Reached root
+            break
+        current_dir = parent_dir
+
+    # Check user home directory
+    user_config_path = os.path.expanduser("~/.rai/raiconfig.toml")
+    if os.path.exists(user_config_path):
+        return user_config_path
+
+    return None

relationalai/config/shims.py

@@ -1 +1,2 @@
 DRY_RUN=False
+ENFORCE_TYPE_CORRECT=False