uipath 2.1.68__py3-none-any.whl → 2.1.70__py3-none-any.whl

uipath/_cli/_auth/auth_config.json

@@ -1,6 +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 EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "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/_cli/_dev/_terminal/__init__.py

@@ -37,7 +37,7 @@ from ._models._execution import ExecutionRun
 from ._models._messages import LogMessage, TraceMessage
 from ._utils._chat import RunContextChatHandler, build_user_message_event
 from ._utils._exporter import RunContextExporter
-from ._utils._logger import RunContextLogHandler
+from ._utils._logger import RunContextLogHandler, patch_textual_stderr
 
 
 class UiPathDevTerminal(App[Any]):
@@ -61,6 +61,8 @@ class UiPathDevTerminal(App[Any]):
         runtime_factory: UiPathRuntimeFactory[Any, Any],
         **kwargs,
     ):
+        self._stderr_write_fd: int = patch_textual_stderr(self._add_subprocess_log)
+
         super().__init__(**kwargs)
 
         self.initial_entrypoint: str = "main.py"
@@ -357,3 +359,15 @@ class UiPathDevTerminal(App[Any]):
         )
         log_msg = LogMessage(run.id, "ERROR", tb, timestamp)
         self._handle_log_message(log_msg)
+
+    def _add_subprocess_log(self, level: str, message: str) -> None:
+        """Handle a stderr line coming from subprocesses."""
+
+        def add_log() -> None:
+            details_panel = self.query_one("#details-panel", RunDetailsPanel)
+            run = getattr(details_panel, "current_run", None)
+            if run:
+                log_msg = LogMessage(run.id, level, message, datetime.now())
+                self._handle_log_message(log_msg)
+
+        self.call_from_thread(add_log)

uipath/_cli/_dev/_terminal/_utils/_logger.py

@@ -1,6 +1,11 @@
+from __future__ import annotations
+
 import logging
+import os
+import re
+import threading
 from datetime import datetime
-from typing import Callable
+from typing import Callable, Pattern
 
 from .._models._messages import LogMessage
 
@@ -30,3 +35,64 @@ class RunContextLogHandler(logging.Handler):
         except Exception:
             # Don't let logging errors crash the app
             pass
+
+
+# A dispatcher is a callable that accepts (level, message) pairs
+DispatchLog = Callable[[str, str], None]
+
+LEVEL_PATTERNS: list[tuple[str, Pattern[str]]] = [
+    ("DEBUG", re.compile(r"^(DEBUG)[:\s-]+", re.I)),
+    ("INFO", re.compile(r"^(INFO)[:\s-]+", re.I)),
+    ("WARN", re.compile(r"^(WARNING|WARN)[:\s-]+", re.I)),
+    ("ERROR", re.compile(r"^(ERROR|ERRO)[:\s-]+", re.I)),
+]
+
+
+def patch_textual_stderr(dispatch_log: DispatchLog) -> int:
+    """Redirect subprocess stderr into a provided dispatcher.
+
+    Args:
+        dispatch_log: Callable invoked with (level, message) for each stderr line.
+                      This will be called from a background thread, so the caller
+                      should use `App.call_from_thread` or equivalent.
+
+    Returns:
+        int: The write file descriptor for stderr (pass to subprocesses).
+    """
+    from textual.app import _PrintCapture
+
+    read_fd, write_fd = os.pipe()
+
+    # Patch fileno() so subprocesses can write to our pipe
+    _PrintCapture.fileno = lambda self: write_fd  # type: ignore[method-assign]
+
+    def read_stderr_pipe() -> None:
+        with os.fdopen(read_fd, "r", buffering=1) as pipe_reader:
+            try:
+                for raw in pipe_reader:
+                    text = raw.rstrip()
+                    level: str = "ERROR"
+                    message: str = text
+
+                    # Try to parse a known level prefix
+                    for lvl, pattern in LEVEL_PATTERNS:
+                        m = pattern.match(text)
+                        if m:
+                            level = lvl
+                            message = text[m.end() :]
+                            break
+
+                    dispatch_log(level, message)
+
+            except Exception:
+                # Never raise from thread
+                pass
+
+    thread = threading.Thread(
+        target=read_stderr_pipe,
+        daemon=True,
+        name="stderr-reader",
+    )
+    thread.start()
+
+    return write_fd

uipath/_services/__init__.py

@@ -5,6 +5,7 @@ from .attachments_service import AttachmentsService
 from .buckets_service import BucketsService
 from .connections_service import ConnectionsService
 from .context_grounding_service import ContextGroundingService
+from .documents_service import DocumentsService
 from .entities_service import EntitiesService
 from .folder_service import FolderService
 from .jobs_service import JobsService
@@ -19,6 +20,7 @@ __all__ = [
     "BucketsService",
     "ConnectionsService",
     "ContextGroundingService",
+    "DocumentsService",
     "ProcessesService",
     "ApiClient",
     "QueuesService",

uipath/_services/documents_service.py

@@ -0,0 +1,651 @@
+import asyncio
+import time
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple
+from uuid import UUID
+
+from httpx._types import FileContent
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._utils import Endpoint
+from ..models.documents import (
+    ActionPriority,
+    ExtractionResponse,
+    ValidatedResult,
+    ValidationAction,
+)
+from ..tracing._traced import traced
+from ._base_service import BaseService
+
+POLLING_INTERVAL = 2  # seconds
+POLLING_TIMEOUT = 300  # seconds
+
+
+class DocumentsService(FolderContext, BaseService):
+    """Service for managing UiPath DocumentUnderstanding Document Operations.
+
+    This service provides methods to extract data from documents using UiPath's Document Understanding capabilities.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def _get_common_headers(self) -> Dict[str, str]:
+        return {
+            "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
+        }
+
+    def _get_project_id_by_name(self, project_name: str) -> str:
+        response = self.request(
+            "GET",
+            url=Endpoint("/du_/api/framework/projects"),
+            params={"api-version": 1.1, "type": "IXP"},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                project["id"]
+                for project in response.json()["projects"]
+                if project["name"] == project_name
+            )
+        except StopIteration:
+            raise ValueError(f"Project '{project_name}' not found.") from None
+
+    async def _get_project_id_by_name_async(self, project_name: str) -> str:
+        response = await self.request_async(
+            "GET",
+            url=Endpoint("/du_/api/framework/projects"),
+            params={"api-version": 1.1, "type": "IXP"},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                project["id"]
+                for project in response.json()["projects"]
+                if project["name"] == project_name
+            )
+        except StopIteration:
+            raise ValueError(f"Project '{project_name}' not found.") from None
+
+    def _get_project_tags(self, project_id: str) -> Set[str]:
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/tags"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+        return {tag["name"] for tag in response.json().get("tags", [])}
+
+    async def _get_project_tags_async(self, project_id: str) -> Set[str]:
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/tags"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+        return {tag["name"] for tag in response.json().get("tags", [])}
+
+    def _get_project_id_and_validate_tag(self, project_name: str, tag: str) -> str:
+        project_id = self._get_project_id_by_name(project_name)
+        tags = self._get_project_tags(project_id)
+        if tag not in tags:
+            raise ValueError(
+                f"Tag '{tag}' not found in project '{project_name}'. Available tags: {tags}"
+            )
+
+        return project_id
+
+    async def _get_project_id_and_validate_tag_async(
+        self, project_name: str, tag: str
+    ) -> str:
+        project_id = await self._get_project_id_by_name_async(project_name)
+        tags = await self._get_project_tags_async(project_id)
+        if tag not in tags:
+            raise ValueError(
+                f"Tag '{tag}' not found in project '{project_name}'. Available tags: {tags}"
+            )
+
+        return project_id
+
+    def _start_digitization(
+        self,
+        project_id: str,
+        file: FileContent,
+    ) -> 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"]
+
+    async def _start_digitization_async(
+        self,
+        project_id: str,
+        file: FileContent,
+    ) -> str:
+        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": file},
+            )
+        ).json()["documentId"]
+
+    def _start_extraction(
+        self,
+        project_id: str,
+        tag: str,
+        document_id: str,
+    ) -> str:
+        return self.request(
+            "POST",
+            url=Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/extraction/start"
+            ),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={"documentId": document_id},
+        ).json()["operationId"]
+
+    async def _start_extraction_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}/document-types/{UUID(int=0)}/extraction/start"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={"documentId": document_id},
+            )
+        ).json()["operationId"]
+
+    def _wait_for_operation(
+        self,
+        result_getter: Callable[[], Tuple[str, Any]],
+        wait_statuses: List[str],
+        success_status: str,
+    ) -> Any:
+        start_time = time.monotonic()
+        status = wait_statuses[0]
+        result = None
+
+        while (
+            status in wait_statuses
+            and (time.monotonic() - start_time) < POLLING_TIMEOUT
+        ):
+            status, result = result_getter()
+            time.sleep(POLLING_INTERVAL)
+
+        if status != success_status:
+            if time.monotonic() - start_time >= POLLING_TIMEOUT:
+                raise TimeoutError("Operation timed out.")
+            raise RuntimeError(f"Operation failed with status: {status}")
+
+        return result
+
+    async def _wait_for_operation_async(
+        self,
+        result_getter: Callable[[], Awaitable[Tuple[str, Any]]],
+        wait_statuses: List[str],
+        success_status: str,
+    ) -> Any:
+        start_time = time.monotonic()
+        status = wait_statuses[0]
+        result = None
+
+        while (
+            status in wait_statuses
+            and (time.monotonic() - start_time) < POLLING_TIMEOUT
+        ):
+            status, result = await result_getter()
+            await asyncio.sleep(POLLING_INTERVAL)
+
+        if status != success_status:
+            if time.monotonic() - start_time >= POLLING_TIMEOUT:
+                raise TimeoutError("Operation timed out.")
+            raise RuntimeError(f"Operation failed with status: {status}")
+
+        return result
+
+    def _wait_for_extraction(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> ExtractionResponse:
+        extraction_response = self._wait_for_operation(
+            result_getter=lambda: (
+                (
+                    result := self.request(
+                        method="GET",
+                        url=Endpoint(
+                            f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/extraction/result/{operation_id}"
+                        ),
+                        params={"api-version": 1.1},
+                        headers=self._get_common_headers(),
+                    ).json()
+                )["status"],
+                result.get("result", None),
+            ),
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["tag"] = tag
+        return ExtractionResponse.model_validate(extraction_response)
+
+    async def _wait_for_extraction_async(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> ExtractionResponse:
+        async def result_getter() -> Tuple[str, Any]:
+            result = await self.request_async(
+                method="GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/extraction/result/{operation_id}"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            )
+            json_result = result.json()
+            return json_result["status"], json_result.get("result", None)
+
+        extraction_response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        extraction_response["projectId"] = project_id
+        extraction_response["tag"] = tag
+        return ExtractionResponse.model_validate(extraction_response)
+
+    @traced(name="documents_extract", run_type="uipath")
+    def extract(
+        self,
+        project_name: str,
+        tag: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> ExtractionResponse:
+        """Extract predicted data from a document using an IXP project.
+
+        Args:
+            project_name (str): Name of the IXP project. Details about IXP projects can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project).
+            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.
+
+        Note:
+            Either `file` or `file_path` must be provided, but not both.
+
+        Returns:
+            ExtractionResponse: The extraction result containing predicted data.
+
+        Examples:
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                extraction_response = service.extract(
+                    project_name="MyProject",
+                    tag="live",
+                    file=file,
+                )
+            ```
+        """
+        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")
+
+        project_id = self._get_project_id_and_validate_tag(
+            project_name=project_name, tag=tag
+        )
+
+        if file_path is not None:
+            with open(Path(file_path), "rb") as handle:
+                document_id = self._start_digitization(
+                    project_id=project_id, file=handle
+                )
+        else:
+            document_id = self._start_digitization(project_id=project_id, file=file)  # type: ignore
+
+        operation_id = self._start_extraction(
+            project_id=project_id, tag=tag, document_id=document_id
+        )
+
+        return self._wait_for_extraction(
+            project_id=project_id, tag=tag, operation_id=operation_id
+        )
+
+    @traced(name="documents_extract_async", run_type="uipath")
+    async def extract_async(
+        self,
+        project_name: str,
+        tag: str,
+        file: Optional[FileContent] = None,
+        file_path: Optional[str] = None,
+    ) -> ExtractionResponse:
+        """Asynchronously extract predicted data from a document using an IXP project."""
+        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")
+
+        project_id = await self._get_project_id_and_validate_tag_async(
+            project_name=project_name, tag=tag
+        )
+
+        if file_path is not None:
+            with open(Path(file_path), "rb") as handle:
+                document_id = await self._start_digitization_async(
+                    project_id=project_id, file=handle
+                )
+        else:
+            document_id = await self._start_digitization_async(
+                project_id=project_id,
+                file=file,  # type: ignore
+            )
+
+        operation_id = await self._start_extraction_async(
+            project_id=project_id, tag=tag, document_id=document_id
+        )
+
+        return await self._wait_for_extraction_async(
+            project_id=project_id, tag=tag, operation_id=operation_id
+        )
+
+    def _start_validation(
+        self,
+        project_id: str,
+        tag: str,
+        action_title: str,
+        action_priority: ActionPriority,
+        action_catalog: str,
+        action_folder: str,
+        storage_bucket_name: str,
+        storage_bucket_directory_path: str,
+        extraction_response: ExtractionResponse,
+    ) -> str:
+        return self.request(
+            "POST",
+            url=Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start"
+            ),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+            json={
+                "extractionResult": extraction_response.extraction_result.model_dump(),
+                "documentId": extraction_response.extraction_result.document_id,
+                "actionTitle": action_title,
+                "actionPriority": action_priority,
+                "actionCatalog": action_catalog,
+                "actionFolder": action_folder,
+                "storageBucketName": storage_bucket_name,
+                "allowChangeOfDocumentType": True,
+                "storageBucketDirectoryPath": storage_bucket_directory_path,
+            },
+        ).json()["operationId"]
+
+    async def _start_validation_async(
+        self,
+        project_id: str,
+        tag: str,
+        action_title: str,
+        action_priority: ActionPriority,
+        action_catalog: str,
+        action_folder: str,
+        storage_bucket_name: str,
+        storage_bucket_directory_path: str,
+        extraction_response: ExtractionResponse,
+    ) -> str:
+        return (
+            await self.request_async(
+                "POST",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+                json={
+                    "extractionResult": extraction_response.extraction_result.model_dump(),
+                    "documentId": extraction_response.extraction_result.document_id,
+                    "actionTitle": action_title,
+                    "actionPriority": action_priority,
+                    "actionCatalog": action_catalog,
+                    "actionFolder": action_folder,
+                    "storageBucketName": storage_bucket_name,
+                    "allowChangeOfDocumentType": True,
+                    "storageBucketDirectoryPath": storage_bucket_directory_path,
+                },
+            )
+        ).json()["operationId"]
+
+    def _get_validation_result(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> Dict:  # type: ignore
+        return self.request(
+            method="GET",
+            url=Endpoint(
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}"
+            ),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        ).json()
+
+    async def _get_validation_result_async(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> Dict:  # type: ignore
+        return (
+            await self.request_async(
+                method="GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/result/{operation_id}"
+                ),
+                params={"api-version": 1.1},
+                headers=self._get_common_headers(),
+            )
+        ).json()
+
+    def _wait_for_create_validation_action(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> ValidationAction:
+        response = self._wait_for_operation(
+            lambda: (
+                (
+                    result := self._get_validation_result(
+                        project_id=project_id, tag=tag, operation_id=operation_id
+                    )
+                )["status"],
+                result.get("result", None),
+            ),
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["tag"] = tag
+        response["operationId"] = operation_id
+        return ValidationAction.model_validate(response)
+
+    async def _wait_for_create_validation_action_async(
+        self, project_id: str, tag: str, operation_id: str
+    ) -> ValidationAction:
+        async def result_getter() -> Tuple[str, Any]:
+            result = await self._get_validation_result_async(
+                project_id=project_id, tag=tag, operation_id=operation_id
+            )
+            return result["status"], result.get("result", None)
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["NotStarted", "Running"],
+            success_status="Succeeded",
+        )
+
+        response["projectId"] = project_id
+        response["tag"] = tag
+        response["operationId"] = operation_id
+        return ValidationAction.model_validate(response)
+
+    @traced(name="documents_create_validation_action", run_type="uipath")
+    def create_validation_action(
+        self,
+        action_title: str,
+        action_priority: ActionPriority,
+        action_catalog: str,
+        action_folder: str,
+        storage_bucket_name: str,
+        storage_bucket_directory_path: str,
+        extraction_response: ExtractionResponse,
+    ) -> ValidationAction:
+        """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).
+
+        Args:
+            action_title (str): Title of the action.
+            action_priority (ActionPriority): Priority of the action.
+            action_catalog (str): Catalog of the action.
+            action_folder (str): Folder of the action.
+            storage_bucket_name (str): Name of the storage bucket.
+            storage_bucket_directory_path (str): Directory path in the storage bucket.
+            extraction_response (ExtractionResponse): The extraction result to be validated, typically obtained from the [`extract`][uipath._services.documents_service.DocumentsService.extract] method.
+
+        Returns:
+            ValidationAction: The created validation action.
+
+        Examples:
+            ```python
+            validation_action = service.create_validation_action(
+                action_title="Test Validation Action",
+                action_priority=ActionPriority.MEDIUM,
+                action_catalog="default_du_actions",
+                action_folder="Shared",
+                storage_bucket_name="TestBucket",
+                storage_bucket_directory_path="TestDirectory",
+                extraction_response=extraction_response,
+            )
+            ```
+        """
+        operation_id = self._start_validation(
+            project_id=extraction_response.project_id,
+            tag=extraction_response.tag,  # should I validate tag again?
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            extraction_response=extraction_response,
+        )
+
+        return self._wait_for_create_validation_action(
+            project_id=extraction_response.project_id,
+            tag=extraction_response.tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_create_validation_action_async", run_type="uipath")
+    async def create_validation_action_async(
+        self,
+        action_title: str,
+        action_priority: ActionPriority,
+        action_catalog: str,
+        action_folder: str,
+        storage_bucket_name: str,
+        storage_bucket_directory_path: str,
+        extraction_response: ExtractionResponse,
+    ) -> ValidationAction:
+        """Asynchronously create a validation action for a document based on the extraction response."""
+        # Add reference to sync method docstring
+        operation_id = await self._start_validation_async(
+            project_id=extraction_response.project_id,
+            tag=extraction_response.tag,  # should I validate tag again?
+            action_title=action_title,
+            action_priority=action_priority,
+            action_catalog=action_catalog,
+            action_folder=action_folder,
+            storage_bucket_name=storage_bucket_name,
+            storage_bucket_directory_path=storage_bucket_directory_path,
+            extraction_response=extraction_response,
+        )
+
+        return await self._wait_for_create_validation_action_async(
+            project_id=extraction_response.project_id,
+            tag=extraction_response.tag,
+            operation_id=operation_id,
+        )
+
+    @traced(name="documents_get_validation_result", run_type="uipath")
+    def get_validation_result(
+        self, validation_action: ValidationAction
+    ) -> ValidatedResult:
+        """Get the result of a validation action.
+
+        Note:
+            This method will block until the validation action is completed, meaning the user has completed the validation in UiPath Action Center.
+
+        Args:
+            validation_action (ValidationAction): The validation action to get the result for, typically obtained from the [`create_validation_action`][uipath._services.documents_service.DocumentsService.create_validation_action] method.
+
+        Returns:
+            ValidatedResult: The result of the validation action.
+
+        Examples:
+            ```python
+            validated_result = service.get_validation_result(validation_action)
+            ```
+        """
+        response = self._wait_for_operation(
+            result_getter=lambda: (
+                (
+                    result := self._get_validation_result(
+                        project_id=validation_action.project_id,
+                        tag=validation_action.tag,
+                        operation_id=validation_action.operation_id,
+                    )
+                )["result"]["actionStatus"],
+                result["result"].get("validatedExtractionResults", None),
+            ),
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+
+        return ValidatedResult.model_validate(response)
+
+    @traced(name="documents_get_validation_result_async", run_type="uipath")
+    async def get_validation_result_async(
+        self, validation_action: ValidationAction
+    ) -> ValidatedResult:
+        """Asynchronously get the result of a validation action."""
+
+        async def result_getter() -> Tuple[str, Any]:
+            result = await self._get_validation_result_async(
+                project_id=validation_action.project_id,
+                tag=validation_action.tag,
+                operation_id=validation_action.operation_id,
+            )
+            return result["result"]["actionStatus"], result["result"].get(
+                "validatedExtractionResults", None
+            )
+
+        response = await self._wait_for_operation_async(
+            result_getter=result_getter,
+            wait_statuses=["Unassigned", "Pending"],
+            success_status="Completed",
+        )
+
+        return ValidatedResult.model_validate(response)

uipath/_uipath.py

@@ -13,6 +13,7 @@ from ._services import (
     BucketsService,
     ConnectionsService,
     ContextGroundingService,
+    DocumentsService,
     EntitiesService,
     FolderService,
     JobsService,
@@ -114,6 +115,10 @@ class UiPath:
             self._buckets_service,
         )
 
+    @property
+    def documents(self) -> DocumentsService:
+        return DocumentsService(self._config, self._execution_context)
+
     @property
     def queues(self) -> QueuesService:
         return QueuesService(self._config, self._execution_context)

uipath/models/documents.py

@@ -0,0 +1,127 @@
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FieldType(str, Enum):
+    TEXT = "Text"
+    NUMBER = "Number"
+    DATE = "Date"
+    NAME = "Name"
+    ADDRESS = "Address"
+    KEYWORD = "Keyword"
+    SET = "Set"
+    BOOLEAN = "Boolean"
+    TABLE = "Table"
+    INTERNAL = "Internal"
+
+
+class ActionPriority(str, Enum):
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+    CRITICAL = "Critical"
+
+
+class FieldValueProjection(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    id: str
+    name: str
+    value: str
+    unformatted_value: str = Field(alias="unformattedValue")
+    confidence: float
+    ocr_confidence: float = Field(alias="ocrConfidence")
+    type: FieldType
+
+
+class FieldGroupValueProjection(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    field_group_name: str = Field(alias="fieldGroupName")
+    field_values: List[FieldValueProjection] = Field(alias="fieldValues")
+
+
+class ExtractionResult(BaseModel):
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    document_id: str = Field(alias="DocumentId")
+    results_version: int = Field(alias="ResultsVersion")
+    results_document: dict = Field(alias="ResultsDocument")  # type: ignore
+    extractor_payloads: Optional[List[dict]] = Field(  # type: ignore
+        default=None, alias="ExtractorPayloads"
+    )
+    business_rules_results: Optional[List[dict]] = Field(  # type: ignore
+        default=None, alias="BusinessRulesResults"
+    )
+
+
+class ExtractionResponse(BaseModel):
+    """A model representing the response from a document extraction process.
+
+    Attributes:
+        extraction_result (ExtractionResult): The result of the extraction process.
+        data_projection (List[FieldGroupValueProjection]): A simplified projection of the extracted data.
+        project_id (str): The ID of the project associated with the extraction.
+        tag (str): The tag associated with the published model version.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    extraction_result: ExtractionResult = Field(alias="extractionResult")
+    data_projection: List[FieldGroupValueProjection] = Field(alias="dataProjection")
+    project_id: str = Field(alias="projectId")
+    tag: str
+
+
+class ValidationAction(BaseModel):
+    """A model representing a validation action for a document.
+
+    Attributes:
+        action_data (dict): The data associated with the validation action.
+        action_status (str): The status of the validation action. Possible values can be found in the [official documentation](https://docs.uipath.com/action-center/automation-cloud/latest/user-guide/about-actions#action-statuses).
+        project_id (str): The ID of the project associated with the validation action.
+        tag (str): The tag associated with the published model version.
+        operation_id (str): The operation ID associated with the validation action.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    action_data: dict = Field(alias="actionData")  # type: ignore
+    action_status: str = Field(alias="actionStatus")
+    project_id: str = Field(alias="projectId")
+    tag: str
+    operation_id: str = Field(alias="operationId")
+
+
+class ValidatedResult(BaseModel):
+    """A model representing the result of a validation action.
+
+    Attributes:
+        document_id (str): The ID of the validated document.
+        results_document (dict): The validated results document.
+    """
+
+    model_config = ConfigDict(
+        serialize_by_alias=True,
+        validate_by_alias=True,
+    )
+
+    document_id: str = Field(alias="DocumentId")
+    results_document: dict = Field(alias="ResultsDocument")  # type: ignore

{uipath-2.1.68.dist-info → uipath-2.1.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.68
+Version: 2.1.70
 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.68.dist-info → uipath-2.1.70.dist-info}/RECORD

@@ -2,7 +2,7 @@ uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
 uipath/_config.py,sha256=pi3qxPzDTxMEstj_XkGOgKJqD6RTHHv7vYv8sS_-d5Q,92
 uipath/_execution_context.py,sha256=Qo8VMUFgtiL-40KsZrvul5bGv1CRERle_fCw1ORCggY,2374
 uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,1861
-uipath/_uipath.py,sha256=p2ccvWpzBXAGFSSF_YaaSWdEqzMmRt786d0pFWrCEwU,4463
+uipath/_uipath.py,sha256=u01pAYrVYfwgAWGeSyD-3Eg33uNHFxhQaH1KAg9NSTA,4616
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=2RUgXYd8uJaYjA67xWb0w4IZuBmZoY8G1ccNmEQk9oM,2343
@@ -28,11 +28,11 @@ uipath/_cli/_auth/_oidc_utils.py,sha256=j9VCXai_dM9PF1WtoWEsXETvrWUjuTgU-dCJ3oRu
 uipath/_cli/_auth/_portal_service.py,sha256=vP82BhjA2D6E6y2wDcXqO1cM4thhPl6DeGsnNXCBdhA,9144
 uipath/_cli/_auth/_url_utils.py,sha256=Vr-eYbwW_ltmwkULNEAbn6LNsMHnT4uT1n_1zlqD4Ss,1503
 uipath/_cli/_auth/_utils.py,sha256=9nb76xe5XmDZ0TAncp-_1SKqL6FdwRi9eS3C2noN1lY,1591
-uipath/_cli/_auth/auth_config.json,sha256=UnAhdum8phjuZaZKE5KLp0IcPCbIltDEU1M_G8gVbos,443
+uipath/_cli/_auth/auth_config.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
-uipath/_cli/_dev/_terminal/__init__.py,sha256=q3vn6JhXCmLNc-5j17YqB2a22-ttD2iccUpyKcPryxY,13430
+uipath/_cli/_dev/_terminal/__init__.py,sha256=di_RiN9Mcp9wqyKRRqXag28vbSw8_78mCnQZNn9H-Ss,14027
 uipath/_cli/_dev/_terminal/_components/_chat.py,sha256=NLRoy49QScHiI-q0FGykkaU8ajv1d23fx7issSALcFA,4119
 uipath/_cli/_dev/_terminal/_components/_details.py,sha256=FbLYtJ56gqHV6CIrpzO_n9Sk_YNg4nzRKTSsbj-DBPQ,17257
 uipath/_cli/_dev/_terminal/_components/_history.py,sha256=dcT9tohEwpUaLGi7VWu5d-mDIF45UxFzN2Yvdf5N-eM,2691
@@ -43,7 +43,7 @@ uipath/_cli/_dev/_terminal/_models/_messages.py,sha256=p66MHUi_SS30CQWXtiwydybMK
 uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i9NTGvts_icCTxMdzEiY,3240
 uipath/_cli/_dev/_terminal/_utils/_chat.py,sha256=YUZxYVdmEManwHDuZsczJT1dWIYE1dVBgABlurwMFcE,8493
 uipath/_cli/_dev/_terminal/_utils/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
-uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=jeNShEED27cNIHTe_NNx-2kUiXpSLTmi0onM6tVkqRM,888
+uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=_ipTl_oAiMF9I7keGt2AAFAMz40DNLVMVkoiq-07UAU,2943
 uipath/_cli/_evals/_evaluator_factory.py,sha256=OWfLxPOEcDn4qv5m3n7LBfIBKcdTPml2ZCLcsqSymlU,5329
 uipath/_cli/_evals/_progress_reporter.py,sha256=hpSt0CXpIoFJGsbqZkqmwyGO_TBNesbWKlvDJUEDxd8,16455
 uipath/_cli/_evals/_runtime.py,sha256=WKcBT6DGzNRjgEOpmH0b7RoEbEsHMyAbcAMs8b_CAI0,11418
@@ -81,7 +81,7 @@ uipath/_events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,5496
 uipath/_events/_events.py,sha256=FhSqbEW4lcBp_QWcDsMtF5XtUtQ8S3rts6uEtMDmGbA,1252
 uipath/_resources/AGENTS.md,sha256=YWhWuX9XIbyVhVT3PnPc4Of3_q6bsNJcuzYu3N8f_Ug,25850
-uipath/_services/__init__.py,sha256=W08UO7ZBQRD8LBHsC6gaM4YBSUl8az0S4d6iZSKsdPE,965
+uipath/_services/__init__.py,sha256=eYZElMfYDQTQU6MMjIke5J-GGT9pzLD5QfbwLiTQkEE,1037
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
 uipath/_services/api_client.py,sha256=kGm04ijk9AOEQd2BMxvQg-2QoB8dmyoDwFFDPyutAGw,1966
@@ -90,6 +90,7 @@ uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZf
 uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
 uipath/_services/connections_service.py,sha256=Gt8zPY4oA7cMYAU2LI3lBieoBpV81BOGelnzDWJl_V4,7931
 uipath/_services/context_grounding_service.py,sha256=kp7h6Hd-VUuTqiDO-G7IanmXhaq0XHjXUk0ISFev-5c,24835
+uipath/_services/documents_service.py,sha256=UnFS8EpOZ_Ng2TZk3OiJJ3iNANvFs7QxuoG_v-lQj6c,24815
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
 uipath/_services/jobs_service.py,sha256=tTZNsdZKN3uP7bWPQyBCpJeQxTfuOWbKYOR4L-_yJo4,32736
@@ -139,6 +140,7 @@ uipath/models/buckets.py,sha256=N3Lj_dVCv709-ywhOOdyCSvsuLn41eGuAfSiik6Q6F8,1285
 uipath/models/connections.py,sha256=bTDg8xISSPmKB1GFNEEMD1OEZyBDFHfZVKqw4gab1pE,2524
 uipath/models/context_grounding.py,sha256=3MaF2Fv2QYle8UUWvKGkCN5XGpx2T4a34fdbBqJ2fCs,1137
 uipath/models/context_grounding_index.py,sha256=OhRyxZDHDSrEmBFK0-JLqMMMT64jir4XkHtQ54IKtc0,2683
+uipath/models/documents.py,sha256=g3xAhZlGcLuD6a_DHcUQWoLdzh5dENulouYAwrjGHEw,3963
 uipath/models/entities.py,sha256=x6jbq4o_QhgL_pCgvHFsp9O8l333kQhn8e9ZCBs72UM,9823
 uipath/models/errors.py,sha256=WCxxHBlLzLF17YxjqsFkkyBLwEQM_dc6fFU5qmBjD4A,597
 uipath/models/exceptions.py,sha256=F0ITAhJsl6Agvmnv4nxvgY5oC_lrYIlxWTLs0yx859M,1636
@@ -156,8 +158,8 @@ uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,199
 uipath/tracing/_utils.py,sha256=qd7N56tg6VXQ9pREh61esBgUWLNA0ssKsE0QlwrRWFM,11974
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.68.dist-info/METADATA,sha256=OCkfgVGObNPCBdNKlOpLLygiWar399jsvc4Cvr3y2g0,6482
-uipath-2.1.68.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.68.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.68.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.68.dist-info/RECORD,,
+uipath-2.1.70.dist-info/METADATA,sha256=Psv1JkySYItSXLqXbmXX2QBnKgVHtESV3-dEiKtCVEc,6482
+uipath-2.1.70.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.70.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.70.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.70.dist-info/RECORD,,