relationalai 0.9.16__tar.gz → 0.9.18__tar.gz

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

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

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

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

{relationalai-0.9.16 → relationalai-0.9.18}/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.18}/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.18}/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)
@@ -702,22 +702,14 @@ Otherwise, remove it from your '{profile}' configuration profile.
         self._create_engine(name, size, auto_suspend_mins, True)
 
     def delete_engine(self, name:str, force:bool = False, headers: Dict | None = None):
-        request_headers = {}
-        prop_headers = debugging.gen_current_propagation_headers()
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
+        request_headers = debugging.add_current_propagation_headers(headers)
         self._exec(f"call {APP_NAME}.api.delete_engine('{name}', {force},{request_headers});")
 
     def suspend_engine(self, name:str):
         self._exec(f"call {APP_NAME}.api.suspend_engine('{name}');")
 
     def resume_engine(self, name:str, headers: Dict | None = None) -> Dict:
-        request_headers = {}
-        prop_headers = debugging.gen_current_propagation_headers()
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
+        request_headers = debugging.add_current_propagation_headers(headers)
         self._exec(f"call {APP_NAME}.api.resume_engine('{name}',{request_headers});")
         # returning empty dict to match the expected return type
         return {}
@@ -1559,12 +1551,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
     ):
         if inputs is None:
             inputs = {}
-        prop_headers = debugging.generate_propagation_headers(debugging.get_current_span())
-        request_headers = {}
-        if headers:
-            request_headers.update(headers)
-        request_headers.update(prop_headers)
-
+        request_headers = debugging.add_current_propagation_headers(headers)
         query_attrs_dict = json.loads(request_headers.get("X-Query-Attributes", "{}"))
 
         with debugging.span("transaction", **query_attrs_dict) as txn_span:
@@ -1703,7 +1690,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 +1703,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 +1779,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 +1802,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:
@@ -2980,13 +2967,12 @@ class DirectAccessClient:
         return url, ep.method
 
     def _prepare_headers(self, headers: Dict[str, str] | None) -> Dict[str, str]:
-
         request_headers = {}
         if headers:
             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'
@@ -2994,7 +2980,8 @@ class DirectAccessClient:
 
         request_headers["user-agent"] = get_pyrel_version(self.generation)
         request_headers["pyrel_program_id"] = debugging.get_program_span_id() or ""
-        return request_headers
+
+        return debugging.add_current_propagation_headers(request_headers)
 
 class DirectAccessResources(Resources):
     """

{relationalai-0.9.16 → relationalai-0.9.18}/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,
@@ -142,7 +142,10 @@ class UseIndexPoller:
                 "should_check_cdc": self.should_check_cdc,
                 "init_engine_async": self.init_engine_async,
             })
-            sql_string = f"CALL {self.app_name}.api.use_index([{sources_object_references_str}], PARSE_JSON(?), {self.headers});"
+
+            request_headers = debugging.add_current_propagation_headers(self.headers)
+
+            sql_string = f"CALL {self.app_name}.api.use_index([{sources_object_references_str}], PARSE_JSON(?), {request_headers});"
 
             with debugging.span("wait", counter=self.counter, use_index_id=use_index_id) as span:
                 results = self.res._exec(sql_string, [params])
@@ -261,7 +264,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.16 → relationalai-0.9.18}/src/relationalai/debugging.py

@@ -4,7 +4,7 @@ import contextlib
 import datetime
 import json
 import os
-from typing import Dict, Generator
+from typing import Dict, Generator, Optional
 import logging
 import uuid
 import warnings
@@ -212,6 +212,15 @@ class Span:
             "attrs": self.attrs,
         }
 
+
+def add_current_propagation_headers(headers: Optional[Dict]) -> Dict:
+    prop_headers = gen_current_propagation_headers()
+
+    if headers:
+        prop_headers.update(headers)        
+
+    return prop_headers
+
 def gen_current_propagation_headers():
     return generate_propagation_headers(get_current_span())
 

relationalai-0.9.18/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.18/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, TupleArg)
+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", "TupleArg"
+]
+
+warnings.warn(
+    "relationalai.early_access.builder.builder is deprecated, "
+    "Please migrate to relationalai.semantics.internal",
+    DeprecationWarning,
+    stacklevel=2,
+)

relationalai-0.9.18/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.18/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.18/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.18/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.18/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.18/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.18/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.18/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.18/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.18}/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