classiq 0.93.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/_internals/authentication/auth0.py

@@ -1,6 +1,7 @@
 import urllib.parse
+import warnings
 from dataclasses import dataclass
-from typing import Any, Optional, Union
+from typing import Any
 
 from httpx import AsyncClient, Response, codes
 from pydantic import Field
@@ -8,6 +9,8 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from classiq.interface.exceptions import ClassiqAuthenticationError
 
+from classiq._internals.config import CONFIG_ENV_FILES
+
 
 class AuthSettings(BaseSettings):
     domain: str = Field(
@@ -20,22 +23,18 @@ class AuthSettings(BaseSettings):
         default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y",
         validation_alias="CLASSIQ_AUTH_CLIENT_ID",
     )
+    organization: str = Field(default="", validation_alias="CLASSIQ_AUTH_ORGANIZATION")
 
-    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)
+    model_config = SettingsConfigDict(
+        env_file=CONFIG_ENV_FILES,
+        extra="ignore",
+    )
 
 
 @dataclass
 class Tokens:
     access_token: str
-    refresh_token: Optional[str]
+    refresh_token: str | None
 
 
 class Auth0:
@@ -53,11 +52,15 @@ class Auth0:
     def _client_id(self) -> str:
         return self._auth_settings.client_id
 
+    @property
+    def _organization(self) -> str:
+        return self._auth_settings.organization
+
     async def _make_request(
         self,
         url: str,
         payload: dict[str, str],
-        allow_error: Union[bool, int] = False,
+        allow_error: bool | int = False,
     ) -> dict[str, Any]:
         encoded_payload = urllib.parse.urlencode(payload)
         client: AsyncClient
@@ -76,13 +79,20 @@ 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, require_refresh_token: bool = True
+    ) -> dict[str, Any]:
         payload = {
-            "client_id": self._auth_settings.client_id,
+            "client_id": self._client_id,
             "audience": self._auth_settings.audience,
         }
-        if get_refresh_token:
+        if require_refresh_token:
             payload["scope"] = "offline_access"
+        if self._organization:
+            warnings.warn(
+                "Organizations are not supported in device auth flow.",
+                stacklevel=1,
+            )
 
         return await self._make_request(
             url="/oauth/device/code",
@@ -102,6 +112,22 @@ class Auth0:
             allow_error=codes.FORBIDDEN,
         )
 
+    def get_authorize_url(
+        self, redirect_uri: str, require_refresh_token: bool = True
+    ) -> str:
+        params = {
+            "client_id": self._client_id,
+            "response_type": "code",
+            "audience": self._auth_settings.audience,
+            "redirect_uri": redirect_uri,
+        }
+        if require_refresh_token:
+            params["scope"] = "offline_access"
+        if self._organization:
+            # Otherwise, let the Auth0 handle
+            params["organization"] = self._organization
+        return f"{self._base_url}/authorize?{urllib.parse.urlencode(params)}"
+
     async def refresh_access_token(self, refresh_token: str) -> Tokens:
         # TODO handle failure
         payload = {

classiq/_internals/authentication/authorization_code.py

@@ -0,0 +1,9 @@
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+
+
+class AuthorizationCodeFlow(AuthorizationFlow):
+    async def authorize(self, redirect_uri: str) -> None:
+        auth_url = self.auth0_client.get_authorize_url(
+            redirect_uri, self.require_refresh_token
+        )
+        self.open_url(auth_url)

classiq/_internals/authentication/authorization_flow.py

@@ -0,0 +1,41 @@
+import webbrowser
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqAuthenticationError
+
+from classiq._internals.authentication.auth0 import Auth0, Tokens
+
+
+class AuthorizationFlow:
+    def __init__(self, require_refresh_token: bool = True, text_only: bool = False):
+        self.require_refresh_token = require_refresh_token
+        self.text_only = text_only
+        self.auth0_client = Auth0()
+
+    async def get_tokens(self) -> Tokens:
+        raise NotImplementedError
+
+    def handle_ready_data(self, data: dict[str, Any]) -> Tokens:
+        access_token: str | None = data.get("access_token") or None
+        # If refresh token was not requested, this would be None
+        refresh_token: str | None = data.get("refresh_token") or None
+
+        if access_token is None or (
+            self.require_refresh_token is True and refresh_token is None
+        ):
+            raise ClassiqAuthenticationError(
+                "Token generation failed for unknown reason (missing access token or refresh token)."
+            )
+
+        return Tokens(access_token=access_token, refresh_token=refresh_token)
+
+    def open_url(self, url: str) -> None:
+        if self.text_only:
+            print(  # noqa: T201
+                f"Please visit this URL from any trusted device to authenticate: {url}"
+            )
+        else:
+            webbrowser.open(url)
+            print(  # noqa: T201
+                f"If a browser doesn't automatically open, please visit this URL from any trusted device to authenticate: {url}"
+            )

classiq/_internals/authentication/device.py

@@ -1,8 +1,8 @@
 import asyncio
-import webbrowser
 from collections.abc import Iterable
+from dataclasses import dataclass
 from datetime import timedelta
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqAuthenticationError,
@@ -10,74 +10,55 @@ from classiq.interface.exceptions import (
 )
 
 from classiq._internals.async_utils import poll_for
-from classiq._internals.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
 
 T = TypeVar("T")
 
 
-class DeviceRegistrar:
+@dataclass
+class DeviceData:
+    user_code: str
+    device_code: str
+    interval: float
+    expires_in: float
+    verification_uri: str
+    verification_uri_complete: str
+
+
+class DeviceCodeFlow(AuthorizationFlow):
     _TIMEOUT_ERROR = (
         "Device registration timed out. Please re-initiate the flow and "
         "authorize the device within the timeout."
     )
     _TIMEOUT_SEC: float = timedelta(minutes=15).total_seconds()
 
-    @classmethod
-    async def register(
-        cls, get_refresh_token: bool = True, text_only: bool = False
-    ) -> Tokens:
-        auth0_client = Auth0()
-        data: dict[str, Any] = await auth0_client.get_device_data(
-            get_refresh_token=get_refresh_token
+    async def get_device_data(self) -> DeviceData:
+        device_data: dict[str, Any] = await self.auth0_client.get_device_data(
+            require_refresh_token=self.require_refresh_token
         )
+        return DeviceData(**device_data)
 
-        print(f"Your user code: {data['user_code']}")  # noqa: T201
-        verification_url = data["verification_uri_complete"]
-        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:
-            webbrowser.open(verification_url)
-        timeout = min(data["expires_in"], cls._TIMEOUT_SEC)
-        return await cls._poll_tokens(
-            auth0_client=auth0_client,
-            device_code=data["device_code"],
-            interval=data["interval"],
+    async def poll_tokens(self, device_data: DeviceData) -> Tokens:
+        interval = device_data.interval
+        timeout = min(device_data.expires_in, self._TIMEOUT_SEC)
+        return await self._poll_tokens(
+            device_code=device_data.device_code,
+            interval=interval,
             timeout=timeout,
-            get_refresh_token=get_refresh_token,
         )
 
-    @classmethod
-    def _handle_ready_data(
-        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
-        refresh_token: Optional[str] = data.get("refresh_token")
-
-        if access_token is None or (
-            get_refresh_token is True and refresh_token is None
-        ):
-            raise ClassiqAuthenticationError(
-                "Token generation failed for unknown reason."
-            )
-
-        return Tokens(access_token=access_token, refresh_token=refresh_token)
-
-    @classmethod
     async def _poll_tokens(
-        cls,
-        auth0_client: Auth0,
+        self,
         device_code: str,
-        interval: int,
+        interval: float,
         timeout: float,
-        get_refresh_token: bool = True,
     ) -> Tokens:
         async def poller() -> dict[str, Any]:
             nonlocal device_code
-            return await auth0_client.poll_tokens(device_code=device_code)
+            return await self.auth0_client.poll_tokens(device_code=device_code)
 
-        def interval_coro() -> Iterable[int]:
+        def interval_coro() -> Iterable[float]:
             nonlocal interval
             while True:
                 yield interval
@@ -86,16 +67,16 @@ class DeviceRegistrar:
         async for data in poll_for(
             poller=poller, timeout_sec=timeout, interval_sec=interval_coro()
         ):
-            error_code: Optional[str] = data.get("error")
+            error_code: str | None = data.get("error")
             if error_code is None:
-                return cls._handle_ready_data(data, get_refresh_token)
+                return self.handle_ready_data(data)
             elif error_code == "authorization_pending":
                 pass
             elif error_code == "slow_down":
                 # This value is used by poll_for via interval_coro
                 interval *= 2
             elif error_code == "expired_token":
-                raise ClassiqExpiredTokenError(cls._TIMEOUT_ERROR)
+                raise ClassiqExpiredTokenError(self._TIMEOUT_ERROR)
             elif error_code == "access_denied":
                 error_description = data.get("error_description")
                 if error_description is None:
@@ -109,4 +90,4 @@ class DeviceRegistrar:
                     f"Device registration failed with an unknown error: {error_code}."
                 )
         else:
-            raise ClassiqAuthenticationError(cls._TIMEOUT_ERROR)
+            raise ClassiqAuthenticationError(self._TIMEOUT_ERROR)

classiq/_internals/authentication/hybrid_flow.py

@@ -0,0 +1,19 @@
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_code import AuthorizationCodeFlow
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+from classiq._internals.authentication.device import DeviceCodeFlow
+
+
+class HybridFlow(AuthorizationFlow):
+    def __init__(
+        self, require_refresh_token: bool = True, text_only: bool = False
+    ) -> None:
+        super().__init__(require_refresh_token, text_only)
+        self.device_flow = DeviceCodeFlow(require_refresh_token, text_only)
+        self.auth_code_flow = AuthorizationCodeFlow(require_refresh_token, text_only)
+
+    async def get_tokens(self) -> Tokens:
+        device_data = await self.device_flow.get_device_data()
+        await self.auth_code_flow.authorize(device_data.verification_uri_complete)
+        print(f"Your user code: {device_data.user_code}")  # noqa: T201
+        return await self.device_flow.poll_tokens(device_data)

classiq/_internals/authentication/password_manager.py

@@ -5,7 +5,7 @@ import os
 import pathlib
 import platform
 import stat
-from typing import Any, Optional
+from typing import Any
 
 import keyring
 from keyring.backends import fail
@@ -42,27 +42,27 @@ class PasswordManager(abc.ABC):
         self._settings = PasswordManagerSettings()
 
     @property
-    def access_token(self) -> Optional[str]:
+    def access_token(self) -> str | None:
         return self._get(key=self._settings.ACCESS_TOKEN_KEY)
 
     @access_token.setter
-    def access_token(self, access_token: Optional[str]) -> None:
+    def access_token(self, access_token: str | None) -> None:
         self._set(key=self._settings.ACCESS_TOKEN_KEY, value=access_token)
 
     @property
-    def refresh_token(self) -> Optional[str]:
+    def refresh_token(self) -> str | None:
         return self._get(key=self._settings.REFRESH_TOKEN_KEY)
 
     @refresh_token.setter
-    def refresh_token(self, refresh_token: Optional[str]) -> None:
+    def refresh_token(self, refresh_token: str | None) -> None:
         self._set(key=self._settings.REFRESH_TOKEN_KEY, value=refresh_token)
 
     @abc.abstractmethod
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         pass
 
     @abc.abstractmethod
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         pass
 
     @abc.abstractmethod
@@ -76,10 +76,10 @@ class PasswordManager(abc.ABC):
 
 
 class KeyringPasswordManager(PasswordManager):
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         return keyring.get_password(service_name=self._SERVICE_NAME, username=key)
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         if value is None:
             self._clear(key)
             return
@@ -101,10 +101,10 @@ class KeyringPasswordManager(PasswordManager):
 
 
 class DummyPasswordManager(PasswordManager):
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         return None
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         return
 
     def _clear(self, key: str) -> None:
@@ -134,13 +134,13 @@ class FilePasswordManager(PasswordManager):
             return json.loads(self.credentials_file.read_text())
         return {}
 
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         token_dict = self._get_token_dict()
         if key in token_dict:
             return token_dict[key]
         return None
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         token_dict = self._get_token_dict()
         token_dict[key] = value
         self._update_file(token_dict)

classiq/_internals/authentication/token_manager.py

@@ -3,7 +3,6 @@ import logging
 import threading
 import warnings
 from collections.abc import Sequence
-from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqAuthenticationError,
@@ -11,8 +10,8 @@ from classiq.interface.exceptions import (
 )
 
 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.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.hybrid_flow import HybridFlow
 from classiq._internals.config import Configuration
 
 PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
@@ -26,7 +25,7 @@ class TokenManager:
     def __init__(
         self,
         config: Configuration,
-        password_manager: Optional[pm.PasswordManager] = None,
+        password_manager: pm.PasswordManager | None = None,
     ) -> None:
         self._config = config
         if password_manager is None:
@@ -35,8 +34,8 @@ class TokenManager:
         # to a specific event loop, which is undesirable
         self._lock = threading.Lock()
         self._password_manager: pm.PasswordManager = password_manager
-        self._access_token: Optional[str] = self._password_manager.access_token
-        self._refresh_token: Optional[str] = self._password_manager.refresh_token
+        self._access_token: str | None = self._password_manager.access_token
+        self._refresh_token: str | None = self._password_manager.refresh_token
         if self._access_token is None and self._refresh_token is not None:
             _logger.info(
                 "Inconsistent state, access token is absent and refresh token is present."
@@ -67,7 +66,7 @@ class TokenManager:
             "Password Manager not found, we could not store your credentials securely. Please contact support@classiq.io"
         )
 
-    def get_access_token(self) -> Optional[str]:
+    def get_access_token(self) -> str | None:
         return self._access_token
 
     async def _refresh(self) -> None:
@@ -127,7 +126,8 @@ class TokenManager:
     async def _authentication_helper(self) -> None:
         # TODO: consider using refresh token rotation
         #  (https://auth0.com/docs/tokens/refresh-tokens/refresh-token-rotation)
-        tokens = await DeviceRegistrar.register(
-            get_refresh_token=True, text_only=self._config.text_only
+        authorization_flow = HybridFlow(
+            require_refresh_token=True, text_only=self._config.text_only
         )
+        tokens = await authorization_flow.get_tokens()
         self._save_tokens(tokens, force_override_refresh_token=True)

classiq/_internals/client.py

@@ -7,9 +7,8 @@ import os
 import platform
 import sys
 import time
-from collections.abc import Awaitable
-from types import TracebackType
-from typing import Any, Callable, NoReturn, Optional, TypeVar, Union
+from collections.abc import Awaitable, Callable
+from typing import Any, NoReturn, TypeVar
 
 import httpx
 from typing_extensions import ParamSpec
@@ -146,27 +145,6 @@ 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"
@@ -177,7 +155,7 @@ class Client:
         self._config = conf
         self._token_manager = token_manager.TokenManager(config=self._config)
         self._api_prefix = self._make_api_prefix()
-        self._session_id: Optional[str] = None
+        self._session_id: str | None = None
 
     @staticmethod
     def _make_api_prefix() -> str:
@@ -229,9 +207,9 @@ class Client:
         http_client: httpx.AsyncClient,
         method: str,
         url: str,
-        json: Optional[dict] = None,
-        params: Optional[dict] = None,
-        headers: Optional[dict[str, str]] = None,
+        json: dict | None = None,
+        params: dict | None = None,
+        headers: dict[str, str] | None = None,
     ) -> httpx.Response:
         http_client.headers.update(self._get_headers())
 
@@ -265,12 +243,12 @@ class Client:
         self,
         http_method: str,
         url: str,
-        body: Optional[dict] = None,
-        params: Optional[dict] = None,
+        body: dict | None = None,
+        params: dict | None = None,
         use_versioned_url: bool = True,
-        headers: Optional[dict[str, str]] = None,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> Union[dict, list, str]:
+        headers: dict[str, str] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> dict | list | str:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         async with self.use_client_or_create(http_client) as async_client:
@@ -285,26 +263,21 @@ class Client:
             return response.json()
 
     def use_client_or_create(
-        self, http_client: Optional[httpx.AsyncClient]
+        self, http_client: httpx.AsyncClient | None
     ) -> 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)
+            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: dict | None = None,
+        headers: dict | None = None,
         use_versioned_url: bool = True,
-    ) -> Union[dict, str]:
+    ) -> dict | str:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         with httpx.Client(**self._make_client_args()) as sync_client:
@@ -356,7 +329,7 @@ class Client:
         return self._config
 
 
-DEFAULT_CLIENT: Optional[Client] = None
+DEFAULT_CLIENT: Client | None = None
 
 
 def client() -> Client:

classiq/_internals/config.py

@@ -2,7 +2,6 @@
 
 import os
 import pathlib
-from typing import Optional, Union
 
 import configargparse  # type: ignore[import]
 import pydantic
@@ -37,7 +36,21 @@ class Configuration(BaseModel):
     )
 
 
-_DEFAULT_CONFIG_FILES = [str(pathlib.Path("classiq", "config.ini"))]
+home_path = pathlib.Path.home()
+if os.name == "posix":
+    config_path = home_path / ".config"
+else:  # assuming "nt"
+    app_data = os.getenv("APPDATA")
+    if app_data:
+        config_path = pathlib.Path(app_data)
+    else:
+        config_path = home_path / "AppData" / "Roaming"
+
+_DEFAULT_CONFIG_FILES = [
+    str(config_path / "classiq" / "config.ini"),
+    str(config_path / "classiq.conf"),
+    str(pathlib.Path("classiq", "config.ini")),
+]
 if os.name == "posix":
     # Unix convensions:
     #   System-wide configuration rests in "/etc"
@@ -48,12 +61,13 @@ if os.name == "posix":
     _DEFAULT_CONFIG_FILES = [
         "/etc/classiq/config.ini",
         "/etc/classiq.conf",
-        "~/.config/classiq/config.ini",
-        "~/.config/classiq.conf",
     ] + _DEFAULT_CONFIG_FILES
 
 
-def init(args: Optional[Union[str, list[str]]] = None) -> Configuration:
+CONFIG_ENV_FILES = (config_path / "classiq" / "config.env",)
+
+
+def init(args: str | list[str] | None = None) -> Configuration:
     """Initialize the configuration object.
 
     Args:

classiq/_internals/help.py

@@ -1,12 +1,11 @@
 import webbrowser
-from typing import Optional
 
 from classiq.interface._version import SEMVER_VERSION
 
 DOCS_BASE_URL = "https://docs.classiq.io/"
 
 
-def open_help(version: Optional[str] = None) -> None:
+def open_help(version: str | None = None) -> None:
     if version is None:
         version = SEMVER_VERSION
     if version == "0.0.0":

classiq/_internals/host_checker.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import warnings
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import httpx
 import pydantic
@@ -38,7 +38,7 @@ class HostChecker:
         self._client_version = client_version
         self._interface_version = interface_version
 
-    def _get_interface_version(self) -> Optional[str]:
+    def _get_interface_version(self) -> str | None:
         global_interfaces = GlobalVersions.model_validate(
             self._client.sync_call_api(
                 "get", "/interface_versions", use_versioned_url=False
@@ -52,7 +52,7 @@ class HostChecker:
         )
         return host.classiq_interface
 
-    def _get_deprecation_info(self) -> Optional[DeprecationInfo]:
+    def _get_deprecation_info(self) -> DeprecationInfo | None:
         global_versions = GlobalVersions.model_validate(
             self._client.sync_call_api("get", "/versions", use_versioned_url=False)
         )