uipath 2.1.117__tar.gz → 2.1.119__tar.gz

{uipath-2.1.117 → uipath-2.1.119}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.117
+Version: 2.1.119
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.117 → uipath-2.1.119}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.117"
+version = "2.1.119"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.117 → uipath-2.1.119}/src/uipath/_cli/_auth/_auth_service.py

@@ -121,7 +121,7 @@ class AuthService:
         return False
 
     def _perform_oauth_flow(self) -> TokenData:
-        auth_config = OidcUtils.get_auth_config()
+        auth_config = OidcUtils.get_auth_config(self._domain)
         auth_url, code_verifier, state = OidcUtils.get_auth_url(
             self._domain, auth_config
         )

uipath-2.1.119/src/uipath/_cli/_auth/_oidc_utils.py

@@ -0,0 +1,196 @@
+import base64
+import hashlib
+import json
+import os
+from typing import Optional
+from urllib.parse import urlencode, urlparse
+
+import httpx
+
+from ..._utils._ssl_context import get_httpx_client_kwargs
+from .._utils._console import ConsoleLogger
+from ._models import AuthConfig
+from ._url_utils import build_service_url
+
+
+def generate_code_verifier_and_challenge():
+    """Generate PKCE code verifier and challenge."""
+    code_verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+    code_challenge_bytes = hashlib.sha256(code_verifier.encode("utf-8")).digest()
+    code_challenge = (
+        base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8").rstrip("=")
+    )
+
+    return code_verifier, code_challenge
+
+
+def get_state_param() -> str:
+    return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+
+def _get_version_from_api(domain: str) -> Optional[str]:
+    """Fetch the version from the UiPath orchestrator API.
+
+    Args:
+        domain: The UiPath domain (e.g., 'https://alpha.uipath.com')
+
+    Returns:
+        The version string (e.g., '25.10.0-beta.415') or None if unable to fetch
+    """
+    try:
+        version_url = build_service_url(domain, "/orchestrator_/api/status/version")
+        client_kwargs = get_httpx_client_kwargs()
+        # Override timeout for version check
+        client_kwargs["timeout"] = 5.0
+
+        with httpx.Client(**client_kwargs) as client:
+            response = client.get(version_url)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("version")
+    except Exception:
+        # Silently fail and return None if we can't fetch the version
+        return None
+
+
+def _is_cloud_domain(domain: str) -> bool:
+    """Check if the domain is a cloud domain (alpha, staging, or cloud.uipath.com).
+
+    Args:
+        domain: The domain string (e.g., 'https://alpha.uipath.com')
+
+    Returns:
+        True if it's a cloud domain, False otherwise
+    """
+    parsed = urlparse(domain)
+    netloc = parsed.netloc.lower()
+    return netloc in [
+        "alpha.uipath.com",
+        "staging.uipath.com",
+        "cloud.uipath.com",
+    ]
+
+
+def _select_config_file(domain: str) -> str:
+    """Select the appropriate auth config file based on domain and version.
+
+    Logic:
+    1. If domain is alpha/staging/cloud.uipath.com -> use auth_config_cloud.json
+    2. Otherwise, try to get version from API
+    3. If version starts with '25.10' -> use auth_config_25_10.json
+    4. If version can't be determined -> fallback to auth_config_cloud.json
+    5. Otherwise -> fallback to auth_config_cloud.json
+
+    Args:
+        domain: The UiPath domain
+
+    Returns:
+        The filename of the config to use
+    """
+    # Check if it's a known cloud domain
+    if _is_cloud_domain(domain):
+        return "auth_config_cloud.json"
+
+    # Try to get version from API
+    version = _get_version_from_api(domain)
+
+    # If we can't determine version, fallback to cloud config
+    if version is None:
+        return "auth_config_cloud.json"
+
+    # Check if version is 25.10.*
+    if version.startswith("25.10"):
+        return "auth_config_25_10.json"
+
+    # Default fallback to cloud config
+    return "auth_config_cloud.json"
+
+
+class OidcUtils:
+    _console = ConsoleLogger()
+
+    @classmethod
+    def _find_free_port(cls, candidates: list[int]):
+        from socket import AF_INET, SOCK_STREAM, error, socket
+
+        def is_free(port: int) -> bool:
+            with socket(AF_INET, SOCK_STREAM) as s:
+                try:
+                    s.bind(("localhost", port))
+                    return True
+                except error:
+                    return False
+
+        return next((p for p in candidates if is_free(p)), None)
+
+    @classmethod
+    def get_auth_config(cls, domain: Optional[str] = None) -> AuthConfig:
+        """Get the appropriate auth configuration based on domain.
+
+        Args:
+            domain: The UiPath domain (e.g., 'https://cloud.uipath.com').
+                   If None, uses default auth_config_cloud.json
+
+        Returns:
+            AuthConfig with the appropriate configuration
+        """
+        # Select the appropriate config file based on domain
+        if domain:
+            config_file = _select_config_file(domain)
+        else:
+            config_file = "auth_config_cloud.json"
+
+        config_path = os.path.join(os.path.dirname(__file__), config_file)
+        with open(config_path, "r") as f:
+            auth_config = json.load(f)
+
+        custom_port = os.getenv("UIPATH_AUTH_PORT")
+        candidates = [int(custom_port)] if custom_port else [8104, 8055, 42042]
+
+        port = cls._find_free_port(candidates)
+        if port is None:
+            ports_str = ", ".join(str(p) for p in candidates)
+            cls._console.error(
+                f"All configured ports ({ports_str}) are in use. Please close applications using these ports or configure different ports."
+            )
+
+        redirect_uri = auth_config["redirect_uri"].replace(
+            "__PY_REPLACE_PORT__", str(port)
+        )
+
+        return AuthConfig(
+            client_id=auth_config["client_id"],
+            redirect_uri=redirect_uri,
+            scope=auth_config["scope"],
+            port=port,
+        )
+
+    @classmethod
+    def get_auth_url(cls, domain: str, auth_config: AuthConfig) -> tuple[str, str, str]:
+        """Get the authorization URL for OAuth2 PKCE flow.
+
+        Args:
+            domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
+            auth_config (AuthConfig): The authentication configuration to use
+
+        Returns:
+            tuple[str, str]: A tuple containing:
+                - The authorization URL with query parameters
+                - The code verifier for PKCE flow
+        """
+        code_verifier, code_challenge = generate_code_verifier_and_challenge()
+        state = get_state_param()
+        query_params = {
+            "client_id": auth_config["client_id"],
+            "redirect_uri": auth_config["redirect_uri"],
+            "response_type": "code",
+            "scope": auth_config["scope"],
+            "state": state,
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        query_string = urlencode(query_params)
+        url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
+        return url, code_verifier, state

{uipath-2.1.117 → uipath-2.1.119}/src/uipath/_cli/_auth/_portal_service.py

@@ -94,7 +94,7 @@ class PortalService:
 
     def refresh_access_token(self, refresh_token: str) -> TokenData:  # type: ignore
         url = build_service_url(self.domain, "/identity_/connect/token")
-        client_id = OidcUtils.get_auth_config().get("client_id")
+        client_id = OidcUtils.get_auth_config(self.domain).get("client_id")
 
         data = {
             "grant_type": "refresh_token",

{uipath-2.1.117 → uipath-2.1.119}/src/uipath/_cli/_auth/_url_utils.py

@@ -15,13 +15,20 @@ def resolve_domain(
     Args:
         base_url: The base URL explicitly provided.
         environment: The environment name (e.g., 'alpha', 'staging', 'cloud').
-        force: Whether to ignore UIPATH_URL from environment variables.
+        force: Whether to ignore UIPATH_URL from environment variables when base_url is set.
 
     Returns:
         A valid base URL for UiPath services.
     """
-    if not force:
-        # If UIPATH_URL is set, prefer its domain
+    # If base_url is a real URL, prefer it
+    if base_url and base_url.startswith("http"):
+        parsed = urlparse(base_url)
+        domain = f"{parsed.scheme}://{parsed.netloc}"
+        if domain:
+            return domain
+
+    # If base_url is not set (or force is False), check UIPATH_URL
+    if not base_url or not force:
         uipath_url = os.getenv("UIPATH_URL")
         if uipath_url and environment == "cloud":
             parsed = urlparse(uipath_url)
@@ -34,13 +41,6 @@ def resolve_domain(
                     "Please ensure it includes scheme and netloc (e.g., 'https://cloud.uipath.com')."
                 )
 
-    # If base_url is a real URL, prefer it
-    if base_url and base_url.startswith("http"):
-        parsed = urlparse(base_url)
-        domain = f"{parsed.scheme}://{parsed.netloc}"
-        if domain:
-            return domain
-
     # Otherwise, fall back to environment
     return f"https://{environment or 'cloud'}.uipath.com"
 

uipath-2.1.119/src/uipath/_cli/_auth/auth_config_cloud.json

@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access ProcessMining OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DocumentUnderstanding Du.Digitization.Api Du.Classification.Api Du.Extraction.Api Du.Validation.Api EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "port": 8104
+}

{uipath-2.1.117 → uipath-2.1.119}/src/uipath/_resources/CLI_REFERENCE.md

@@ -62,10 +62,10 @@ uv run uipath init --infer-bindings
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `--resume` | flag | false | Resume execution from a previous state |
-| `-f`, `--file` | value | none | File path for the .json input |
-| `--input-file` | value | none | Alias for '-f/--file' arguments |
-| `--output-file` | value | none | File path where the output will be written |
-| `--trace-file` | value | none | File path where the trace spans will be written (JSON Lines format) |
+| `-f`, `--file` | value | `Sentinel.UNSET` | File path for the .json input |
+| `--input-file` | value | `Sentinel.UNSET` | Alias for '-f/--file' arguments |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
+| `--trace-file` | value | `Sentinel.UNSET` | File path where the trace spans will be written (JSON Lines format) |
 | `--debug` | flag | false | Enable debugging with debugpy. The process will wait for a debugger to attach. |
 | `--debug-port` | value | `5678` | Port for the debug server (default: 5678) |
 
@@ -117,7 +117,7 @@ uv run uipath run --resume
 |--------|------|---------|-------------|
 | `--no-report` | flag | false | Do not report the evaluation results |
 | `--workers` | value | `1` | Number of parallel workers for running evaluations (default: 1) |
-| `--output-file` | value | none | File path where the output will be written |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
 
 **Usage Examples:**
 

{uipath-2.1.117 → uipath-2.1.119}/src/uipath/_resources/SDK_REFERENCE.md

@@ -124,17 +124,23 @@ sdk.context_grounding.search_async(name: str, query: str, number_of_results: int
 Documents service
 
 ```python
+# Classify a document using a DU Modern project.
+sdk.documents.classify(tag: str, project_name: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> typing.List[uipath.models.documents.ClassificationResult]
+
+# Asynchronously version of the [`classify`][uipath._services.documents_service.DocumentsService.classify] method.
+sdk.documents.classify_async(tag: str, project_name: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> typing.List[uipath.models.documents.ClassificationResult]
+
 # Create a validation action for a document based on the extraction response. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-extractions).
 sdk.documents.create_validation_action(action_title: str, action_priority: <enum 'ActionPriority, action_catalog: str, action_folder: str, storage_bucket_name: str, storage_bucket_directory_path: str, extraction_response: uipath.models.documents.ExtractionResponse) -> uipath.models.documents.ValidationAction
 
 # Asynchronous version of the [`create_validation_action`][uipath._services.documents_service.DocumentsService.create_validation_action] method.
 sdk.documents.create_validation_action_async(action_title: str, action_priority: <enum 'ActionPriority, action_catalog: str, action_folder: str, storage_bucket_name: str, storage_bucket_directory_path: str, extraction_response: uipath.models.documents.ExtractionResponse) -> uipath.models.documents.ValidationAction
 
-# Extract predicted data from a document using an IXP project.
-sdk.documents.extract(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, project_type: <enum 'ProjectType="IXP", document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
+# Extract predicted data from a document using an DU Modern/IXP project.
+sdk.documents.extract(tag: str, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, classification_result: Optional[uipath.models.documents.ClassificationResult]=None, project_type: Optional[uipath.models.documents.ProjectType]=None, document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
 
 # Asynchronously version of the [`extract`][uipath._services.documents_service.DocumentsService.extract] method.
-sdk.documents.extract_async(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, project_type: <enum 'ProjectType="IXP", document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
+sdk.documents.extract_async(tag: str, project_name: Optional[str]=None, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, classification_result: Optional[uipath.models.documents.ClassificationResult]=None, project_type: Optional[uipath.models.documents.ProjectType]=None, document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
 
 # Get the result of a validation action.
 sdk.documents.get_validation_result(validation_action: uipath.models.documents.ValidationAction) -> uipath.models.documents.ValidatedResult