relationalai 0.9.16__tar.gz → 0.9.17__tar.gz

{relationalai-0.9.16 → relationalai-0.9.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 0.9.16
+Version: 0.9.17
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 License-File: LICENSE

{relationalai-0.9.16 → relationalai-0.9.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '0.9.16'
+version = '0.9.17'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/auth/token_handler.py

@@ -1,6 +1,7 @@
 import base64
 import hashlib
 import json
+import jwt
 import requests
 import secrets
 import threading
@@ -13,9 +14,9 @@ from typing import Dict, Tuple
 
 from .jwt_generator import JWTGenerator
 from .oauth_callback_server import OAuthCallbackServer
-from .util import is_keyring_secure, is_localhost, extract_port
+from .util import is_keyring_secure, is_localhost, extract_port, remove_url_scheme
 from ..debugging import warn
-from ..errors import RAIException, DirectAccessInvalidAuthException, InsecureKeychainWarning, KeychainFailureWarning, OAuthSSLMismatchException
+from ..errors import RAIException, DirectAccessInvalidAuthException, InsecureKeychainWarning, KeychainFailureWarning
 from ..tools.constants import SNOWFLAKE_DIRECT_ACCESS_AUTHS
 from ..clients.config import Config
 
@@ -33,7 +34,8 @@ class TokenHandler(ABC):
         self._config = config
         self.role: str = str(self._config.get("role", ""))
         self.user: str = str(self._config.get("user", ""))
-        self.account: str = str(self._config.get("account", ""))
+        self.account: str = self._prepare_account_name(str(config.get("account", "")))
+        self._renewal_buffer_time = timedelta(minutes=2)
 
     @staticmethod
     def from_config(config: Config) -> "TokenHandler":
@@ -48,9 +50,38 @@ class TokenHandler(ABC):
         raise DirectAccessInvalidAuthException(authenticator, SNOWFLAKE_DIRECT_ACCESS_AUTHS.keys())
 
     @abstractmethod
-    def get_token(self) -> str:
+    # returns a token which can be used to create a snowflake session object
+    def get_session_login_token(self) -> str:
+        pass
+
+    @abstractmethod
+    # returns a token which can be used to access a specific endpoint in multiple cases this
+    # can be the same token as for session login but is dependent on the authentication
+    # method
+    def get_ingress_token(self, endpoint) -> str:
         pass
 
+    @staticmethod
+    # this helper method is needed to prepare the account name to a format accepted to form 
+    # the snowflake URLs. Without the replacement of '_' with '-' the requests to snowflake
+    # auth endpoints will lead to SSL mismatch errors.
+    def _prepare_account_name(account: str) -> str:
+        return account.replace("_", "-").upper()
+
+    # helper method to retrieve a token from a cache and check if it is expired
+    # assumes the key consisting of the (account, user, role) tuple
+    def _get_token_from_cache(self, cache) -> Tuple:
+        key = (self.account, self.user, self.role)
+        if key in cache:
+            token, expiration_timestamp = cache[key]
+            current_timestamp = datetime.now(timezone.utc).timestamp()
+            # only use cached token if not expired and not close to expiring
+            if expiration_timestamp - self._renewal_buffer_time.total_seconds() > current_timestamp:
+                return token, False
+            else:
+                return "", True
+        return "", False
+
 class SnowflakeOAuthTokenHandler(TokenHandler):
 
     # Global cache to re-use the tokens over multiple threads and resource objects
@@ -85,10 +116,14 @@ class SnowflakeOAuthTokenHandler(TokenHandler):
         self.redirect_port: int = extract_port(self.redirect_uri)
         self.account_url: str = f"https://{self.account}.snowflakecomputing.com"
         self._callback_server = None
-        self._renewal_buffer_time = timedelta(minutes=2)
         self._load_refresh_token_cache()
 
-    def get_token(self) -> str:
+    # performing token retrieval in a thread safe manner. This is needed as multiple
+    # resources are oftentimes created in parallel, leading to multiple token handlers
+    # hitting the Snowflake auth endpoint at the same time and trying to start local
+    # callback servers. Instead we re-suse the retrieved token until the end of its
+    # lifetime over all threads.
+    def get_session_login_token(self) -> str:
         token, expired = self._get_access_token_from_cache()
         if token and not expired:
             return token
@@ -103,6 +138,9 @@ class SnowflakeOAuthTokenHandler(TokenHandler):
 
             auth_code, code_verifier = self._authenticate()
             return self._exchange_code_for_token(auth_code, code_verifier)
+        
+    def get_ingress_token(self, endpoint) -> str:
+        return self.get_session_login_token()
 
     def _get_access_token_from_cache(self) -> Tuple[str, bool]:
         return self._get_token_from_cache(SnowflakeOAuthTokenHandler._token_cache)
@@ -110,18 +148,6 @@ class SnowflakeOAuthTokenHandler(TokenHandler):
     def _get_refresh_token_from_cache(self) -> Tuple[str, bool]:
         return self._get_token_from_cache(SnowflakeOAuthTokenHandler._refresh_token_cache)
 
-    def _get_token_from_cache(self, cache) -> Tuple:
-        key = (self.account, self.user, self.role)
-        if key in cache:
-            token, expiration_timestamp = cache[key]
-            current_timestamp = datetime.now(timezone.utc).timestamp()
-            # only use cached token if not expired and not close to expiring
-            if expiration_timestamp - self._renewal_buffer_time.total_seconds() > current_timestamp:
-                return token, False
-            else:
-                return "", True
-        return "", False
-
     def _get_auth_token_from_cache(self) -> Tuple[str, str, bool]:
         key = (self.account, self.user, self.role)
         if key in SnowflakeOAuthTokenHandler._auth_token_cache:
@@ -266,13 +292,10 @@ class SnowflakeOAuthTokenHandler(TokenHandler):
 
         try:
             response = requests.post(token_url, data=data, headers=headers, auth=auth)
-        except requests.exceptions.SSLError:
-            e = OAuthSSLMismatchException(self.account)
-            raise e
         except Exception as e:
             raise RAIException(f"Error during token exchange: {e}")
         if response.status_code != 200:
-            raise Exception(f"Token exchange failed: {response.status_code} - {response.text}")
+            raise RAIException(f"Token exchange failed: {response.status_code} - {response.text}")
 
         return self._handle_token_response(response, issue_time)
 
@@ -297,12 +320,10 @@ class SnowflakeOAuthTokenHandler(TokenHandler):
 
         try:
             response = requests.post(token_url, data=data, headers=headers, auth=auth)
-        except requests.exceptions.SSLError:
-            raise OAuthSSLMismatchException(self.account)
         except Exception as e:
             raise RAIException(f"Error during token exchange: {e}")
         if response.status_code != 200:
-            raise Exception(f"Token refresh failed: {response.status_code} - {response.text}")
+            raise RAIException(f"Token refresh failed: {response.status_code} - {response.text}")
 
         return self._handle_token_response(response, issue_time, is_refresh=True)
 
@@ -348,10 +369,21 @@ class SnowflakePATHandler(TokenHandler):
         except Exception as e:
             raise RAIException(f"Failed to read personal access token file: {e}")
 
-    def get_token(self) -> str:
+    def get_session_login_token(self) -> str:
+        return self.token
+
+    def get_ingress_token(self, endpoint) -> str:
         return self.token
 
 class SnowflakeKeyFileHandler(TokenHandler):
+    # Global cache to re-use the tokens over multiple threads and resource objects
+    # Maps (account, user, role) to (token, expiration_timestamp)
+    _token_cache: Dict[Tuple[str, str, str], Tuple[str, float]] = dict()
+
+    # To avoid authenticating for multiple threads, we use this lock to let the first thread
+    # authenticate and the others wait for the result retrieved from the global cache
+    _authenticate_lock = threading.Lock()
+
     def __init__(self, config: Config):
         super().__init__(config)
         self.key_file_path = self._config.get("private_key_file")
@@ -360,5 +392,43 @@ class SnowflakeKeyFileHandler(TokenHandler):
         self.key_file_pwd = self._config.get("private_key_file_pwd", "")
         self._jwt_generator = JWTGenerator(self.account, self.user, self.key_file_path, self.key_file_pwd)
 
-    def get_token(self) -> str:
+    def get_session_login_token(self) -> str:
         return self._jwt_generator.get_or_generate_token()
+    
+    # performing token retrieval in a thread safe manner. This is needed as multiple
+    # resources are oftentimes created in parallel, leading to multiple token handlers
+    # hitting the Snowflake auth endpoint at the same time. Instead we re-suse the retrieved
+    # token until the end of its lifetime over all threads.
+    def get_ingress_token(self, endpoint) -> str:
+        with SnowflakeKeyFileHandler._authenticate_lock:
+            token, expired = self._get_token_from_cache(SnowflakeKeyFileHandler._token_cache)
+            if token and not expired:
+                return token
+            
+            generated_jwt_token = self.get_session_login_token()
+            token = self._exchange_token(generated_jwt_token, endpoint)
+            return token
+
+    def _exchange_token(self, token, endpoint):
+        endpoint = remove_url_scheme(endpoint)
+        scope_role = f'session:role:{self.role}' if self.role is not None else None
+        scope = f'{scope_role} {endpoint}' if scope_role is not None else endpoint
+        data = {
+            'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+            'scope': scope,
+            'assertion': token,
+        }
+        url = f'https://{self.account}.snowflakecomputing.com/oauth/token'
+        try:
+            response = requests.post(url, data=data)
+        except Exception as e:
+            raise RAIException(f"Error during token exchange: {e}")
+        if response.status_code != 200:
+            raise RAIException(f"Token exchange failed: {response.status_code} - {response.text}")
+        token = response.text
+        try:
+            expire_timestamp = jwt.decode(token, options={"verify_signature": False})['exp']
+        except Exception as e:
+            raise RAIException(f"Failed to decode exchanged token: {e}")
+        SnowflakeKeyFileHandler._token_cache[(self.account, self.user, self.role)] = (token, expire_timestamp)
+        return token

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/auth/util.py

@@ -23,6 +23,13 @@ def extract_port(url: str) -> int:
         else:
             port = 80
     return port
+
+def remove_url_scheme(url: str) -> str:
+    parsed = urlparse(url)
+    # If there's a scheme, reconstruct without it
+    if parsed.scheme:
+        return parsed.netloc + parsed.path
+    return url
     
 def is_keyring_secure() -> bool:
     if not KEYRING_AVAILABLE or keyring is None:

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/clients/snowflake.py

@@ -47,7 +47,7 @@ from ..clients.client import Client, ExportParams, ProviderBase, ResourcesBase
 from ..clients.util import IdentityParser, escape_for_f_string, get_pyrel_version, get_with_retries, poll_with_specified_overhead, safe_json_loads, sanitize_module_name, scrub_exception, wrap_with_request_id, ms_to_timestamp
 from ..environments import runtime_env, HexEnvironment, SnowbookEnvironment
 from .. import dsl, rel, metamodel as m
-from ..errors import DuoSecurityFailed, EngineAutoCreateFailed, EngineNameValidationException, EngineNotFoundException, EnginePending, EngineSizeMismatchWarning, EngineResumeFailed, Errors, InvalidAliasError, InvalidEngineSizeError, InvalidSourceTypeWarning, RAIAbortedTransactionError, RAIException, HexSessionException, SnowflakeAppMissingException, SnowflakeChangeTrackingNotEnabledException, SnowflakeDatabaseException, SnowflakeImportMissingException, SnowflakeInvalidSource, SnowflakeMissingConfigValuesException, SnowflakeProxyAPIDeprecationWarning, SnowflakeProxySourceError, SnowflakeRaiAppNotStarted, ModelNotFoundException, UnknownSourceWarning, ResponseStatusException, RowsDroppedFromTargetTableWarning
+from ..errors import DuoSecurityFailed, EngineProvisioningFailed, EngineNameValidationException, EngineNotFoundException, EnginePending, EngineSizeMismatchWarning, EngineResumeFailed, Errors, InvalidAliasError, InvalidEngineSizeError, InvalidSourceTypeWarning, RAIAbortedTransactionError, RAIException, HexSessionException, SnowflakeAppMissingException, SnowflakeChangeTrackingNotEnabledException, SnowflakeDatabaseException, SnowflakeImportMissingException, SnowflakeInvalidSource, SnowflakeMissingConfigValuesException, SnowflakeProxyAPIDeprecationWarning, SnowflakeProxySourceError, SnowflakeRaiAppNotStarted, ModelNotFoundException, UnknownSourceWarning, ResponseStatusException, RowsDroppedFromTargetTableWarning
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, date, timedelta
 from snowflake.snowpark.types import StringType, StructField, StructType
@@ -413,7 +413,7 @@ class Resources(ResourcesBase):
             if "authenticator" in connection_parameters and connection_parameters["authenticator"] == "OAUTH_AUTHORIZATION_CODE":
                 # we are replicating OAUTH_AUTHORIZATION_CODE by first retrieving the token
                 # and then authenticating with the token via the OAUTH authenticator
-                connection_parameters["token"] = self.token_handler.get_token()
+                connection_parameters["token"] = self.token_handler.get_session_login_token()
                 connection_parameters["authenticator"] = "OAUTH"
             return Session.builder.configs(connection_parameters).create()
         except snowflake.connector.errors.Error as e:
@@ -468,7 +468,7 @@ class Resources(ResourcesBase):
                 except EngineNameValidationException as e:
                     raise EngineNameValidationException(engine) from e
                 except Exception as e:
-                    raise EngineAutoCreateFailed(engine) from e
+                    raise EngineProvisioningFailed(engine, e) from e
             elif re.search(r"javascript execution error", orig_message):
                 match = re.search(r"\"message\":\"(.*)\"", orig_message)
                 if match:
@@ -693,7 +693,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                 else:
                     self._exec(f"call {APP_NAME}.api.{api}('{name}', '{size}', PARSE_JSON('{{\"auto_suspend_mins\": {auto_suspend_mins}}}'), {headers});")
         except Exception as e:
-            raise Exception(f"Failed to create engine {name} with size {size}: {e}") from e
+            raise EngineProvisioningFailed(name, e) from e
 
     def create_engine(self, name:str, size:str|None=None, auto_suspend_mins:int|None=None, headers: Dict | None = None):
         self._create_engine(name, size, auto_suspend_mins, headers=headers)
@@ -1703,7 +1703,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                                 engine = None
                                 pass
                             else:
-                                raise EngineAutoCreateFailed(engine_name) from e
+                                raise EngineProvisioningFailed(engine_name, e) from e
 
                 if not engine:
                     with Spinner(
@@ -1716,7 +1716,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                 print(e)
                 if DUO_TEXT in str(e).lower():
                     raise DuoSecurityFailed(e)
-                raise EngineAutoCreateFailed(engine_name) from e
+                raise EngineProvisioningFailed(engine_name, e) from e
             return engine_name
 
     def auto_create_engine_async(self, name: str | None = None):
@@ -1792,7 +1792,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                                     pass
                                 else:
                                     print(e)
-                                    EngineAutoCreateFailed(engine_name)
+                                    raise EngineProvisioningFailed(engine_name, e) from e
 
                     if not engine:
                         self.create_engine_async(engine_name, size=self.config.get("engine_size", None))
@@ -1815,7 +1815,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                     if isinstance(e, RAIException):
                         raise e
                     print(e)
-                    raise EngineAutoCreateFailed(engine_name) from e
+                    raise EngineProvisioningFailed(engine_name, e) from e
 
     def validate_engine_size(self, size: str) -> Tuple[bool, List[str]]:
         if size is not None:
@@ -2986,7 +2986,7 @@ class DirectAccessClient:
             request_headers.update(headers)
         # Authorization tokens are not needed in a snowflake notebook environment
         if not self._is_snowflake_notebook:
-            request_headers["Authorization"] = f'Snowflake Token="{self._token_handler.get_token()}"'
+            request_headers["Authorization"] = f'Snowflake Token="{self._token_handler.get_ingress_token(self.service_endpoint)}"'
             # needed for oauth, does no harm for other authentication methods
             request_headers["X-SF-SPCS-Authentication-Method"] = 'OAUTH'
             request_headers["Content-Type"] = 'application/x-www-form-urlencoded'

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/clients/use_index_poller.py

@@ -7,7 +7,7 @@ from relationalai.clients.cache_store import GraphIndexCache
 from relationalai.clients.util import get_pyrel_version, poll_with_specified_overhead
 from relationalai.errors import (
     ERPNotRunningError,
-    EngineAutoCreateFailed,
+    EngineProvisioningFailed,
     SnowflakeChangeTrackingNotEnabledException,
     SnowflakeTableObjectsException,
     SnowflakeTableObject,
@@ -261,7 +261,11 @@ class UseIndexPoller:
             if self.engine_errors:
                 spinner.update_messages({ "message": "Errors found. See below for details." })
                 # if there is an engine error, probably auto create engine failed
-                raise EngineAutoCreateFailed(self.engine_name)
+                # Create a synthetic exception from the first engine error
+                first_error = self.engine_errors[0]
+                error_message = first_error.get("message", "Unknown engine error")
+                synthetic_exception = Exception(f"Engine error: {error_message}")
+                raise EngineProvisioningFailed(self.engine_name, synthetic_exception)
 
             if num_tables_altered > 0:
                 s = "s" if num_tables_altered > 1 else ""

relationalai-0.9.17/src/relationalai/early_access/builder/__init__.py

@@ -0,0 +1,30 @@
+import warnings
+
+from relationalai.semantics.internal import (
+    Model, Concept, Relationship, RelationshipReading, Expression, Fragment, Error,
+    String, Integer, Int64, Int128, Float, Decimal, Bool,
+    Date, DateTime,
+    RawSource, Hash,
+    select, where, require, define, distinct, union, data,
+    rank, asc, desc,
+    count, sum, min, max, avg, per,
+    not_, internal as builder, annotations
+)
+
+__all__ = [
+    "Model", "Concept", "Relationship", "RelationshipReading", "Expression", "Fragment", "Error",
+    "String", "Integer", "Int64", "Int128", "Float", "Decimal", "Bool",
+    "Date", "DateTime",
+    "RawSource", "Hash",
+    "select", "where", "require", "define", "distinct", "union", "data",
+    "rank", "asc", "desc",
+    "count", "sum", "min", "max", "avg", "per",
+    "not_", "builder", "annotations"
+]
+
+warnings.warn(
+    "relationalai.early_access.builder.* is deprecated. "
+    "Please migrate to relationalai.semantics.*",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/builder/__init__.py

@@ -0,0 +1,35 @@
+import warnings
+
+from relationalai.semantics.internal.internal import (field_to_type, Compiler, RelationshipRef, ConceptNew,
+                                                      RelationshipFieldRef, Ref, Aggregate, decimal_concept_by_name,
+                                                      _global_id)
+from relationalai.semantics.internal import (
+    Model, Concept, Relationship, RelationshipReading, Expression, Fragment, Error, Field,
+    String, Integer, Int64, Int128, Float, Decimal, Bool,
+    Date, DateTime,
+    RawSource, Hash,
+    select, where, require, define, distinct, union, data,
+    rank, asc, desc,
+    count, sum, min, max, avg, per,
+    not_, internal as builder
+)
+
+__all__ = [
+    "Model", "Concept", "Relationship", "RelationshipReading", "Expression", "Fragment", "Error", "Field",
+    "String", "Integer", "Int64", "Int128", "Float", "Decimal", "Bool",
+    "Date", "DateTime",
+    "RawSource", "Hash",
+    "select", "where", "require", "define", "distinct", "union", "data",
+    "rank", "asc", "desc",
+    "count", "sum", "min", "max", "avg", "per",
+    "not_", "builder",
+    "field_to_type", "Compiler", "RelationshipRef", "ConceptNew", "RelationshipFieldRef", "Ref", "Aggregate",
+    "decimal_concept_by_name", "_global_id"
+]
+
+warnings.warn(
+    "relationalai.early_access.builder.builder is deprecated, "
+    "Please migrate to relationalai.semantics.internal",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/snowflake/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.internal.snowflake import Table, is_direct_access_enabled
+
+__all__ = ["Table", "is_direct_access_enabled"]
+
+warnings.warn(
+    "relationalai.early_access.builder.snowflake is deprecated, "
+    "Please migrate to relationalai.semantics.internal.snowflake",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/std/__init__.py

@@ -0,0 +1,25 @@
+import warnings
+
+from relationalai.semantics.std import range, hash, cast, dates, math, strings, decimals, integers, pragmas, \
+    constraints, uuid_to_string
+
+__all__ = [
+    "range",
+    "hash",
+    "cast",
+    "dates",
+    "math",
+    "strings",
+    "decimals",
+    "integers",
+    "pragmas",
+    "constraints",
+    "uuid_to_string"
+]
+
+warnings.warn(
+    "relationalai.early_access.builder.std.* is deprecated. "
+    "Please migrate to relationalai.semantics.std.*",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/std/decimals/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.std.decimals import decimal, parse_decimal
+
+__all__ = ["decimal", "parse_decimal"]
+
+warnings.warn(
+    "relationalai.early_access.builder.std.decimals is deprecated, "
+    "Please migrate to relationalai.semantics.std.decimals",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/std/integers/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.std.integers import int64, int128, parse, parse_int64, parse_int128
+
+__all__ = ["int64", "int128", "parse", "parse_int64", "parse_int128"]
+
+warnings.warn(
+    "relationalai.early_access.builder.std.integers is deprecated, "
+    "Please migrate to relationalai.semantics.std.integers",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/std/math/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.std.math import abs, isnan, isinf, maximum, natural_log, sqrt, minimum, ceil, floor
+
+__all__ = ["abs", "isnan", "isinf", "maximum", "natural_log", "sqrt", "minimum", "ceil", "floor"]
+
+warnings.warn(
+    "relationalai.early_access.builder.std.math is deprecated, "
+    "Please migrate to relationalai.semantics.std.math",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/builder/std/strings/__init__.py

@@ -0,0 +1,14 @@
+import warnings
+
+from relationalai.semantics.std.strings import (string, len, contains, substring, like, lower, upper, strip, startswith,
+                                                endswith, levenshtein, concat)
+
+__all__ = ["string", "len", "contains", "substring", "like", "lower", "upper", "strip", "startswith", "endswith",
+           "levenshtein", "concat"]
+
+warnings.warn(
+    "relationalai.early_access.builder.std.strings is deprecated, "
+    "Please migrate to relationalai.semantics.std.strings",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/devtools/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.devtools import CompilationManager
+
+__all__ = ["CompilationManager"]
+
+warnings.warn(
+    "relationalai.early_access.devtools.* is deprecated. "
+    "Please migrate to relationalai.semantics.devtools.*",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/devtools/benchmark_lqp/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.devtools.benchmark_lqp import benchmark_lqp
+
+__all__ = ["benchmark_lqp"]
+
+warnings.warn(
+    "relationalai.early_access.devtools.benchmark_lqp is deprecated, "
+    "Please migrate to relationalai.semantics.devtools.benchmark_lqp",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.17/src/relationalai/early_access/devtools/extract_lqp/__init__.py

@@ -0,0 +1,12 @@
+import warnings
+
+from relationalai.semantics.devtools.extract_lqp import extract_rai_calls
+
+__all__ = ["extract_rai_calls"]
+
+warnings.warn(
+    "relationalai.early_access.devtools.extract_lqp is deprecated. "
+    "Please migrate to relationalai.semantics.devtools.extract_lqp",
+    DeprecationWarning,
+    stacklevel=2,
+)

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/adapters/orm/adapter_qb.py

@@ -7,8 +7,8 @@ from relationalai.early_access.dsl.adapters.orm.parser import ORMParser
 from relationalai.early_access.dsl.core.utils import to_pascal_case
 from relationalai.early_access.dsl.orm.constraints import RingType, ValueComparisonType, Range
 from relationalai.early_access.dsl.orm.models import Model
-from relationalai.early_access.builder import Concept, Integer, String, DateTime, Decimal, Date, Float
-from relationalai.early_access.metamodel.util import NameCache
+from relationalai.semantics import Concept, Integer, String, DateTime, Decimal, Date, Float
+from relationalai.semantics.metamodel.util import NameCache
 from datetime import date, datetime
 from decimal import Decimal as PyDecimal
 

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/adapters/orm/parser.py

@@ -11,7 +11,7 @@ from relationalai.early_access.dsl.adapters.orm.model import ORMEntityType, ORMV
     ORMRoleSubsetConstraint, ORMInclusiveRoleConstraint, ORMExclusiveRoleConstraint, ORMEqualityConstraint, \
     ORMFrequencyConstraint, ORMCardinalityConstraint, ORMRange, ORMRoleCardinalityConstraint, \
     ORMValueTypeValueConstraint
-from relationalai.early_access.metamodel.util import ordered_set
+from relationalai.semantics.metamodel.util import ordered_set
 from relationalai.util.graph import topological_sort
 
 

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/bindings/common.py

@@ -5,9 +5,10 @@ from enum import Enum
 from typing import Optional, TypeVar, Generic, Tuple, Callable, Sequence
 from typing import Union
 
-import relationalai.early_access.builder as qb
-from relationalai.early_access.builder import std, builder as b
-from relationalai.early_access.builder.builder import Not
+import relationalai.semantics as qb
+from relationalai.semantics import std
+from relationalai.semantics.internal import internal as b
+from relationalai.semantics.internal.internal import Not
 from relationalai.early_access.dsl.orm.relationships import Relationship, Role
 from relationalai.early_access.dsl.orm.types import Concept
 from relationalai.early_access.dsl.snow.common import ColumnRef, ForeignKey

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/bindings/csv.py

@@ -4,8 +4,9 @@ from typing import Optional
 import numpy as np
 import pandas as pd
 
-from relationalai.early_access.builder import define, where, builder as b
-from relationalai.early_access.builder.std import decimals
+from relationalai.semantics import define, where
+from relationalai.semantics.std import decimals
+from relationalai.semantics.internal import internal as b
 from relationalai.early_access.dsl.bindings.common import BindableColumn, AbstractBindableTable
 from relationalai.early_access.dsl.snow.common import CsvColumnMetadata
 from relationalai.early_access.dsl.utils import normalize

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/bindings/snowflake.py

@@ -1,4 +1,5 @@
-from relationalai.early_access.builder import builder as b, snowflake as sf
+from __future__ import annotations
+from relationalai.semantics.internal import snowflake as sf, internal as b
 from relationalai.early_access.dsl.bindings.common import BindableColumn, AbstractBindableTable
 
 
@@ -26,8 +27,8 @@ class BindableSnowflakeColumn(BindableColumn, sf.Column):
 
 class SnowflakeTable(AbstractBindableTable[BindableSnowflakeColumn], sf.Table):
 
-    def __init__(self, fqn: str, model):
-        sf.Table.__init__(self, fqn)
+    def __init__(self, fqn: str, model, schema:dict[str, str|b.Concept]|None=None):
+        sf.Table.__init__(self, fqn, schema=schema)
         AbstractBindableTable.__init__(self, fqn, model, set())
         self._initialize(model)
 

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/codegen/binder.py

@@ -4,9 +4,9 @@ from relationalai.early_access.dsl.bindings.common import Binding, IdentifierCon
     SubtypeConceptBinding, BindableTable, BindableAttribute, ReferentConceptBinding
 from relationalai.early_access.dsl.codegen.common import BoundIdentifierConstraint, BoundRelationship
 from relationalai.early_access.dsl.orm.relationships import Role, Relationship
-from relationalai.early_access.metamodel.util import OrderedSet
+from relationalai.semantics.metamodel.util import OrderedSet
 
-import relationalai.early_access.builder as qb
+import relationalai.semantics as qb
 
 class Binder:
     def __init__(self, model):

{relationalai-0.9.16 → relationalai-0.9.17}/src/relationalai/early_access/dsl/codegen/helpers.py

@@ -1,4 +1,4 @@
-import relationalai.early_access.builder as qb
+import relationalai.semantics as qb
 
 
 def reference_entity(concept: qb.Concept, *args, check_population: bool=True):