classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/_internals/async_utils.py

@@ -3,12 +3,10 @@ import functools
 import itertools
 import logging
 import time
+from collections.abc import AsyncGenerator, Awaitable, Iterable
 from typing import (
     Any,
-    AsyncGenerator,
-    Awaitable,
     Callable,
-    Iterable,
     Optional,
     SupportsFloat,
     TypeVar,

classiq/_internals/authentication/auth0.py

@@ -1,20 +1,36 @@
 import urllib.parse
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 from httpx import AsyncClient, Response, codes
-from pydantic import BaseSettings, Field
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from classiq.exceptions import ClassiqAuthenticationError
+from classiq.interface.exceptions import ClassiqAuthenticationError
 
 
 class AuthSettings(BaseSettings):
-    domain: str = Field(default="auth.classiq.io", env="CLASSIQ_AUTH_DOMAIN")
-    audience: str = Field(default="https://cadmium-be", env="CLASSIQ_AUTH_AUDIENCE")
+    domain: str = Field(
+        default="auth.classiq.io", validation_alias="CLASSIQ_AUTH_DOMAIN"
+    )
+    audience: str = Field(
+        default="https://cadmium-be", validation_alias="CLASSIQ_AUTH_AUDIENCE"
+    )
     client_id: str = Field(
-        default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y", env="CLASSIQ_AUTH_CLIENT_ID"
+        default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y",
+        validation_alias="CLASSIQ_AUTH_CLIENT_ID",
     )
 
+    model_config = SettingsConfigDict(extra="allow")
+
+    def __init__(self, **data: Any) -> None:
+        initial_data = {
+            field: data[field] for field in data if field in self.model_fields
+        }
+        super().__init__(**data)
+        for field, value in initial_data.items():
+            setattr(self, field, value)
+
 
 @dataclass
 class Tokens:
@@ -40,9 +56,9 @@ class Auth0:
     async def _make_request(
         self,
         url: str,
-        payload: Dict[str, str],
+        payload: dict[str, str],
         allow_error: Union[bool, int] = False,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         encoded_payload = urllib.parse.urlencode(payload)
         client: AsyncClient
         async with AsyncClient(
@@ -60,7 +76,7 @@ class Auth0:
             f"Request to Auth0 failed with error code {code}: {data.get('error')}"
         )
 
-    async def get_device_data(self, get_refresh_token: bool = True) -> Dict[str, Any]:
+    async def get_device_data(self, get_refresh_token: bool = True) -> dict[str, Any]:
         payload = {
             "client_id": self._auth_settings.client_id,
             "audience": self._auth_settings.audience,
@@ -73,7 +89,7 @@ class Auth0:
             payload=payload,
         )
 
-    async def poll_tokens(self, device_code: str) -> Dict[str, Any]:
+    async def poll_tokens(self, device_code: str) -> dict[str, Any]:
         payload = {
             "client_id": self._client_id,
             "device_code": device_code,

classiq/_internals/authentication/authentication.py

@@ -3,6 +3,17 @@ from classiq._internals.client import client
 
 
 def authenticate(overwrite: bool = False) -> None:
+    """
+
+    Authenticate to access the Classiq platform.
+
+     Args:
+        overwrite: A flag indicating whether to overwrite the existing
+        authentication tokens. Defaults to `False`.
+
+      If you are not registered, please visit the Classiq platform
+    to complete registration: https://platform.classiq.io/
+    """
     async_utils.run(authenticate_async(overwrite))
 
 

classiq/_internals/authentication/device.py

@@ -1,11 +1,16 @@
 import asyncio
 import webbrowser
+from collections.abc import Iterable
 from datetime import timedelta
-from typing import Any, Dict, Iterable, Optional, TypeVar
+from typing import Any, Optional, TypeVar
+
+from classiq.interface.exceptions import (
+    ClassiqAuthenticationError,
+    ClassiqExpiredTokenError,
+)
 
 from classiq._internals.async_utils import poll_for
 from classiq._internals.authentication.auth0 import Auth0, Tokens
-from classiq.exceptions import ClassiqAuthenticationError, ClassiqExpiredTokenError
 
 T = TypeVar("T")
 
@@ -22,7 +27,7 @@ class DeviceRegistrar:
         cls, get_refresh_token: bool = True, text_only: bool = False
     ) -> Tokens:
         auth0_client = Auth0()
-        data: Dict[str, Any] = await auth0_client.get_device_data(
+        data: dict[str, Any] = await auth0_client.get_device_data(
             get_refresh_token=get_refresh_token
         )
 
@@ -44,7 +49,7 @@ class DeviceRegistrar:
 
     @classmethod
     def _handle_ready_data(
-        cls, data: Dict[str, Any], get_refresh_token: bool
+        cls, data: dict[str, Any], get_refresh_token: bool
     ) -> Tokens:
         access_token: Optional[str] = data.get("access_token")
         # If refresh token was not requested, this would be None
@@ -68,7 +73,7 @@ class DeviceRegistrar:
         timeout: float,
         get_refresh_token: bool = True,
     ) -> Tokens:
-        async def poller() -> Dict[str, Any]:
+        async def poller() -> dict[str, Any]:
             nonlocal device_code
             return await auth0_client.poll_tokens(device_code=device_code)
 

classiq/_internals/authentication/password_manager.py

@@ -5,23 +5,35 @@ import os
 import pathlib
 import platform
 import stat
-from typing import Dict, Optional
+from typing import Any, Optional
 
 import keyring
 from keyring.backends import fail
-from pydantic import BaseSettings, Field
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 _logger = logging.getLogger(__name__)
 
 
 class PasswordManagerSettings(BaseSettings):
     ACCESS_TOKEN_KEY: str = Field(
-        default="classiqTokenAccount", env="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
+        default="classiqTokenAccount", validation_alias="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
     )
     REFRESH_TOKEN_KEY: str = Field(
-        default="classiqRefershTokenAccount", env="CLASSIQ_REFRESH_TOKEN_ACCOUNT"
+        default="classiqRefershTokenAccount",
+        validation_alias="CLASSIQ_REFRESH_TOKEN_ACCOUNT",
     )
 
+    model_config = SettingsConfigDict(extra="allow")
+
+    def __init__(self, **data: Any) -> None:
+        initial_data = {
+            field: data[field] for field in data if field in self.model_fields
+        }
+        super().__init__(**data)
+        for field, value in initial_data.items():
+            setattr(self, field, value)
+
 
 class PasswordManager(abc.ABC):
     _SERVICE_NAME: str = "classiqTokenService"
@@ -112,12 +124,12 @@ class FilePasswordManager(PasswordManager):
         super().__init__()
         self.credentials_file = pathlib.Path(self._CLASSIQ_CREDENTIALS_FILE_PATH)
 
-    def _update_file(self, token_dict: Dict) -> None:
+    def _update_file(self, token_dict: dict) -> None:
         self.credentials_file.touch()
         self.credentials_file.chmod(stat.S_IRUSR | stat.S_IWUSR)
         self.credentials_file.write_text(json.dumps(token_dict))
 
-    def _get_token_dict(self) -> Dict:
+    def _get_token_dict(self) -> dict:
         if self.credentials_file.exists():
             return json.loads(self.credentials_file.read_text())
         return {}

classiq/_internals/authentication/token_manager.py

@@ -2,18 +2,23 @@ import argparse
 import logging
 import threading
 import warnings
+from collections.abc import Sequence
 from typing import Optional
 
+from classiq.interface.exceptions import (
+    ClassiqAuthenticationError,
+    ClassiqPasswordManagerSelectionError,
+)
+
 from classiq._internals.authentication import password_manager as pm
 from classiq._internals.authentication.auth0 import Auth0
 from classiq._internals.authentication.device import DeviceRegistrar, Tokens
 from classiq._internals.config import Configuration
-from classiq.exceptions import (
-    ClassiqAuthenticationError,
-    ClassiqPasswordManagerSelectionError,
-)
 
-PASSWORD_MANAGERS = [pm.KeyringPasswordManager, pm.FilePasswordManager]
+PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
+    pm.KeyringPasswordManager,
+    pm.FilePasswordManager,
+]
 _logger = logging.getLogger(__name__)
 
 

classiq/_internals/client.py

@@ -1,23 +1,26 @@
 import asyncio
+import contextlib
 import functools
 import inspect
 import logging
 import os
 import platform
-import ssl
 import sys
-from typing import Any, Awaitable, Callable, Dict, NoReturn, Optional, TypeVar, Union
+import time
+from collections.abc import Awaitable
+from types import TracebackType
+from typing import Any, Callable, NoReturn, Optional, TypeVar, Union
 
 import httpx
-from packaging.version import Version
 from typing_extensions import ParamSpec
 
 from classiq.interface._version import VERSION as _VERSION
+from classiq.interface.exceptions import ClassiqAPIError, ClassiqExpiredTokenError
+from classiq.interface.interface_version import INTERFACE_VERSION
 
 from classiq._internals import config
 from classiq._internals.authentication import token_manager
 from classiq._internals.host_checker import HostChecker
-from classiq.exceptions import ClassiqAPIError, ClassiqExpiredTokenError
 
 _FRONTEND_VARIANT: str = "classiq-sdk"
 _INTERFACE_VARIANT: str = "classiq-interface-sdk"
@@ -27,7 +30,7 @@ _logger = logging.getLogger(__name__)
 
 _RETRY_COUNT = 2
 
-Headers = Dict[str, str]
+Headers = dict[str, str]
 
 APPROVED_API_ERROR_MESSAGES_FOR_RESTART = [
     "Call to API failed with code 502",
@@ -135,28 +138,42 @@ def try_again_on_failure(
     return wrapper
 
 
+class _AsyncNullContext(contextlib.AbstractAsyncContextManager):
+    """
+    This class is meant to replace `contextlib.nullcontext`, which hadn't supported
+    async context manager until python 3.10.
+    """
+
+    def __init__(self, enter_result: Any = None) -> None:
+        self._enter_result = enter_result
+
+    async def __aenter__(self) -> Any:
+        return self._enter_result
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        pass
+
+
 class Client:
     _UNKNOWN_VERSION = HostChecker._UNKNOWN_VERSION
     _SESSION_HEADER = "Classiq-Session"
     _WARNINGS_HEADER = "X-Classiq-Warnings"
-    _LATEST_VERSION_API_PREFIX = "/api/v1"
+    _HTTP_TIMEOUT_SECONDS = 3600  # Needs to be synced with load-balancer timeout
 
     def __init__(self, conf: config.Configuration) -> None:
         self._config = conf
         self._token_manager = token_manager.TokenManager(config=self._config)
-        self._ssl_context = ssl.create_default_context()
-        self._HTTP_TIMEOUT_SECONDS = (
-            3600  # Needs to be synced with load-balancer timeout
-        )
         self._api_prefix = self._make_api_prefix()
         self._session_id: Optional[str] = None
 
-    @classmethod
-    def _make_api_prefix(cls) -> str:
-        if _VERSION == cls._UNKNOWN_VERSION:
-            return cls._LATEST_VERSION_API_PREFIX
-        parsed_version = Version(_VERSION)
-        return f"/api/v{parsed_version.major}-{parsed_version.minor}"
+    @staticmethod
+    def _make_api_prefix() -> str:
+        return f"/api/v{INTERFACE_VERSION}"
 
     def make_versioned_url(self, url_postfix: str) -> str:
         return self._api_prefix + url_postfix
@@ -196,46 +213,90 @@ class Client:
             message += f": {detail}"
         except Exception:  # noqa: S110
             pass
-        raise ClassiqAPIError(message)
+        raise ClassiqAPIError(message, response.status_code)
 
-    def _make_client_args(self) -> Dict[str, Any]:
+    @try_again_on_failure
+    async def request(
+        self,
+        http_client: httpx.AsyncClient,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> httpx.Response:
+        http_client.headers.update(self._get_headers())
+
+        _logger.debug("HTTP request: %s %s", method.upper(), url)
+        start_time = time.monotonic()
+        response = await http_client.request(
+            method=method,
+            url=url,
+            json=json,
+            params=params,
+            headers=headers,
+        )
+        _logger.debug(
+            "HTTP response: %s %s %d (%.0fms)",
+            method.upper(),
+            url,
+            response.status_code,
+            (time.monotonic() - start_time) * 1000,
+        )
+        self.handle_response(response)
+        return response
+
+    def _make_client_args(self) -> dict[str, Any]:
         return {
-            "base_url": self._config.host,
+            "base_url": str(self._config.host),
             "timeout": self._HTTP_TIMEOUT_SECONDS,
-            "headers": self.get_headers(),
+            "headers": self._get_headers(),
         }
 
-    @try_again_on_failure
     async def call_api(
         self,
         http_method: str,
         url: str,
-        body: Optional[Dict] = None,
-        params: Optional[Dict] = None,
+        body: Optional[dict] = None,
+        params: Optional[dict] = None,
         use_versioned_url: bool = True,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> Union[Dict, str]:
+        headers: Optional[dict[str, str]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> Union[dict, list, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
-        async with self.async_client() as async_client:
-            response = await async_client.request(
+        async with self.use_client_or_create(http_client) as async_client:
+            response = await self.request(
+                http_client=async_client,
                 method=http_method,
                 url=url,
                 json=body,
                 params=params,
                 headers=headers,
             )
-            self.handle_response(response)
             return response.json()
 
+    def use_client_or_create(
+        self, http_client: Optional[httpx.AsyncClient]
+    ) -> contextlib.AbstractAsyncContextManager[httpx.AsyncClient]:
+        if http_client is None:
+            return self.async_client()
+        else:
+            if sys.version_info[0:2] < (3, 10):
+                # remove this `if` and the `_AsyncNullContext` class when we stop
+                # supporting python 3.9
+                return _AsyncNullContext(enter_result=http_client)
+            else:
+                return contextlib.nullcontext(enter_result=http_client)
+
     def sync_call_api(
         self,
         http_method: str,
         url: str,
-        body: Optional[Dict] = None,
-        headers: Optional[Dict] = None,
+        body: Optional[dict] = None,
+        headers: Optional[dict] = None,
         use_versioned_url: bool = True,
-    ) -> Union[Dict, str]:
+    ) -> Union[dict, str]:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         with httpx.Client(**self._make_client_args()) as sync_client:
@@ -248,7 +309,7 @@ class Client:
     def async_client(self) -> httpx.AsyncClient:
         return httpx.AsyncClient(**self._make_client_args())
 
-    def get_headers(self) -> Headers:
+    def _get_headers(self) -> Headers:
         headers = dict()
         access_token = self._token_manager.get_access_token()
         if access_token is not None:
@@ -262,7 +323,7 @@ class Client:
         await self._token_manager.update_expired_access_token()
 
     def get_backend_uri(self) -> str:
-        return self._config.host
+        return self._config.host.unicode_string()
 
     def check_host(self) -> None:
         # This function is NOT async (despite the fact that it can be) because it's called from a non-async context.

classiq/_internals/config.py

@@ -2,16 +2,15 @@
 
 import os
 import pathlib
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 import configargparse  # type: ignore[import]
 import pydantic
 from pydantic import BaseModel
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.server.routes import DEFAULT_IDE_FE_APP
 
-from classiq._internals.enum_utils import StrEnum
-
 DEFAULT_HOST = "https://api.classiq.io"
 
 
@@ -54,7 +53,7 @@ if os.name == "posix":
     ] + _DEFAULT_CONFIG_FILES
 
 
-def init(args: Optional[Union[str, List[str]]] = None) -> Configuration:
+def init(args: Optional[Union[str, list[str]]] = None) -> Configuration:
     """Initialize the configuration object.
 
     Args:

classiq/_internals/host_checker.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import logging
+import warnings
+from datetime import datetime
 from typing import TYPE_CHECKING, Optional
 
 import httpx
@@ -8,10 +10,10 @@ import pydantic
 from packaging.version import Version
 from pydantic import BaseModel
 
+from classiq.interface.exceptions import ClassiqAPIError, ClassiqDeprecationWarning
+from classiq.interface.interface_version import INTERFACE_VERSION
 from classiq.interface.server.global_versions import DeprecationInfo, GlobalVersions
 
-from classiq.exceptions import ClassiqAPIError
-
 if TYPE_CHECKING:
     from classiq._internals.client import Client
 
@@ -26,16 +28,32 @@ class HostVersions(BaseModel):
 class HostChecker:
     _UNKNOWN_VERSION = "0.0.0"
 
-    def __init__(self, client: Client, client_version: str) -> None:
+    def __init__(
+        self,
+        client: Client,
+        client_version: str,
+        interface_version: str = INTERFACE_VERSION,
+    ) -> None:
         self._client = client
         self._client_version = client_version
+        self._interface_version = interface_version
+
+    def _get_interface_version(self) -> Optional[str]:
+        global_interfaces = GlobalVersions.model_validate(
+            self._client.sync_call_api(
+                "get", "/interface_versions", use_versioned_url=False
+            )
+        )
+        return global_interfaces.deployed.get(self._interface_version, None)
 
     def _get_host_version(self) -> str:
-        host = HostVersions.parse_obj(self._client.sync_call_api("get", "/versions"))
+        host = HostVersions.model_validate(
+            self._client.sync_call_api("get", "/versions")
+        )
         return host.classiq_interface
 
     def _get_deprecation_info(self) -> Optional[DeprecationInfo]:
-        global_versions = GlobalVersions.parse_obj(
+        global_versions = GlobalVersions.model_validate(
             self._client.sync_call_api("get", "/versions", use_versioned_url=False)
         )
         return global_versions.deprecated.get(self._client_version, None)
@@ -56,18 +74,16 @@ class HostChecker:
 
     def check_host_version(self) -> None:
         try:
-            raw_host_version = self._get_host_version()
+            interface_version = self._get_interface_version()
         except httpx.ConnectError:
             _logger.warning(
                 "Version check failed - host unavailable.",
             )
         else:
-            if not self._check_matching_versions(
-                raw_host_version, self._client_version
-            ):
+            if interface_version is None:
                 raise ClassiqAPIError(
-                    f"Classiq API version mismatch: 'classiq' version is "
-                    f"{self._client_version}, backend version is {raw_host_version}. {_VERSION_UPDATE_SUGGESTION}"
+                    f"You are using an unsupported version of Classiq SDK - {self._client_version}. "
+                    f"{_VERSION_UPDATE_SUGGESTION}"
                 )
 
     def check_deprecated_version(self) -> None:
@@ -80,8 +96,15 @@ class HostChecker:
         else:
             if deprecation_info is None:
                 return
-            _logger.warning(
-                "The current version of 'classiq' has been deprecated, and will not be supported as of %s. %s",
-                deprecation_info.removal_date.date(),
-                _VERSION_UPDATE_SUGGESTION,
+            removal_date = (
+                deprecation_info.removal_date.date()
+                if isinstance(deprecation_info.removal_date, datetime)
+                else deprecation_info.removal_date
+            )
+            warnings.warn(
+                f"The current version of 'classiq' has been deprecated, and"
+                f" will not be supported as of {removal_date}. "
+                f"{_VERSION_UPDATE_SUGGESTION}",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
             )