icmd-python 1.1.4__py3-none-any.whl → 1.2.3__py3-none-any.whl

icmd/__init__.py

@@ -1,3 +1,5 @@
 """Python client app for ICMD® API."""
 
-from .core import Session
+from .core import ICMD
+
+__all__ = ["ICMD"]

icmd/core/__init__.py

@@ -1,4 +1,12 @@
-"""Core module for icmd package."""
+"""Core ICMD client modules."""
 
-from .base_client import BaseClient
-from .session import Session
+from .client import ICMD, ICMDAuthenticationError, ICMDConnectionError, ICMDValidationError
+from .credentials import CredentialManager
+
+__all__ = [
+    "ICMD",
+    "CredentialManager",
+    "ICMDAuthenticationError",
+    "ICMDConnectionError",
+    "ICMDValidationError",
+]

icmd/core/client.py

@@ -0,0 +1,482 @@
+"""ICMD client - clean, fast, intuitive."""
+
+import contextlib
+import webbrowser
+from datetime import UTC, datetime, timedelta
+from getpass import getpass
+from http import HTTPStatus
+from typing import Any
+
+import requests
+from requests.adapters import HTTPAdapter
+
+from .credentials import CredentialManager
+
+
+class ICMDAuthenticationError(Exception):
+    """Raised when authentication fails."""
+
+
+class ICMDConnectionError(Exception):
+    """Raised when connection to ICMD fails."""
+
+
+class ICMDValidationError(Exception):
+    """Raised when input validation fails."""
+
+
+class ICMD:
+    """ICMD client - supports multiple domains per process."""
+
+    # Configuration constants
+    _DEFAULT_POOL_CONNECTIONS = 20
+    _DEFAULT_POOL_MAXSIZE = 20
+    _DEFAULT_MAX_RETRIES = 3
+    _DEFAULT_TIMEOUT = 30
+    _TOKEN_EXPIRE_BUFFER_MS = 5000
+    _HTTP_NOT_FOUND = 404
+
+    def __init__(self, domain: str, jupyterlite: bool = False, skip_auth: bool = False):
+        """Initialize ICMD client with required domain parameter.
+
+        Args:
+            domain: REQUIRED domain (e.g., 'icmd.questek.com', 'cust.icmd.questek.com')
+            jupyterlite: Skip auto-authentication for JupyterLite
+            skip_auth: Skip auto-authentication (useful for testing or non-interactive
+                environments)
+
+        Raises
+        ------
+        ValueError
+            If domain is not provided or invalid
+        """
+        if not domain:
+            raise ValueError("Domain is required: ICMD('icmd.questek.com')")
+
+        self.domain = self._validate_domain(domain)
+        self._session = requests.Session()
+        self._session.headers.update({"Content-Type": "application/json"})
+
+        # Connection pooling configuration
+        adapter = HTTPAdapter(
+            pool_connections=self._DEFAULT_POOL_CONNECTIONS,
+            pool_maxsize=self._DEFAULT_POOL_MAXSIZE,
+            max_retries=self._DEFAULT_MAX_RETRIES,
+            pool_block=False,
+        )
+        self._session.mount("http://", adapter)
+        self._session.mount("https://", adapter)
+
+        # Set reasonable timeouts by default
+        self._default_timeout = self._DEFAULT_TIMEOUT
+
+        self._credentials = CredentialManager()
+        self.auth_method = self._auto_detect_auth_method()
+        self.jupyterlite = jupyterlite
+
+        self._refresh_token = ""
+        self._id_token = ""
+        self._id_token_expiration = datetime.now(UTC)
+        self._token_expire_buffer = timedelta(milliseconds=self._TOKEN_EXPIRE_BUFFER_MS)
+
+        # Initialize default timeout (needed for tests that bypass __init__)
+        if not hasattr(self, "_default_timeout"):
+            self._default_timeout = self._DEFAULT_TIMEOUT
+
+        self._load_cached_credentials()
+
+        if not (jupyterlite or skip_auth):
+            self._ensure_authenticated()
+
+    def _validate_domain(self, domain: str) -> str:
+        """Validate domain format and return normalized domain.
+
+        Args
+        ----
+            domain: Domain to validate
+
+        Returns
+        -------
+            Normalized domain string
+
+        Raises
+        ------
+            ValueError: If domain format is invalid
+        """
+        if not domain or not isinstance(domain, str):
+            raise ValueError(f"Invalid domain: {domain}. Must be a non-empty string.")
+
+        normalized = self._normalize_domain(domain)
+
+        # Accept: icmd.questek.com or *.icmd.questek.com
+        if ".questek.com" in normalized:
+            return normalized
+
+        raise ValueError(f"Invalid domain: {domain}. Must be a 'questek.com' subdomain")
+
+    def _normalize_domain(self, domain: str) -> str:
+        """Normalize domain to https:// format."""
+        if not isinstance(domain, str):
+            raise ICMDValidationError("Domain must be a string")
+
+        domain = domain.strip()
+        if not domain:
+            raise ICMDValidationError("Domain cannot be empty")
+
+        if not domain.startswith("http"):
+            domain = f"https://{domain}"
+        return domain
+
+    def _get_server_config(self) -> dict:
+        """Fetch server configuration from /api/v1/public/config/ endpoint."""
+        try:
+            config_url = f"{self.api_root}/public/config/"
+            response = self._session.get(config_url, timeout=5)
+
+            if response.status_code == HTTPStatus.OK:
+                return response.json()
+        except (requests.RequestException, ValueError, OSError, Exception):
+            # Network issues, JSON parsing errors, timeouts, or any other errors
+            pass
+
+        return {}
+
+    def _enhance_auth_error(self, error_response: requests.Response, auth_method: str) -> str:
+        """Enhance authentication error messages with Cognito-specific context."""
+        base_error = f"{auth_method} authentication failed"
+        enhanced_error = base_error
+
+        try:
+            error_data = error_response.json()
+            if not isinstance(error_data, dict):
+                return enhanced_error
+
+            # Extract error message
+            error_msg = error_data.get("error") or error_data.get("message", "")
+
+            # Map error types to enhanced messages
+            error_enhancements = {
+                "InvalidParameterException": "Invalid credentials or user not found",
+                "UserNotFoundException": "User account not found",
+                "CodeMismatchException": "Invalid authentication code",
+                "ExpiredCodeException": "Authentication code has expired, please try again",
+                "TooManyRequestsException": "Too many attempts, please wait before trying again",
+            }
+
+            # Check for specific error types
+            for error_type, enhancement in error_enhancements.items():
+                if error_type in error_msg:
+                    enhanced_error = f"{base_error}: {enhancement}"
+                    break
+            else:
+                # Handle NotAuthorizedException with method-specific messages
+                if "NotAuthorizedException" in error_msg:
+                    if auth_method == "PASSWORD":
+                        enhanced_error = f"{base_error}: Incorrect username or password"
+                    else:
+                        enhanced_error = f"{base_error}: Access denied by identity provider"
+                # Handle networking errors
+                elif "NetworkingError" in error_msg or "timeout" in error_msg.lower():
+                    enhanced_error = (
+                        f"{base_error}: Network connectivity issue with identity provider"
+                    )
+                # Generic error message if available
+                elif error_msg:
+                    enhanced_error = f"{base_error}: {error_msg}"
+
+        except (ValueError, KeyError):
+            pass
+
+        return enhanced_error
+
+    def _auto_detect_auth_method(self) -> str:
+        """Enhanced auth method detection using server config discovery."""
+        if cached := self._credentials.get_auth_method(self.domain):
+            return cached
+
+        # Server config discovery for Cognito IdP detection
+        config = self._get_server_config()
+        if idps := config.get("identityProviders", []):
+            # Prefer external IdP (Azure AD, etc.) over native Cognito password
+            external_idps = [idp for idp in idps if idp != "UP"]
+            if external_idps:
+                return "SAML"  # External IdP available
+            if "UP" in idps:
+                return "PASSWORD"  # Cognito native user/password
+
+        # Fallback: When server config is unavailable, default to PASSWORD
+        # NOTE: The consent endpoint exists for both UP-only and SAML-enabled instances,
+        # so we cannot reliably determine SAML availability without server config.
+        # Conservative approach: assume PASSWORD when config is unavailable.
+        return "PASSWORD"
+
+    @property
+    def api_root(self) -> str:
+        """Return the root of the ICMD API."""
+        return f"{self.domain}/api/v1"
+
+    def _load_cached_credentials(self) -> None:
+        """Load cached credentials from ~/.icmd.json."""
+        if refresh_token := self._credentials.get_refresh_token(self.domain):
+            self._refresh_token = refresh_token
+
+    def _save_credentials(self) -> None:
+        """Save credentials to ~/.icmd.json."""
+        self._credentials.save_domain_credentials(
+            self.domain, self.auth_method, self._refresh_token
+        )
+
+    def _is_token_expired(self) -> bool:
+        """Check if current token is expired."""
+        return self._id_token_expiration - self._token_expire_buffer <= datetime.now(UTC)
+
+    def _ensure_authenticated(self) -> None:
+        """Ensure we have a valid authentication token with smart refresh."""
+        # Check if we already have a valid token
+        if self._id_token and not self._is_token_expired():
+            return
+
+        # Try refresh token if available
+        if self._refresh_token:
+            try:
+                self._refresh_access_token()
+                return
+            except Exception:
+                # Clear invalid refresh token
+                self._refresh_token = ""
+                self._credentials.clear_refresh_token(self.domain)
+
+        # Full authentication required
+        self._perform_authentication()
+
+    def authenticate(self) -> None:
+        """Manually trigger authentication. Useful when ICMD was created with skip_auth=True."""
+        self._ensure_authenticated()
+
+    def _refresh_access_token(self) -> None:
+        """Refresh access token using refresh token."""
+        try:
+            url = f"{self.api_root}/account/auth/refresh/"
+            response = self._session.post(
+                url, json={"refreshToken": self._refresh_token}, timeout=self._default_timeout
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                error_msg = "Token refresh failed"
+                try:
+                    error_data = response.json()
+                    if isinstance(error_data, dict) and "error" in error_data:
+                        error_msg = f"Token refresh failed: {error_data['error']}"
+                except (ValueError, KeyError):
+                    pass
+                raise ICMDAuthenticationError(error_msg)
+
+            self._handle_auth_response(response)
+
+        except requests.RequestException as e:
+            raise ICMDConnectionError(f"Network error during token refresh: {e}") from e
+
+    def _perform_authentication(self) -> None:
+        """Perform full authentication flow."""
+        if self.auth_method == "SAML":
+            self._saml_authentication()
+        else:
+            self._password_authentication()
+
+        self._save_credentials()
+
+    def _password_authentication(self) -> None:
+        """Authenticate with username/password."""
+        try:
+            username = input("Your ICMD® email: ").strip()
+            if not username:
+                raise ICMDValidationError("Username cannot be empty")
+
+            password = getpass("Your ICMD® password: ")
+            if not password:
+                raise ICMDValidationError("Password cannot be empty")
+
+            mfa_code = input("Your MFA Code (if enabled): ").strip()
+
+            url = f"{self.api_root}/account/auth/login/"
+            response = self._session.post(
+                url,
+                json={"username": username, "password": password},
+                timeout=self._default_timeout,
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                error_msg = self._enhance_auth_error(response, "PASSWORD")
+                raise ICMDAuthenticationError(error_msg)
+
+            auth_data = response.json()
+            if auth_data.get("challenge"):
+                self._handle_mfa_challenge(auth_data["challenge"], username, mfa_code)
+            else:
+                self._handle_auth_response(response)
+
+        except EOFError:
+            raise ICMDAuthenticationError(
+                "Cannot authenticate in non-interactive environment. "
+                "Consider using ICMD(skip_auth=True) and calling authenticate() later."
+            ) from None
+        except requests.RequestException as e:
+            raise ICMDConnectionError(f"Network error during password authentication: {e}") from e
+        except KeyboardInterrupt:
+            raise ICMDAuthenticationError("Authentication cancelled by user") from None
+
+    def _handle_mfa_challenge(self, challenge: dict, username: str, mfa_code: str) -> None:
+        """Handle MFA challenge."""
+        try:
+            if not mfa_code:
+                mfa_code = input("Your MFA Code: ").strip()
+
+            if not mfa_code:
+                raise ICMDValidationError("MFA code cannot be empty")
+
+            url = f"{self.api_root}/account/auth/mfa/"
+            response = self._session.post(
+                url,
+                json={
+                    "mfa_code": mfa_code,
+                    "session": challenge["Session"],
+                    "username": username,
+                    "challenge_name": challenge.get("ChallengeName"),
+                },
+                timeout=self._default_timeout,
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                error_msg = "MFA verification failed"
+                try:
+                    error_data = response.json()
+                    if isinstance(error_data, dict) and "error" in error_data:
+                        error_msg = f"MFA failed: {error_data['error']}"
+                except (ValueError, KeyError):
+                    pass
+                raise ICMDAuthenticationError(error_msg)
+
+            self._handle_auth_response(response)
+
+        except requests.RequestException as e:
+            raise ICMDConnectionError(f"Network error during MFA verification: {e}") from e
+        except KeyboardInterrupt:
+            raise ICMDAuthenticationError("MFA verification cancelled by user") from None
+
+    def _saml_authentication(self) -> None:
+        """Authenticate with SAML SSO."""
+        try:
+            print("\n\033[94mSigning into ICMD® with SAML SSO...\033[0m\n")
+
+            consent_url = f"{self.api_root}/account/auth/consent"
+            print(f"Opening browser: {consent_url}")
+            print("If it doesn't open, copy this URL to your browser:")
+            print(f"\n{consent_url}\n")
+
+            with contextlib.suppress(Exception):
+                webbrowser.open(consent_url)
+
+            auth_code = input("Please enter the authentication code: ").strip()
+            if not auth_code:
+                raise ICMDValidationError("Authentication code required")
+
+            url = f"{self.api_root}/account/auth/login/"
+            response = self._session.post(
+                url,
+                json={"code": auth_code, "redirect_uri": f"{self.api_root}/account/auth/exchange"},
+                timeout=self._default_timeout,
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                error_msg = self._enhance_auth_error(response, "SAML")
+                raise ICMDAuthenticationError(error_msg)
+
+            self._handle_auth_response(response)
+            print("\n\033[92mSigned in successfully.\033[0m\n")
+
+        except requests.RequestException as e:
+            raise ICMDConnectionError(f"Network error during SAML authentication: {e}") from e
+        except KeyboardInterrupt:
+            raise ICMDAuthenticationError("SAML authentication cancelled by user") from None
+
+    def _handle_auth_response(self, response: requests.Response) -> None:
+        """Handle authentication response and extract tokens."""
+        auth_data = response.json()
+
+        # Update session headers
+        if user_context := auth_data.get("userFingerprint"):
+            self._session.headers["X-User-Context"] = user_context
+
+        # Extract tokens
+        self._id_token = auth_data.get("idToken", "")
+        if refresh_token := auth_data.get("refreshToken"):
+            self._refresh_token = refresh_token
+
+        # Set expiration
+        if expires_at := auth_data.get("expiresAt"):
+            self._id_token_expiration = datetime.fromisoformat(expires_at)
+
+        # Set bearer auth
+        if self._id_token:
+            self._session.headers["Authorization"] = f"Bearer {self._id_token}"
+
+        # Handle cookies
+        for cookie in response.cookies:
+            if cookie.name == "Secure-Fgp" and cookie.value:
+                self._session.cookies.set("Secure-Fgp", cookie.value)
+
+    def request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        """Make authenticated request to ICMD API with smart retry and error handling."""
+        try:
+            self._ensure_authenticated()
+
+            # Clean and validate endpoint
+            if not endpoint:
+                raise ICMDValidationError("Endpoint cannot be empty")
+
+            endpoint = endpoint.strip("/")
+            url = f"{self.api_root}/{endpoint}/"
+
+            # Set default timeout if not provided
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = self._default_timeout
+
+            # Make request with automatic retry on auth failure
+            response = self._session.request(method, url, **kwargs)
+
+            # Handle token expiration with single retry
+            if response.status_code == HTTPStatus.UNAUTHORIZED and not kwargs.get("_retry_auth"):
+                # Clear token and re-authenticate
+                self._id_token = ""
+                self._session.headers.pop("Authorization", None)
+                self._ensure_authenticated()
+
+                # Retry once with fresh token
+                kwargs["_retry_auth"] = True
+                response = self._session.request(method, url, **kwargs)
+
+            return response
+
+        except (ICMDAuthenticationError, ICMDConnectionError, ICMDValidationError):
+            # Re-raise our custom exceptions
+            raise
+        except requests.RequestException as e:
+            raise ICMDConnectionError(f"Request failed for {method} {endpoint}: {e}") from e
+        except Exception as e:
+            raise ICMDConnectionError(f"Unexpected error during request: {e}") from e
+
+    def get(self, endpoint: str, **kwargs) -> requests.Response:
+        """GET request."""
+        return self.request("GET", endpoint, **kwargs)
+
+    def post(self, endpoint: str, data: Any = None, **kwargs) -> requests.Response:
+        """POST request."""
+        return self.request("POST", endpoint, json=data, **kwargs)
+
+    def put(self, endpoint: str, data: Any = None, **kwargs) -> requests.Response:
+        """PUT request."""
+        return self.request("PUT", endpoint, json=data, **kwargs)
+
+    def delete(self, endpoint: str, **kwargs) -> requests.Response:
+        """DELETE request."""
+        return self.request("DELETE", endpoint, **kwargs)

icmd/core/credentials.py

@@ -0,0 +1,144 @@
+"""Credential management for ICMD client."""
+
+import json
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class CredentialManager:
+    """Handles domain-keyed credential persistence for multiple ICMD instances."""
+
+    def __init__(self, credential_file: str | None = None):
+        """Initialize credential manager.
+
+        Args:
+            credential_file: Optional custom path to credential file.
+                           Defaults to ~/.icmd.json
+        """
+        self.credential_file = Path(credential_file or Path.home() / ".icmd.json")
+
+    def load_domain_credentials(self, domain: str) -> dict[str, Any]:
+        """Load cached credentials for specific domain.
+
+        Args:
+            domain: Domain to load credentials for
+
+        Returns
+        -------
+            Dictionary containing auth_method, refresh_token, etc.
+            Empty dict if file doesn't exist or domain not found.
+        """
+        all_credentials = self._load_all_credentials()
+        return all_credentials.get(domain, {})
+
+    def _load_all_credentials(self) -> dict[str, dict[str, Any]]:
+        """Load all domain-keyed credentials from file.
+
+        Returns
+        -------
+            Dictionary with domain keys and credential values.
+            Empty dict if file doesn't exist or can't be read.
+        """
+        if not self.credential_file.exists():
+            return {}
+
+        try:
+            with open(self.credential_file) as f:
+                data = json.load(f)
+
+            # Validate domain-keyed structure
+            if not isinstance(data, dict):
+                logger.warning("Credential file contains invalid data structure")
+                return {}
+
+            return data
+
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(f"Failed to load credential file: {e}")
+            return {}
+
+    def save_domain_credentials(
+        self, domain: str, auth_method: str, refresh_token: str, **additional_data: Any
+    ) -> None:
+        """Save credentials for specific domain, preserving other domains.
+
+        Args:
+            domain: ICMD domain
+            auth_method: Authentication method (SAML/PASSWORD)
+            refresh_token: Refresh token for subsequent sessions
+            **additional_data: Additional data to store
+        """
+        # Load existing credentials
+        all_credentials = self._load_all_credentials()
+
+        # Update credentials for this domain
+        all_credentials[domain] = {
+            "auth_method": auth_method,
+            "refresh_token": refresh_token,
+            "saved_at": datetime.now(UTC).isoformat(),
+            **additional_data,
+        }
+
+        self._save_all_credentials(all_credentials)
+
+    def _save_all_credentials(self, all_credentials: dict[str, dict[str, Any]]) -> None:
+        """Save all domain-keyed credentials to file.
+
+        Args:
+            all_credentials: Dictionary with domain keys and credential values
+        """
+        try:
+            # Ensure parent directory exists
+            self.credential_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Save with proper permissions (readable only by user)
+            with open(self.credential_file, "w") as f:
+                json.dump(all_credentials, f, indent=2)
+
+            # Set file permissions to be readable only by user
+            self.credential_file.chmod(0o600)
+
+            logger.debug(f"Saved credentials to {self.credential_file}")
+
+        except OSError as e:
+            logger.error(f"Failed to save credentials: {e}")
+            # Don't raise - failing to save credentials shouldn't break the session
+
+    def clear_session_data(self) -> None:
+        """Clear cached session data by removing the credential file."""
+        try:
+            if self.credential_file.exists():
+                self.credential_file.unlink()
+                logger.info("Cleared cached credentials")
+        except OSError as e:
+            logger.warning(f"Failed to clear credentials: {e}")
+
+    def get_auth_method(self, domain: str) -> str | None:
+        """Get cached authentication method for domain."""
+        data = self.load_domain_credentials(domain)
+        return data.get("auth_method")
+
+    def get_refresh_token(self, domain: str) -> str | None:
+        """Get cached refresh token for domain."""
+        data = self.load_domain_credentials(domain)
+        return data.get("refresh_token")
+
+    def clear_refresh_token(self, domain: str) -> None:
+        """Clear only the refresh token for domain, keeping other session data."""
+        all_credentials = self._load_all_credentials()
+        if domain in all_credentials and "refresh_token" in all_credentials[domain]:
+            all_credentials[domain].pop("refresh_token")
+            self._save_all_credentials(all_credentials)
+            logger.debug(f"Cleared invalid refresh token for domain {domain}")
+
+    def clear_domain_credentials(self, domain: str) -> None:
+        """Clear all credentials for specific domain."""
+        all_credentials = self._load_all_credentials()
+        if domain in all_credentials:
+            del all_credentials[domain]
+            self._save_all_credentials(all_credentials)
+            logger.info(f"Cleared credentials for domain {domain}")

icmd/version.py

@@ -1 +1 @@
-__version__ = "1.1.4"
+__version__ = "1.2.3"

{icmd_python-1.1.4.dist-info → icmd_python-1.2.3.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: icmd-python
-Version: 1.1.4
+Version: 1.2.3
 Summary: Python client app for ICMD®
 Author: QuesTek Innovations LLC
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Requires-Dist: requests
+Requires-Dist: jupyter
 Provides-Extra: dev
 Requires-Dist: myst-nb; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

icmd_python-1.2.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+icmd/__init__.py,sha256=Y3zT6WXeWkIuMsLjwXs1lTjiGSj-dzLvetVSmRu_u2w,84
+icmd/version.py,sha256=C-D_WWrVkBDmQmApLcm0sWNh2CgIrwWfc8_sB5vvU-Q,22
+icmd/core/__init__.py,sha256=4-zYFBsm52YklOAfbd0EF6wqAQS2bCIDeRAQFJRX9Lw,305
+icmd/core/client.py,sha256=OHMZvO6bG2pF94gyaXnStV6QIYRDOuCePgPNQaTUKrQ,18858
+icmd/core/credentials.py,sha256=rOE1uswqsWpKeNaFO1PMP4EVdNB0tvHzNShG8y7gVA0,5356
+icmd_python-1.2.3.dist-info/METADATA,sha256=YKPWHIxGtImmUdO0zXuCwQSj7gunuhZtYb6RyRBVti8,501
+icmd_python-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+icmd_python-1.2.3.dist-info/top_level.txt,sha256=olzM6Z_QEwg7RrFVOnkgO0I2Ps2m7vhSqYQZYeiawcw,5
+icmd_python-1.2.3.dist-info/RECORD,,

{icmd_python-1.1.4.dist-info → icmd_python-1.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

icmd/clients/__init__.py

@@ -1 +0,0 @@
-"""Client apps for ICMD API."""

icmd/clients/calphad_client.py

@@ -1,93 +0,0 @@
-"""Client for the CALPHAD Simulation Toolkit."""
-
-import warnings
-from http import HTTPStatus
-
-import pandas as pd
-from pandas.io.formats.style import Styler
-
-from icmd.core import BaseClient
-from icmd.core.job_table_format import qt_job_table_style
-
-try:
-    import qt_calphad
-except ImportError:
-    qt_calphad = None
-
-
-class CalphadClient(BaseClient):
-    """Client for the CALPHAD Simulation Toolkit."""
-
-    app_name = "simulation_calphad"
-
-    def __init__(self):
-        super().__init__()
-
-        if qt_calphad is None:
-            raise NotImplementedError("qt_calphad is not installed in current Python.")
-
-    def submit_job(self, name: str, input_dict: dict, send_email: bool = True) -> str:
-        """Submit a job to the queue."""
-        data = {"name": name, "input_dict": input_dict, "send_email": send_email}
-        self.send_request("post", "job", data)
-
-        if self.response.status_code != HTTPStatus.CREATED:
-            raise ValueError("Job submission failed. Check out client.request for more info.")
-
-        data = self.response.json()
-        return data["uuid"]
-
-    def retrieve_job(self, uuid: str):
-        """Retrieve a job from server with given id and load job as calculation object."""
-        self.send_request("get", f"job/{uuid}/get_full_job/")
-
-        if self.response.status_code != HTTPStatus.OK:
-            raise ValueError(
-                "Job retrieval failed. Check out client.session.request for more info."
-            )
-
-        data = self.response.json()
-
-        if data.get("job_status") != "successful" or not data.get("results", {}).get("data"):
-            warnings.warn(
-                "This job is not completed or successful. Loading only input-dict...", stacklevel=2
-            )
-            calculation = qt_calphad.load_calculation(data.get("input_dict"), {}, [])
-        else:
-            try:
-                calculation = qt_calphad.load_calculation(
-                    data.get("input_dict"), data.get("results", {}).get("data"), plots=[]
-                )
-            except Exception as e:
-                warnings.warn(f"Failed to load full calculation: {e}", stacklevel=2)
-                warnings.warn("Loading only input-dict...", stacklevel=2)
-                calculation = qt_calphad.load_calculation(data.get("input_dict"), {}, [])
-
-        return calculation
-
-    def delete_job(self, uuid: str) -> None:
-        """Delete a job with known id."""
-        self.send_request("delete", f"job/{uuid}")
-
-        if self.response.status_code != HTTPStatus.NO_CONTENT:
-            raise ValueError("Job deletion failed. Make sure you have the permission to delete.")
-
-    def list_my_jobs(self, jupyter=True) -> pd.DataFrame | Styler:
-        """List all jobs belong to current user."""
-        self.send_request("get", "job/my_jobs")
-        data = self.response.json()
-        df_data = pd.DataFrame(data)
-
-        if jupyter:
-            df_data.insert(0, "icmd", "")
-            df_data["icmd"] = df_data.apply(lambda row: get_icmd_url(row), axis=1)
-
-            return df_data.style.format(qt_job_table_style).hide(axis="index")
-        return df_data
-
-
-def get_icmd_url(row):
-    """Generate url endpoints for each df row."""
-    if row["type"] in ["point", "step", "grid"]:
-        return f'/simulation_calphad/equilibrium/{row["uuid"]}'
-    return f'/simulation_calphad/{row["type"]}/{row["uuid"]}'

icmd/core/base_client.py

@@ -1,29 +0,0 @@
-"""Base class for ICMD API clients."""
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import requests
-
-from .session import Session
-
-
-class BaseClient:
-    """Client to facilitate user workflows with QuesTek IDE APIs."""
-
-    app_name = ""  # app name in Django urls, provide in subclasses
-
-    def __init__(self):
-        self.session: Session = Session()
-        self.response: requests.Response | None = None
-
-    def send_request(self, method: str, endpoint: str, data: dict | None = None, **kwargs):
-        """Send a request to the ICMD API."""
-        url = self._get_url(endpoint)
-        self.response = self.session.checked_request(method, url, json=data, **kwargs)
-
-    def _get_url(self, endpoint: str) -> str:
-        """Get the full url for a request with app-specific endpoint."""
-        _app_name = self.app_name.strip("/")
-        _endpoint = endpoint.strip("/")
-        return f"{_app_name}/{_endpoint}/"

icmd/core/job_table_format.py

@@ -1,48 +0,0 @@
-"""Format strings in the job table."""
-
-
-def make_clickable(url):
-    """Make a URL clickable."""
-    url = url.lstrip("/")
-    return f'<a href="https://server.questek.com/icmd/{url}">Link</a>'
-
-
-def beautify_job_status(status: str):
-    """Beautify job status."""
-    if status == "successful":
-        return (
-            '<span style="color:white; display:inline-block; padding:5px; '
-            'background-color:rgb(46, 125, 50)">Successful</span>'
-        )
-    if status == "failed":
-        return (
-            '<span style="color:white; display:inline-block; padding:5px; '
-            'background-color:rgb(211, 47, 47)">Failed</span>'
-        )
-    if status == "running":
-        return (
-            '<span style="color:white; display:inline-block; padding:5px; '
-            'background-color:rgb(237, 108, 2)">Running</span>'
-        )
-    if status == "submitted":
-        return (
-            '<span style="color:white; display:inline-block; padding:5px; '
-            'background-color:rgb(55, 111, 208)">Submitted</span>'
-        )
-    return status
-
-
-def beautify_datetime(value: str) -> str:
-    """Beautify datetime string."""
-    if isinstance(value, str):
-        return value.split(".")[0].replace("T", " ")
-    return str(value)
-
-
-qt_job_table_style = {
-    "icmd": make_clickable,
-    "job_status": beautify_job_status,
-    "job_started_at": beautify_datetime,
-    "job_finished_at": beautify_datetime,
-    "created_at": beautify_datetime,
-}

icmd/core/session.py

@@ -1,347 +0,0 @@
-"""Session class to handle ICMD API requests."""
-
-import json
-import logging
-import re
-import socket
-import socketserver
-import webbrowser
-from datetime import datetime, timedelta
-from getpass import getpass
-from http import HTTPStatus
-from pathlib import Path
-
-import requests.auth
-from IPython.display import HTML, display
-
-from .token_handler import TokenHandler
-
-TOKEN_EXPIRE_BUFFER: timedelta = timedelta(milliseconds=5000)
-CREDENTIAL_FILE = str(Path.home() / ".icmd_cred.json")
-
-SIGN_IN_METHODS = {"SAML", "PASSWORD"}
-AUTH_PORTS = [8001, 8002, 8003, 8004, 8005]
-
-def _find_available_port(port_list: list) -> int:
-    """Find the first available port from the predefined list."""
-    for port in port_list:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            try:
-                s.bind(("127.0.0.1", port))
-                return port
-            except OSError:
-                continue
-    raise RuntimeError(f"No available ports found in the predefined list: {port_list}")
-
-class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
-    """Handle requests in a separate thread."""
-
-    allow_reuse_address = True
-
-class Session(requests.Session):
-    """Wrapper around requests.Session that auto refresh token."""
-
-    def __init__(self, jupyterlite: bool = False):
-        super().__init__()
-        self.api_version = "v1"
-
-        self.sign_in_method: str = ""
-        self.icmd_domain: str = ""
-        self.username: str = ""
-        self.password: str = ""
-        self.mfa_code: str = ""
-        self.auth_code: str = ""
-        self.jupyterlite = jupyterlite
-
-        self.refresh_token: str = ""
-        self.id_token: str = ""
-        self.id_token_expiration: datetime = datetime.utcnow()
-        self.headers.update({"Content-Type": "application/json"})
-
-        self._load_credential_file()
-        if not jupyterlite:
-            self._refresh_id_token()
-
-    @property
-    def api_root(self) -> str:
-        """Return the root of the ICMD API, e.g., https://icmd.questek.com/api/v1."""
-        if not self._is_valid_icmd_domain:
-            self.icmd_domain = input("Your ICMD® domain (e.g., icmd.questek.com): ")
-            if not self.icmd_domain.startswith("http"):
-                self.icmd_domain = "https://" + self.icmd_domain
-            self.sign_in_method = input(
-                'If you use SSO, please enter "saml"; otherwise, leave empty: '
-            )
-            self.sign_in_method = self.sign_in_method.strip().upper()
-            if self.sign_in_method == "":
-                self.sign_in_method = "SAML"
-            if self.sign_in_method not in SIGN_IN_METHODS:
-                raise ValueError("Invalid sign-in method.")
-
-        self._write_credential_file()
-        return f"{self.icmd_domain}/api/{self.api_version}"
-
-    def _load_credential_file(self) -> None:
-        """Load icmd_domain and refresh_token from the CREDENTIAL_FILE."""
-        if not Path(CREDENTIAL_FILE).is_file():
-            return
-        try:
-            with open(CREDENTIAL_FILE) as file:
-                data = json.load(file)
-            self.icmd_domain = data.get("ICMD_DOMAIN", "")
-            self.sign_in_method = data.get("ICMD_SIGN_IN_METHOD", "")
-            self.refresh_token = data.get("ICMD_REFRESH_TOKEN", "")
-        except OSError:
-            logging.warning(f"Cannot open credential file: {CREDENTIAL_FILE}")
-        except json.JSONDecodeError:
-            logging.warning(f"Cannot decode credential file in JSON: {CREDENTIAL_FILE}")
-
-    def _write_credential_file(self) -> None:
-        """Write current values to the CREDENTIAL_FILE."""
-        data = {
-            "ICMD_DOMAIN": self.icmd_domain,
-            "ICMD_SIGN_IN_METHOD": self.sign_in_method,
-            "ICMD_REFRESH_TOKEN": self.refresh_token,
-        }
-        with open(CREDENTIAL_FILE, "w") as file:
-            json.dump(data, file)
-
-    @property
-    def _is_valid_icmd_domain(self) -> bool:
-        """Check if the given domain matches the pattern of ICMD domains."""
-        if not self.icmd_domain.startswith("http"):
-            self.icmd_domain = "https://" + self.icmd_domain
-        if self.icmd_domain.endswith("server.questek.com"):
-            return True
-        if self.icmd_domain.startswith("https"):
-            pattern = r"^https://(\w*.)?icmd\.questek\.com"
-            return bool(re.match(pattern, self.icmd_domain))
-        return self.icmd_domain.startswith("http")  # ignore local development
-
-    @property
-    def _is_id_token_expired(self):
-        return self.id_token_expiration - TOKEN_EXPIRE_BUFFER <= datetime.utcnow()
-
-    def _refresh_id_token(self) -> None:
-        """Optionally refresh our id token."""
-        url = f"{self.api_root}/account/auth/refresh/"
-        response = self.request("post", url, json={"refreshToken": self.refresh_token})
-        if response.status_code != HTTPStatus.OK:
-            if self.sign_in_method.strip().upper() == "SAML":
-                self._user_saml_sign_in()
-            else:
-                self._user_sign_in()
-        else:
-            self._handle_cookies(response)
-            self._assign_tokens(response.json())
-
-    def checked_request(self, method: str, path: str, **kwargs) -> requests.Response:
-        """Make a request to the ICMD API and handle token expiration."""
-        clean_path = path.strip("/")
-        if self._is_id_token_expired:
-            self._refresh_id_token()
-
-        url = f"{self.api_root}/{clean_path}/"
-        response = self.request(method, url, **kwargs)
-
-        if response.status_code == HTTPStatus.UNAUTHORIZED and response.reason == "Unauthorized":
-            self._refresh_id_token()
-            response = self.request(method, url, **kwargs)
-
-        return response
-
-    def _assign_tokens(self, auth: dict) -> None:
-        """Assign tokens from auth response."""
-        self.headers.update({"X-User-Context": auth.get("userFingerprint")})
-        self.id_token = auth.get("idToken")
-        if auth.get("refreshToken"):
-            self.refresh_token = auth.get("refreshToken")
-        self.id_token_expiration = datetime.fromisoformat(auth.get("expiresAt"))
-        self.auth = BearerAuth(auth.get("idToken"))
-
-    def _handle_cookies(self, response: requests.Response) -> None:
-        """Handle cookies from response."""
-        for cookie in response.cookies:
-            if cookie.name == "Secure-Fgp":
-                self.cookies.set("Secure-Fgp", cookie.value)
-
-    def _mfa_sign_in(self, challenge, username, challenge_name) -> None:
-        """Sign in with MFA code."""
-        session = challenge["Session"]
-        if not self.mfa_code:
-            self.mfa_code = input("Your MFA Code: ")
-        if username is None:
-            username = input("Your ICMD® email: ")
-        url = f"{self.api_root}/account/auth/mfa/"
-        response = self.request(
-            "post",
-            url,
-            json={
-                "mfa_code": self.mfa_code,
-                "session": session,
-                "username": username,
-                "challenge_name": challenge_name,
-            },
-        )
-        if response.status_code != HTTPStatus.OK:
-            raise ValueError(str(response.json()))
-        self._handle_cookies(response)
-        self._assign_tokens(response.json())
-
-    def _handle_sign_in_response(self, username, response: requests.Response) -> None:
-        """Handle response from login API endpoint."""
-        if response.status_code != HTTPStatus.OK:
-            raise ValueError("Cannot sign into ICMD®: " + str(response.json()))
-        self._handle_cookies(response)
-        auth = response.json()
-        if auth and auth.get("challenge"):
-            challenge = auth["challenge"]
-            challenge_name = challenge.get("ChallengeName")
-            if challenge_name in {"SOFTWARE_TOKEN_MFA", "SMS_MFA"}:
-                self._mfa_sign_in(challenge, username, challenge_name)
-            else:
-                raise ValueError("Unknown challenge - " + challenge_name)
-        else:
-            self._assign_tokens(auth)
-
-    def _user_sign_in(self):
-        """Let user sign in with password to fetch a refresh token."""
-        if not self.username:
-            self.username = input("Your ICMD® email: ")
-            self.password = getpass("Your ICMD® password: ")
-            self.mfa_code = input("Your MFA Code (if enabled): ")
-
-        try:
-            url = f"{self.api_root}/account/auth/login/"
-            response = self.request(
-                "post", url, json={"username": self.username, "password": self.password}
-            )
-            self._handle_sign_in_response(self.username, response)
-        except Exception as e:
-            raise ValueError("Cannot sign into ICMD®: " + str(e)) from e
-
-        self._write_credential_file()
-
-    def _user_saml_sign_in(self):
-        """Let user sign in with SAML to fetch a refresh token."""
-        try:
-            if self.jupyterlite:
-                self._browser_env_saml_sign_in()
-            else:
-                print("\n\033[94mSigning into ICMD® with SAML SSO...\033[0m\n")
-
-                LOCAL_PORT = _find_available_port(AUTH_PORTS)
-                consent_login_url = f"{self.api_root}/account/auth/consent?redirect_uri=http://localhost:{LOCAL_PORT}/callback"
-
-                print("\n\033[94mConsent granted. Proceeding with SSO authentication...\033[0m\n")
-
-                print("Automatically opening the SSO authorization page in your default browser. "
-                    "If it doesn't open or you prefer to use a different browser, "
-                    "go to this URL:")
-
-                print(f"\n{consent_login_url}\n")
-                webbrowser.open(consent_login_url)
-
-                # Start a local server to capture the auth_code
-                with socketserver.TCPServer(("localhost", LOCAL_PORT), TokenHandler) as httpd:
-                    httpd.handle_request()  # Wait for a single request, blocking
-                    auth_code = httpd.auth_code
-                    if not auth_code:
-                        raise ValueError("Authentication code was not received.")
-
-                login_url = f"{self.api_root}/account/auth/login/"
-                response = self.request("post", login_url, json=
-                    {
-                        "code": auth_code,
-                        "redirect_uri": f"http://localhost:{LOCAL_PORT}/callback"
-                    })
-                self._handle_sign_in_response(None, response)
-                print("\n\033[92mSigned in successfully.\033[0m\n")
-        except Exception as e:
-            print("\nCannot sign into ICMD®: " + str(e) + "\n")
-        finally:
-            pass
-
-    def _browser_env_saml_sign_in(self):
-        """Show a button for signing in with SAML in JupyterLite."""
-        try:
-            # Create a sign-in button
-            consent_login_url = f"{self.api_root}/account/auth/consent"
-            buttomHTML = f"""
-            <a type="button" href="{consent_login_url}" target="_blank">Sign in with SAML SSO</a>
-            """
-            display(HTML(buttomHTML))
-        except Exception as e:
-            print(f"\nCannot sign in: {e}\n")
-
-    def complete_saml_sign_in(self):
-        """Complete the SAML sign in process."""
-        if not self.auth_code:
-            print("\033[91mPlease enter an authorization code.\033[0m")
-            return
-        try:
-            login_url = f"{self.api_root}/account/auth/login/"
-            response = self.request("post", login_url, json={
-                "code": self.auth_code,
-                "redirect_uri": f"{self.api_root}/account/auth/exchange"
-            })
-            self._handle_sign_in_response(None, response)
-            print("\n\033[92mSigned in successfully.\033[0m\n")
-        except Exception as e:
-            print(f"\n\033[91mError during sign in: {e!s}\033[0m\n")
-
-    def jupyterlite_sign_in(self):
-        """Sign in on JupyterLite."""
-        if not self.icmd_domain or not self.sign_in_method:
-            raise ValueError(
-                "Please provide all following necessary information to sign in:\n"
-                "session.icmd_domain = await input('icmd_domain'), e.g., icmd.questek.com\n"
-                "session.sign_in_method = await input('sign_in_method'), e.g., PASSWORD or SAML\n"
-            )
-
-        if self.sign_in_method == "PASSWORD" and not all(
-            [
-                self.username,
-                self.password,
-                self.mfa_code,
-            ]
-        ):
-            raise ValueError(
-                "Please provide all following necessary information to sign in:\n"
-                "session.username = await input('username'), i.e., your email\n"
-                "session.password = await getpass('password'), i.e., your password\n"
-                "session.mfa_code = await input('mfa_code'), i.e., the 6 digit code for MFA\n"
-            )
-
-        if self.sign_in_method == "SAML" and not all(
-            [self.username]
-        ):
-            raise ValueError(
-                "Please provide all following necessary information to sign in:\n"
-                "session.username = await input('username'), i.e., your email\n"
-            )
-        self._refresh_id_token()
-
-    @staticmethod
-    def extract_code(url):
-        """Extract authorization code from the url."""
-        start = url.find("code=")
-        if start == -1:
-            return None
-        start += len("code=")
-        end = url.find(" ", start)
-        if end == -1:
-            end = len(url)
-        return url[start:end]
-
-
-class BearerAuth(requests.auth.AuthBase):
-    """A lightweight Auth class to support Bearer token auth header."""
-
-    def __init__(self, token):
-        self.token = token
-
-    def __call__(self, r):
-        """Attach an Authorization header to the given Request object."""
-        r.headers["Authorization"] = f"Bearer {self.token}"
-        return r

icmd/core/token_handler.py

@@ -1,36 +0,0 @@
-"""
-TokenHandler class for processing SAML callbacks.
-
-This module implements a custom HTTP request handler for processing
-SAML callbacks. It listens for authorization codes in the callback
-requests and responds with an HTML template indicating success.
-"""
-
-import os
-from http.server import SimpleHTTPRequestHandler
-
-
-class TokenHandler(SimpleHTTPRequestHandler):
-    """Custom HTTP request handler to process the SAML callback."""
-
-    def do_GET(self):
-        """Handle GET request to capture the auth code."""
-        if "/callback?" in self.path:
-            query_data = self.path.split("?")[1]
-            token_info = dict(qc.split("=") for qc in query_data.split("&"))
-            auth_code = token_info.get("code")
-
-            if auth_code:
-                # Send a response back to the browser indicating success
-                self.send_response(200)
-                self.send_header("Content-type", "text/html")
-                self.end_headers()
-
-                file_path = os.path.join(os.path.dirname(__file__), "template/callback.html")
-                with open(file_path, "rb") as file:
-                    html_content = file.read()
-
-                self.wfile.write(html_content)
-                self.server.auth_code = auth_code
-            else:
-                self.send_error(400, "Authorization code not found")

icmd_python-1.1.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-icmd/__init__.py,sha256=RKbCk0KLWswT4w2Ahfg15MGBhtOG70godi63UAQmjng,67
-icmd/version.py,sha256=XxXhu8-QnuD9hA8Ah0WX5rgpt_DwOQmAwcK-FtpngyQ,22
-icmd/clients/__init__.py,sha256=cKiAGFDou9bwES19V6qwlMtG1rZVi963SoqCWzqQn2Y,32
-icmd/clients/calphad_client.py,sha256=TTMOJilkIRHdTsSuyn3QMOcCCZ-H_W6ebKpBp9z6Kq8,3387
-icmd/core/__init__.py,sha256=11bBl3MBG106aN3VhYi24CqNKMhE2eAjhvQ4cFVmXsc,102
-icmd/core/base_client.py,sha256=1u-BJd3vzcG0MWAmhQbxwyzhpsPp7wj8pRfdJmW9R44,934
-icmd/core/job_table_format.py,sha256=USo0eN40EnE9esfcscP0EWRK-6Zo8_8FIcjGRNvhruc,1473
-icmd/core/session.py,sha256=mMWO5a8IzFn_bUcjpdetZaDtStAZLKzN6sqInHThuDw,13934
-icmd/core/token_handler.py,sha256=mVMJSnQ2Y5smytykdxcBrgkMWpfP8nw0oIYdY23hGrc,1343
-icmd_python-1.1.4.dist-info/METADATA,sha256=6glHN1VBRl7jPzkXxD0BnoBQF0nDM6WOvy1biE1kDCQ,478
-icmd_python-1.1.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-icmd_python-1.1.4.dist-info/top_level.txt,sha256=olzM6Z_QEwg7RrFVOnkgO0I2Ps2m7vhSqYQZYeiawcw,5
-icmd_python-1.1.4.dist-info/RECORD,,