uipath 2.1.117__py3-none-any.whl → 2.1.119__py3-none-any.whl

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/_cli/_auth/_oidc_utils.py

@@ -2,8 +2,12 @@ import base64
 import hashlib
 import json
 import os
-from urllib.parse import urlencode
+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
@@ -25,6 +29,84 @@ 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()
 
@@ -43,10 +125,24 @@ class OidcUtils:
         return next((p for p in candidates if is_free(p)), None)
 
     @classmethod
-    def get_auth_config(cls) -> AuthConfig:
-        with open(
-            os.path.join(os.path.dirname(__file__), "auth_config.json"), "r"
-        ) as f:
+    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")

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/_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/_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/_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/_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

uipath/_services/documents_service.py

@@ -13,6 +13,8 @@ from .._folder_context import FolderContext
 from .._utils import Endpoint
 from ..models.documents import (
     ActionPriority,
+    ClassificationResponse,
+    ClassificationResult,
     ExtractionResponse,
     ExtractionResponseIXP,
     ProjectType,
@@ -26,6 +28,58 @@ POLLING_INTERVAL = 2  # seconds
 POLLING_TIMEOUT = 300  # seconds
 
 
+def _is_provided(arg: Any) -> bool:
+    return arg is not None
+
+
+def _must_not_be_provided(**kwargs: Any) -> None:
+    for name, value in kwargs.items():
+        if value is not None:
+            raise ValueError(f"`{name}` must not be provided")
+
+
+def _must_be_provided(**kwargs: Any) -> None:
+    for name, value in kwargs.items():
+        if value is None:
+            raise ValueError(f"`{name}` must be provided")
+
+
+def _exactly_one_must_be_provided(**kwargs: Any) -> None:
+    provided = [name for name, value in kwargs.items() if value is not None]
+    if len(provided) != 1:
+        raise ValueError(
+            f"Exactly one of `{', '.join(kwargs.keys())}` must be provided"
+        )
+
+
+def _validate_extract_params_and_get_project_type(
+    project_name: Optional[str],
+    file: Optional[FileContent],
+    file_path: Optional[str],
+    classification_result: Optional[ClassificationResult],
+    project_type: Optional[ProjectType],
+    document_type_name: Optional[str],
+) -> ProjectType:
+    if _is_provided(project_name):
+        _must_be_provided(project_type=project_type)
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+        _must_not_be_provided(classification_result=classification_result)
+        if project_type == ProjectType.MODERN:
+            _must_be_provided(document_type_name=document_type_name)
+    else:
+        _must_not_be_provided(
+            project_name=project_name,
+            project_type=project_type,
+            file=file,
+            file_path=file_path,
+            document_type_name=document_type_name,
+        )
+        _must_be_provided(classification_result=classification_result)
+        project_type = ProjectType.MODERN
+
+    return project_type  # type: ignore
+
+
 class DocumentsService(FolderContext, BaseService):
     """Service for managing UiPath DocumentUnderstanding Document Operations.
 
@@ -100,10 +154,65 @@ class DocumentsService(FolderContext, BaseService):
         )
         return {tag["name"] for tag in response.json().get("tags", [])}
 
+    def _get_document_id(
+        self,
+        project_id: Optional[str],
+        file: Optional[FileContent],
+        file_path: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if classification_result is not None:
+            return classification_result.document_id
+
+        document_id = self._start_digitization(
+            project_id=project_id,  # type: ignore
+            file=file,
+            file_path=file_path,
+        )
+        self._wait_for_digitization(
+            project_id=project_id,  # type: ignore
+            document_id=document_id,
+        )
+
+        return document_id
+
+    async def _get_document_id_async(
+        self,
+        project_id: Optional[str],
+        file: Optional[FileContent],
+        file_path: Optional[str],
+        classification_result: Optional[ClassificationResult],
+    ) -> str:
+        if classification_result is not None:
+            return classification_result.document_id
+
+        document_id = await self._start_digitization_async(
+            project_id=project_id,  # type: ignore
+            file=file,
+            file_path=file_path,
+        )
+        await self._wait_for_digitization_async(
+            project_id=project_id,  # type: ignore
+            document_id=document_id,
+        )
+
+        return document_id
+
     def _get_project_id_and_validate_tag(
-        self, project_name: str, project_type: ProjectType, tag: str
+        self,
+        tag: str,
+        project_name: Optional[str],
+        project_type: Optional[ProjectType],
+        classification_result: Optional[ClassificationResult],
     ) -> str:
-        project_id = self._get_project_id_by_name(project_name, project_type)
+        if project_name is not None:
+            project_id = self._get_project_id_by_name(
+                project_name,
+                project_type,  # type: ignore
+            )
+        else:
+            project_id = classification_result.project_id  # type: ignore
+
         tags = self._get_project_tags(project_id)
         if tag not in tags:
             raise ValueError(
@@ -113,11 +222,20 @@ class DocumentsService(FolderContext, BaseService):
         return project_id
 
     async def _get_project_id_and_validate_tag_async(
-        self, project_name: str, project_type: ProjectType, tag: str
+        self,
+        tag: str,
+        project_name: Optional[str],
+        project_type: Optional[ProjectType],
+        classification_result: Optional[ClassificationResult],
     ) -> str:
-        project_id = await self._get_project_id_by_name_async(
-            project_name, project_type
-        )
+        if project_name is not None:
+            project_id = await self._get_project_id_by_name_async(
+                project_name,
+                project_type,  # type: ignore
+            )
+        else:
+            project_id = classification_result.project_id  # type: ignore
+
         tags = await self._get_project_tags_async(project_id)
         if tag not in tags:
             raise ValueError(
@@ -129,44 +247,100 @@ class DocumentsService(FolderContext, BaseService):
     def _start_digitization(
         self,
         project_id: str,
-        file: FileContent,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
     ) -> str:
-        return self.request(
-            "POST",
-            url=Endpoint(
-                f"/du_/api/framework/projects/{project_id}/digitization/start"
-            ),
-            params={"api-version": 1.1},
-            headers=self._get_common_headers(),
-            files={"File": file},
-        ).json()["documentId"]
+        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
+            return self.request(
+                "POST",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/digitization/start"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                files={"File": handle},
+            ).json()["documentId"]
 
     async def _start_digitization_async(
         self,
         project_id: str,
-        file: FileContent,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
     ) -> str:
-        return (
-            await self.request_async(
-                "POST",
+        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
+            return (
+                await self.request_async(
+                    "POST",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/digitization/start"
+                    ),
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                    files={"File": handle},
+                )
+            ).json()["documentId"]
+
+    def _wait_for_digitization(self, project_id: str, document_id: str) -> None:
+        def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = self.request(
+                method="GET",
                 url=Endpoint(
-                    f"/du_/api/framework/projects/{project_id}/digitization/start"
+                    f"/du_/api/framework/projects/{project_id}/digitization/result/{document_id}"
                 ),
                 params={"api-version": 1.1},
                 headers=self._get_common_headers(),
-                files={"File": file},
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
             )
-        ).json()["documentId"]
+
+        self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+    async def _wait_for_digitization_async(
+        self, project_id: str, document_id: str
+    ) -> None:
+        async def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/digitization/result/{document_id}"
+                    ),
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                )
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
 
     def _get_document_type_id(
         self,
         project_id: str,
         document_type_name: Optional[str],
         project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
     ) -> str:
         if project_type == ProjectType.IXP:
             return str(UUID(int=0))
 
+        if classification_result is not None:
+            return classification_result.document_type_id
+
         response = self.request(
             "GET",
             url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
@@ -190,10 +364,14 @@ class DocumentsService(FolderContext, BaseService):
         project_id: str,
         document_type_name: Optional[str],
         project_type: ProjectType,
+        classification_result: Optional[ClassificationResult],
     ) -> str:
         if project_type == ProjectType.IXP:
             return str(UUID(int=0))
 
+        if classification_result is not None:
+            return classification_result.document_type_id
+
         response = await self.request_async(
             "GET",
             url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
@@ -380,25 +558,225 @@ class DocumentsService(FolderContext, BaseService):
 
         return ExtractionResponse.model_validate(extraction_response)
 
+    def _start_classification(
+        self,
+        project_id: str,
+        tag: str,
+        document_id: str,
+    ) -> str:
+        return self.request(
+            "POST",
+            url=Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/classification/start"
+            ),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={"documentId": document_id},
+        ).json()["operationId"]
+
+    async def _start_classification_async(
+        self,
+        project_id: str,
+        tag: str,
+        document_id: str,
+    ) -> str:
+        return (
+            await self.request_async(
+                "POST",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/classification/start"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={"documentId": document_id},
+            )
+        ).json()["operationId"]
+
+    def _wait_for_classification(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> List[ClassificationResult]:
+        def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = self.request(
+                method="GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/classification/result/{operation_id}"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        classification_response = self._wait_for_operation(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+        for classification_result in classification_response["classificationResults"]:
+            classification_result["ProjectId"] = project_id
+
+        return ClassificationResponse.model_validate(
+            classification_response
+        ).classification_results
+
+    async def _wait_for_classification_async(
+        self,
+        project_id: str,
+        tag: str,
+        operation_id: str,
+    ) -> List[ClassificationResult]:
+        async def result_getter() -> Tuple[str, Optional[str], Optional[str]]:
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/{tag}/classification/result/{operation_id}"
+                    ),
+                    params={"api-version": 1.1},
+                    headers=self._get_common_headers(),
+                )
+            ).json()
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
+            )
+
+        classification_response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+        for classification_result in classification_response["classificationResults"]:
+            classification_result["ProjectId"] = project_id
+
+        return ClassificationResponse.model_validate(
+            classification_response
+        ).classification_results
+
+    @traced(name="documents_classify", run_type="uipath")
+    def classify(
+        self,
+        tag: str,
+        project_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> List[ClassificationResult]:
+        """Classify a document using a DU Modern project.
+
+        Args:
+            project_name (str): Name of the [DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project.
+            tag (str): Tag of the published project version.
+            file (FileContent, optional): The document file to be classified.
+            file_path (str, optional): Path to the document file to be classified.
+
+        Note:
+            Either `file` or `file_path` must be provided, but not both.
+
+        Returns:
+            List[ClassificationResult]: A list of classification results.
+
+        Examples:
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                classification_results = service.classify(
+                    project_name="MyModernProjectName",
+                    tag="Production",
+                    file=file,
+                )
+            ```
+        """
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+
+        project_id = self._get_project_id_and_validate_tag(
+            tag=tag,
+            project_name=project_name,
+            project_type=ProjectType.MODERN,
+            classification_result=None,
+        )
+
+        document_id = self._get_document_id(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=None,
+        )
+
+        operation_id = self._start_classification(
+            project_id=project_id,
+            tag=tag,
+            document_id=document_id,
+        )
+
+        return self._wait_for_classification(
+            project_id=project_id,
+            tag=tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_classify_async", run_type="uipath")
+    async def classify_async(
+        self,
+        tag: str,
+        project_name: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> List[ClassificationResult]:
+        """Asynchronously version of the [`classify`][uipath._services.documents_service.DocumentsService.classify] method."""
+        _exactly_one_must_be_provided(file=file, file_path=file_path)
+
+        project_id = await self._get_project_id_and_validate_tag_async(
+            tag=tag,
+            project_name=project_name,
+            project_type=ProjectType.MODERN,
+            classification_result=None,
+        )
+
+        document_id = await self._get_document_id_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=None,
+        )
+
+        operation_id = await self._start_classification_async(
+            project_id=project_id,
+            tag=tag,
+            document_id=document_id,
+        )
+
+        return await self._wait_for_classification_async(
+            project_id=project_id,
+            tag=tag,
+            operation_id=operation_id,
+        )
+
     @traced(name="documents_extract", run_type="uipath")
     def extract(
         self,
-        project_name: str,
         tag: str,
+        project_name: Optional[str] = None,
         file: Optional[FileContent] = None,
         file_path: Optional[str] = None,
-        project_type: ProjectType = ProjectType.IXP,
+        classification_result: Optional[ClassificationResult] = None,
+        project_type: Optional[ProjectType] = None,
         document_type_name: Optional[str] = None,
     ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
-        """Extract predicted data from a document using an IXP project.
+        """Extract predicted data from a document using an DU Modern/IXP project.
 
         Args:
-            project_name (str): Name of the [IXP](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project)/[DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project.
+            project_name (str, optional): Name of the [IXP](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project)/[DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project. Must be provided if `classification_result` is not provided.
             tag (str): Tag of the published project version.
-            file (FileContent, optional): The document file to be processed.
-            file_path (str, optional): Path to the document file to be processed.
-            project_type (ProjectType, optional): Type of the project. Defaults to `ProjectType.IXP`.
-            document_type_name (str, optional): Document type name associated with the extractor to be used for extraction. Required if `project_type` is `ProjectType.MODERN`.
+            file (FileContent, optional): The document file to be processed. Must be provided if `classification_result` is not provided.
+            file_path (str, optional): Path to the document file to be processed. Must be provided if `classification_result` is not provided.
+            project_type (ProjectType, optional): Type of the project. Must be provided if `project_name` is provided.
+            document_type_name (str, optional): Document type name associated with the extractor to be used for extraction. Required if `project_type` is `ProjectType.MODERN` and `project_name` is provided.
 
         Note:
             Either `file` or `file_path` must be provided, but not both.
@@ -417,7 +795,7 @@ class DocumentsService(FolderContext, BaseService):
                 )
             ```
 
-            DU Modern projects:
+            DU Modern projects (providing document type name):
             ```python
             with open("path/to/document.pdf", "rb") as file:
                 extraction_response = service.extract(
@@ -428,27 +806,50 @@ class DocumentsService(FolderContext, BaseService):
                     document_type_name="Receipts",
                 )
             ```
-        """
-        if file is None and file_path is None:
-            raise ValueError("Either `file` or `file_path` must be provided")
-        if file is not None and file_path is not None:
-            raise ValueError("`file` and `file_path` are mutually exclusive")
-        if project_type == ProjectType.MODERN and document_type_name is None:
-            raise ValueError(
-                "`document_type_name` must be provided when `project_type` is `ProjectType.MODERN`"
+
+            DU Modern projects (using existing classification result):
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                classification_results = uipath.documents.classify(
+                    tag="Production",
+                    project_name="MyModernProjectName",
+                    file=file,
+                )
+
+            extraction_result = uipath.documents.extract(
+                tag="Production",
+                classification_result=max(classification_results, key=lambda result: result.confidence),
             )
+            ```
+        """
+        project_type = _validate_extract_params_and_get_project_type(
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+            project_type=project_type,
+            document_type_name=document_type_name,
+        )
 
         project_id = self._get_project_id_and_validate_tag(
-            project_name=project_name, project_type=project_type, tag=tag
+            tag=tag,
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=classification_result,
         )
 
-        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
-            document_id = self._start_digitization(project_id=project_id, file=handle)  # type: ignore
+        document_id = self._get_document_id(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+        )
 
         document_type_id = self._get_document_type_id(
             project_id=project_id,
             document_type_name=document_type_name,
             project_type=project_type,
+            classification_result=classification_result,
         )
 
         operation_id = self._start_extraction(
@@ -469,37 +870,43 @@ class DocumentsService(FolderContext, BaseService):
     @traced(name="documents_extract_async", run_type="uipath")
     async def extract_async(
         self,
-        project_name: str,
         tag: str,
+        project_name: Optional[str] = None,
         file: Optional[FileContent] = None,
         file_path: Optional[str] = None,
-        project_type: ProjectType = ProjectType.IXP,
+        classification_result: Optional[ClassificationResult] = None,
+        project_type: Optional[ProjectType] = None,
         document_type_name: Optional[str] = None,
     ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
         """Asynchronously version of the [`extract`][uipath._services.documents_service.DocumentsService.extract] method."""
-        if file is None and file_path is None:
-            raise ValueError("Either `file` or `file_path` must be provided")
-        if file is not None and file_path is not None:
-            raise ValueError("`file` and `file_path` are mutually exclusive")
-        if project_type == ProjectType.MODERN and document_type_name is None:
-            raise ValueError(
-                "`document_type_name` must be provided when `project_type` is `ProjectType.MODERN`"
-            )
+        project_type = _validate_extract_params_and_get_project_type(
+            project_name=project_name,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+            project_type=project_type,
+            document_type_name=document_type_name,
+        )
 
         project_id = await self._get_project_id_and_validate_tag_async(
-            project_name=project_name, project_type=project_type, tag=tag
+            tag=tag,
+            project_name=project_name,
+            project_type=project_type,
+            classification_result=classification_result,
         )
 
-        with open(Path(file_path), "rb") if file_path else nullcontext(file) as handle:
-            document_id = await self._start_digitization_async(
-                project_id=project_id,
-                file=handle,  # type: ignore
-            )
+        document_id = await self._get_document_id_async(
+            project_id=project_id,
+            file=file,
+            file_path=file_path,
+            classification_result=classification_result,
+        )
 
         document_type_id = await self._get_document_type_id_async(
             project_id=project_id,
             document_type_name=document_type_name,
             project_type=project_type,
+            classification_result=classification_result,
         )
 
         operation_id = await self._start_extraction_async(

uipath/agent/models/agent.py

@@ -278,13 +278,25 @@ class AgentContextOutputColumn(BaseModel):
     )
 
 
+class AgentContextRetrievalMode(str, Enum):
+    """Enum for retrieval modes."""
+
+    SEMANTIC = "Semantic"
+    STRUCTURED = "Structured"
+    DEEP_RAG = "DeepRAG"
+    BATCH_TRANSFORM = "BatchTransform"
+
+
 class AgentContextSettings(BaseModel):
     """Settings for context."""
 
     result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured", "DeepRAG", "BatchTransform"] = (
-        Field(alias="retrievalMode")
-    )
+    retrieval_mode: Literal[
+        AgentContextRetrievalMode.SEMANTIC,
+        AgentContextRetrievalMode.STRUCTURED,
+        AgentContextRetrievalMode.DEEP_RAG,
+        AgentContextRetrievalMode.BATCH_TRANSFORM,
+    ] = Field(alias="retrievalMode")
     threshold: float = Field(default=0)
     query: Optional[AgentContextQuerySetting] = Field(None)
     folder_path_prefix: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = (
@@ -303,6 +315,20 @@ class AgentContextSettings(BaseModel):
         None, alias="outputColumns"
     )
 
+    @field_validator("retrieval_mode", mode="before")
+    @classmethod
+    def normalize_retrieval_mode(cls, v: Any) -> str:
+        """Normalize context retrieval mode."""
+        if isinstance(v, str):
+            lowercase_mapping = {
+                "semantic": AgentContextRetrievalMode.SEMANTIC,
+                "structured": AgentContextRetrievalMode.STRUCTURED,
+                "deeprag": AgentContextRetrievalMode.DEEP_RAG,
+                "batchtransform": AgentContextRetrievalMode.BATCH_TRANSFORM,
+            }
+            return lowercase_mapping.get(v.lower(), v)
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
@@ -553,7 +579,7 @@ class AgentGuardrailLogAction(BaseModel):
     """Log action model."""
 
     action_type: Literal["log"] = Field(alias="$actionType")
-    message: str = Field(..., alias="message")
+    message: Optional[str] = Field(None, alias="message")
     severity_level: AgentGuardrailSeverityLevel = Field(alias="severityLevel")
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")

uipath/models/documents.py

@@ -151,3 +151,67 @@ class ValidatedResult(BaseModel):
 
     document_id: str = Field(alias="DocumentId")
     results_document: dict = Field(alias="ResultsDocument")  # type: ignore
+
+
+class Reference(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    text_start_index: int = Field(alias="TextStartIndex")
+    text_length: int = Field(alias="TextLength")
+    tokens: List[str] = Field(alias="Tokens")
+
+
+class DocumentBounds(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    start_page: int = Field(alias="StartPage")
+    page_count: int = Field(alias="PageCount")
+    text_start_index: int = Field(alias="TextStartIndex")
+    text_length: int = Field(alias="TextLength")
+    page_range: str = Field(alias="PageRange")
+
+
+class ClassificationResult(BaseModel):
+    """A model representing the result of a document classification.
+
+    Attributes:
+        document_id (str): The ID of the classified document.
+        document_type_id (str): The ID of the predicted document type.
+        confidence (float): The confidence score of the classification.
+        ocr_confidence (float): The OCR confidence score of the document.
+        reference (Reference): The reference information for the classified document.
+        document_bounds (DocumentBounds): The bounds of the document in terms of pages and text.
+        classifier_name (str): The name of the classifier used.
+        project_id (str): The ID of the project associated with the classification.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    document_id: str = Field(alias="DocumentId")
+    document_type_id: str = Field(alias="DocumentTypeId")
+    confidence: float = Field(alias="Confidence")
+    ocr_confidence: float = Field(alias="OcrConfidence")
+    reference: Reference = Field(alias="Reference")
+    document_bounds: DocumentBounds = Field(alias="DocumentBounds")
+    classifier_name: str = Field(alias="ClassifierName")
+    project_id: str = Field(alias="ProjectId")
+
+
+class ClassificationResponse(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    classification_results: List[ClassificationResult] = Field(
+        alias="classificationResults"
+    )

{uipath-2.1.117.dist-info → uipath-2.1.119.dist-info}/METADATA

@@ -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.dist-info → uipath-2.1.119.dist-info}/RECORD

@@ -24,13 +24,14 @@ uipath/_cli/cli_run.py,sha256=9vbmSG_FzS0x8KNNzSrST37FKjUOzhXPjl8xTm2ZEqQ,4203
 uipath/_cli/middlewares.py,sha256=tb0c4sU1SCYi0PNs956Qmk24NDk0C0mBfVQmTcyORE0,5000
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=v_b8KNwn0tAv8jxpeKdllOVzl31q9AcdwpE_koAK_w4,7235
-uipath/_cli/_auth/_auth_service.py,sha256=gyOtaHnDmjYccW0R1HVmFgV69a7w53Dx1Mq-PM0uVag,5405
+uipath/_cli/_auth/_auth_service.py,sha256=BoyMytg4tah1558bWzhS33hUacu17vh3Qr6nRBHD1RI,5417
 uipath/_cli/_auth/_models.py,sha256=kWhqd5FqBo_oi3DW2x1IaJHsEloXq0I24f-pX5zb_O4,753
-uipath/_cli/_auth/_oidc_utils.py,sha256=qGpognkz-Ks-8pt-QabSNTix5HE06lQpY3WZxptoJUE,3394
-uipath/_cli/_auth/_portal_service.py,sha256=nbJzMEg4MAhUGrXD90Jwd5b1SzxLiHri-ZgiHQwLzu8,8011
-uipath/_cli/_auth/_url_utils.py,sha256=MuMYesMQDgetLBzkwd19dPxw3fctys7EVpByDUQMyLE,2844
+uipath/_cli/_auth/_oidc_utils.py,sha256=VEXnri7KinOdZMEPGYUf4mUZpCvSwmIL8TUBx6WhxDU,6446
+uipath/_cli/_auth/_portal_service.py,sha256=fWnHGwd60Q_mrNEeENibqe5wv4ixp-yrG7X4XrXsXNk,8022
+uipath/_cli/_auth/_url_utils.py,sha256=-OD7Gz7pYgJU8CahFZdeX0Na1IB2EIX3u964VmZ1K8Q,2898
 uipath/_cli/_auth/_utils.py,sha256=To4Ara_UF4g7nzUfKqFA11lTjhQWIZWNm4xwa5nNKmU,896
-uipath/_cli/_auth/auth_config.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0QvcUX8,521
+uipath/_cli/_auth/auth_config_25_10.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0QvcUX8,521
+uipath/_cli/_auth/auth_config_cloud.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0QvcUX8,521
 uipath/_cli/_auth/index.html,sha256=uGK0CDTP8Rys_p4O_Pbd2x4tz0frKNVcumjrXnal5Nc,22814
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
@@ -106,9 +107,9 @@ uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,
 uipath/_events/_events.py,sha256=S-3zQiJM6y0pKysXhxQQciNaGcnqJqRw5PrRGgFEKn4,4565
 uipath/_resources/AGENTS.md,sha256=nRQNAVeEBaBvuMzXw8uXtMnGebLClUgwIMlgb8_qU9o,1039
 uipath/_resources/CLAUDE.md,sha256=kYsckFWTVe948z_fNWLysCHvi9_YpchBXl3s1Ek03lU,10
-uipath/_resources/CLI_REFERENCE.md,sha256=M_SCtSjRhj1XwfgSFLfHJJahYXEd_CSQ_EnjLQAn-2Y,6470
+uipath/_resources/CLI_REFERENCE.md,sha256=v6pVR2jbBP7hTXwAwi3Ia5C96BfDKs4xGCCUOmsbEBM,6530
 uipath/_resources/REQUIRED_STRUCTURE.md,sha256=3laqGiNa3kauJ7jRI1d7w_fWKUDkqYBjcTT_6_8FAGk,1417
-uipath/_resources/SDK_REFERENCE.md,sha256=xx6-FzXQpva0eeCeLgscrzaaWrVyFedxxACAD7xVlu4,18663
+uipath/_resources/SDK_REFERENCE.md,sha256=lvQxxdsHi-kzur2C1L4fJ6cEvjVdJPUNSX8UMofgqUQ,19485
 uipath/_services/__init__.py,sha256=_LNy4u--VlhVtTO66bULbCoBjyJBTuyh9jnzjWrv-h4,1140
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
@@ -118,7 +119,7 @@ uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZf
 uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
 uipath/_services/connections_service.py,sha256=tKJHHOKQYKR6LkgB-V_2d0vFpLEdFeMzwj_xmBVHUDw,18416
 uipath/_services/context_grounding_service.py,sha256=Pjx-QQQEiSKD-hY6ityj3QUSALN3fIcKLLHr_NZ0d_g,37117
-uipath/_services/documents_service.py,sha256=2LZyGVYXtsC9ajsNpmLTmbgAXF13YeS4N_LObh4o4kA,31389
+uipath/_services/documents_service.py,sha256=2mPZzmOl2r5i8RYvdeRSJtEFWSSsiXqIauTgNTW75s4,45341
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/external_application_service.py,sha256=gZhnGgLn7ZYUZzZF7AumB14QEPanVY-D_02FqEcAFtw,5478
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
@@ -150,7 +151,7 @@ uipath/agent/conversation/exchange.py,sha256=nuk1tEMBHc_skrraT17d8U6AtyJ3h07ExGQ
 uipath/agent/conversation/message.py,sha256=1ZkEs146s79TrOAWCQwzBAEJvjAu4lQBpJ64tKXDgGE,2142
 uipath/agent/conversation/meta.py,sha256=3t0eS9UHoAPHre97QTUeVbjDhnMX4zj4-qG6ju0B8wY,315
 uipath/agent/conversation/tool.py,sha256=ol8XI8AVd-QNn5auXNBPcCzOkh9PPFtL7hTK3kqInkU,2191
-uipath/agent/models/agent.py,sha256=kAdNWpyzggIYB4ye7vs-hPrHGxYPgTp48DcmQXw-Bcw,22630
+uipath/agent/models/agent.py,sha256=F2KBPORufrqplb6cfBck8YI8GO3miNLD2ebpDqV0xEE,23562
 uipath/agent/models/evals.py,sha256=QMIqwCuwabD_vYF0KgJpip5BV0pFLf9ZKUd9AL5eU2w,1843
 uipath/agent/react/__init__.py,sha256=0Ci-uf0gSOReoHQyx3QImY-om3q_SgLT-bJUSlzS3B8,527
 uipath/agent/react/prompts.py,sha256=0a06TJz2XqZuLK-yC_bvZV9ULXpY6UGtybjjbyVzXII,3375
@@ -204,7 +205,7 @@ uipath/models/buckets.py,sha256=N3Lj_dVCv709-ywhOOdyCSvsuLn41eGuAfSiik6Q6F8,1285
 uipath/models/connections.py,sha256=jmzlfnddqlxjmiVhqsETRV6TQPH3fFqJGsygG0gUf7g,2745
 uipath/models/context_grounding.py,sha256=3MaF2Fv2QYle8UUWvKGkCN5XGpx2T4a34fdbBqJ2fCs,1137
 uipath/models/context_grounding_index.py,sha256=OhRyxZDHDSrEmBFK0-JLqMMMT64jir4XkHtQ54IKtc0,2683
-uipath/models/documents.py,sha256=fLmo75okk1peDIiCmH3hmG8GbOte6fjkhwX8EaiOQJY,5124
+uipath/models/documents.py,sha256=gh063bG0pl4YGThWQIgprwRCKxnKVoMOZrXDfDEVnQw,7337
 uipath/models/entities.py,sha256=x6jbq4o_QhgL_pCgvHFsp9O8l333kQhn8e9ZCBs72UM,9823
 uipath/models/errors.py,sha256=WCxxHBlLzLF17YxjqsFkkyBLwEQM_dc6fFU5qmBjD4A,597
 uipath/models/exceptions.py,sha256=f71VsUyonK2uuH1Cs0tpP6f9dec6v6cffL1Z9EjTxm0,1870
@@ -224,8 +225,8 @@ uipath/tracing/_utils.py,sha256=zMjiKjNpSN3YQNEU4-u5AAvPtUsi8QuEqNLya89jfAU,1446
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=tnF_FiCx8qI2XaJDQgYkMN_gl9V0VqNR1uX7iawuLp8,8230
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.117.dist-info/METADATA,sha256=i69OX4o8c_XeqRQzg8dZjLkI03RpWgb5VfoGT-hQMrQ,6626
-uipath-2.1.117.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.117.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.117.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.117.dist-info/RECORD,,
+uipath-2.1.119.dist-info/METADATA,sha256=3bFAJBRf1iXbqhxg8hQUgj3ggLWI6Sptx_R-iQbunbM,6626
+uipath-2.1.119.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.119.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.119.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.119.dist-info/RECORD,,