classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

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,13 +27,13 @@ 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
         )
 
-        print(f"Your user code: {data['user_code']}")
+        print(f"Your user code: {data['user_code']}")  # noqa: T201
         verification_url = data["verification_uri_complete"]
-        print(
+        print(  # noqa: T201
             f"If a browser doesn't automatically open, please visit this URL from any trusted device: {verification_url}"
         )
         if not text_only:
@@ -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():
+        async def poller() -> dict[str, Any]:
             nonlocal device_code
             return await auth0_client.poll_tokens(device_code=device_code)
 
@@ -92,7 +97,12 @@ class DeviceRegistrar:
             elif error_code == "expired_token":
                 raise ClassiqExpiredTokenError(cls._TIMEOUT_ERROR)
             elif error_code == "access_denied":
-                error_description: str = data.get("error_description")
+                error_description = data.get("error_description")
+                if error_description is None:
+                    raise ClassiqAuthenticationError(
+                        "Failed authenticating to Classiq, missing error description"
+                    )
+
                 raise ClassiqAuthenticationError(error_description)
             else:
                 raise ClassiqAuthenticationError(

classiq/_internals/authentication/password_manager.py

@@ -5,34 +5,57 @@ 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 Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 _logger = logging.getLogger(__name__)
 
 
+class PasswordManagerSettings(BaseSettings):
+    ACCESS_TOKEN_KEY: str = Field(
+        default="classiqTokenAccount", validation_alias="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
+    )
+    REFRESH_TOKEN_KEY: str = Field(
+        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"
-    _ACCESS_TOKEN_KEY: str = "classiqTokenAccount"
-    _REFRESH_TOKEN_KEY: str = "classiqRefershTokenAccount"
+
+    def __init__(self) -> None:
+        self._settings = PasswordManagerSettings()
 
     @property
     def access_token(self) -> Optional[str]:
-        return self._get(key=self._ACCESS_TOKEN_KEY)
+        return self._get(key=self._settings.ACCESS_TOKEN_KEY)
 
     @access_token.setter
     def access_token(self, access_token: Optional[str]) -> None:
-        self._set(key=self._ACCESS_TOKEN_KEY, value=access_token)
+        self._set(key=self._settings.ACCESS_TOKEN_KEY, value=access_token)
 
     @property
     def refresh_token(self) -> Optional[str]:
-        return self._get(key=self._REFRESH_TOKEN_KEY)
+        return self._get(key=self._settings.REFRESH_TOKEN_KEY)
 
     @refresh_token.setter
     def refresh_token(self, refresh_token: Optional[str]) -> None:
-        self._set(key=self._REFRESH_TOKEN_KEY, value=refresh_token)
+        self._set(key=self._settings.REFRESH_TOKEN_KEY, value=refresh_token)
 
     @abc.abstractmethod
     def _get(self, key: str) -> Optional[str]:
@@ -46,8 +69,9 @@ class PasswordManager(abc.ABC):
     def _clear(self, key: str) -> None:
         pass
 
+    @staticmethod
     @abc.abstractmethod
-    def is_supported(self) -> bool:
+    def is_supported() -> bool:
         pass
 
 
@@ -71,7 +95,8 @@ class KeyringPasswordManager(PasswordManager):
             username=key,
         )
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return not isinstance(keyring.get_keyring(), fail.Keyring)
 
 
@@ -85,7 +110,8 @@ class DummyPasswordManager(PasswordManager):
     def _clear(self, key: str) -> None:
         return
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return True
 
 
@@ -98,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 {}
@@ -125,5 +151,6 @@ class FilePasswordManager(PasswordManager):
             token_dict.pop(key)
             self._update_file(token_dict)
 
-    def is_supported(self) -> bool:
+    @staticmethod
+    def is_supported() -> bool:
         return "windows" not in platform.platform().lower()

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__)
 
 
@@ -57,7 +62,7 @@ class TokenManager:
             return pm.FilePasswordManager()
         for password_manager in PASSWORD_MANAGERS:
             if password_manager.is_supported():
-                return password_manager
+                return password_manager()
         raise ClassiqPasswordManagerSelectionError(
             "Password Manager not found, we could not store your credentials securely. Please contact support@classiq.io"
         )

classiq/_internals/client.py

@@ -1,22 +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, 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"
@@ -26,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",
@@ -80,9 +84,13 @@ def _get_user_agent_header() -> Headers:
     }
 
 
+Ret = TypeVar("Ret")
+P = ParamSpec("P")
+
+
 def try_again_on_failure(
-    func: Callable[..., Awaitable[Any]]
-) -> Callable[..., Awaitable[Any]]:
+    func: Callable[P, Awaitable[Ret]]
+) -> Callable[P, Awaitable[Ret]]:
     def check_approved_api_error(error_message: str) -> bool:
         for approved_api_error in APPROVED_API_ERROR_MESSAGES_FOR_RESTART:
             if approved_api_error in error_message:
@@ -93,7 +101,7 @@ def try_again_on_failure(
         raise TypeError("Must decorate a coroutine function")
 
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> Ret:
         for i in range(_RETRY_COUNT):
             try:
                 return await func(*args, **kwargs)
@@ -123,32 +131,49 @@ def try_again_on_failure(
                     "There is problem with the connection to Classiq's server. Trying again"
                 )
                 await asyncio.sleep(API_ERROR_SLEEP_TIME)
+        raise ClassiqAPIError(
+            "Reached max retries when trying to connect to Classiq's server"
+        )
 
     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
@@ -186,48 +211,92 @@ class Client:
         try:
             detail = response.json()["detail"]
             message += f": {detail}"
-        except Exception:  # nosec B110
+        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:
@@ -240,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:
@@ -254,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: