uipath 2.1.111__py3-none-any.whl → 2.1.112__py3-none-any.whl

uipath/_cli/_debug/_bridge.py

@@ -4,7 +4,7 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Literal, Optional, Set
 
 from pydantic import BaseModel
 from pysignalr.client import SignalRClient
@@ -123,7 +123,7 @@ class UiPathDebugBridge(ABC):
         pass
 
     @abstractmethod
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at.
 
         Returns:
@@ -220,7 +220,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         """Print error."""
         self.console.print()
         self.console.print("[red]─" * 40)
-        self.console.print(f"[red]✗ Error[/red] [dim]{execution_id}")
+        self.console.print("[red]✗ Error[/red]")
         self.console.print("[red]─" * 40)
 
         # Truncate very long errors
@@ -228,7 +228,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         if len(error) > 500:
             error_display = error[:500] + "\n[dim]... (truncated)"
 
-        self.console.print(f"[white]{error_display}[/white]")
+        self.console.print(f"[red]{error_display}[/red]")
         self.console.print("[red]─" * 40)
 
     async def wait_for_resume(self) -> Any:
@@ -252,21 +252,14 @@ class ConsoleDebugBridge(UiPathDebugBridge):
                 # These commands don't resume execution, loop again
                 continue
 
-            # Reset step modes if continuing
-            if command_result["command"] == DebugCommand.CONTINUE:
-                self.state.step_mode = False
-
-            if command_result["command"] == DebugCommand.QUIT:
-                raise DebuggerQuitException("User requested exit")
-
             # Commands that resume execution: CONTINUE, STEP
             self.console.print()
             return command_result
 
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at."""
         if self.state.step_mode:
-            return ["*"]  # Suspend at all nodes
+            return "*"  # Suspend at all nodes
         return list(self.state.breakpoints)  # Only suspend at breakpoints
 
     def _parse_command(self, user_input: str) -> Dict[str, Any]:
@@ -283,6 +276,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         args = parts[1:] if len(parts) > 1 else []
 
         if cmd in ["c", "continue"]:
+            self.state.step_mode = False
             return {"command": DebugCommand.CONTINUE, "args": None}
 
         elif cmd in ["s", "step"]:
@@ -318,7 +312,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
             }
 
         elif cmd in ["q", "quit", "exit"]:
-            raise KeyboardInterrupt("User requested exit")
+            raise DebuggerQuitException("User requested exit")
 
         elif cmd in ["h", "help", "?"]:
             self._print_help()
@@ -465,26 +459,75 @@ class SignalRDebugBridge(UiPathDebugBridge):
         self._client = SignalRClient(self.hub_url, headers=all_headers)
 
         # Register event handlers
-        self._client.on("ResumeExecution", self._handle_resume)
+        self._client.on("Start", self._handle_start)
+        self._client.on("Resume", self._handle_resume)
+        self._client.on("Step", self._handle_step)
+        self._client.on("AddBreakpoints", self._handle_add_breakpoints)
+        self._client.on("RemoveBreakpoints", self._handle_remove_breakpoints)
+        self._client.on("Quit", self._handle_quit)
         self._client.on_open(self._handle_open)
         self._client.on_close(self._handle_close)
         self._client.on_error(self._handle_error)
 
-        # Start connection in background
-        asyncio.create_task(self._client.run())
+        self._run_task = asyncio.create_task(self._client.run())
+
+        async def cleanup_run_task() -> str:
+            error_message = (
+                "Failed to establish WebSocket connection within 10s timeout"
+            )
+
+            if self._run_task:
+                if not self._run_task.done():
+                    self._run_task.cancel()
+                try:
+                    await self._run_task
+                except asyncio.CancelledError:
+                    pass  # Expected on cancel
+                except Exception as task_error:
+                    error_msg = str(task_error).strip()
+                    error_detail = f": {error_msg}" if error_msg else ""
+                    return f"{error_message}: {type(task_error).__name__}{error_detail}"
+
+            return error_message
+
+        try:
+            # Wait for connection with timeout
+            await asyncio.wait_for(self._connected_event.wait(), timeout=10.0)
+        except asyncio.TimeoutError as e:
+            # Clean up on timeout
+            raise RuntimeError(await cleanup_run_task()) from e
+        except Exception:
+            # Clean up on any other error
+            await cleanup_run_task()
+            raise
 
-        # Wait for connection to establish
-        await asyncio.wait_for(self._connected_event.wait(), timeout=30.0)
+        # Check if run_task failed
+        if self._run_task.done():
+            exception = self._run_task.exception()
+            if exception:
+                raise exception
 
     async def disconnect(self) -> None:
         """Close SignalR connection."""
-        if self._client and hasattr(self._client, "_transport"):
-            transport = self._client._transport
-            if transport and hasattr(transport, "_ws") and transport._ws:
-                try:
+        if not self._client:
+            return
+
+        # Cancel the run task first
+        if self._run_task and not self._run_task.done():
+            self._run_task.cancel()
+            try:
+                await self._run_task
+            except (Exception, asyncio.CancelledError):
+                pass
+
+        # Try to close the client cleanly
+        try:
+            if hasattr(self._client, "_transport"):
+                transport = self._client._transport
+                if transport and hasattr(transport, "_ws") and transport._ws:
                     await transport._ws.close()
-                except Exception as e:
-                    logger.warning(f"Error closing SignalR WebSocket: {e}")
+        except Exception as e:
+            logger.warning(f"Error closing SignalR WebSocket: {e}")
 
     async def emit_execution_started(self, execution_id: str, **kwargs) -> None:
         """Send execution started event."""
@@ -541,6 +584,9 @@ class SignalRDebugBridge(UiPathDebugBridge):
         error: str,
     ) -> None:
         """Send execution error event."""
+        if not self._connected_event.is_set():
+            return
+
         logger.error(f"Execution error: {execution_id} - {error}")
         await self._send(
             "OnExecutionError",
@@ -558,24 +604,139 @@ class SignalRDebugBridge(UiPathDebugBridge):
         logger.info("Resume command received")
         return self._resume_data
 
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at."""
         if self.state.step_mode:
-            return ["*"]  # Suspend at all nodes
+            return "*"  # Suspend at all nodes
         return list(self.state.breakpoints)  # Only suspend at breakpoints
 
-    async def _send(self, method: str, data: Dict[str, Any]) -> None:
-        """Send message to SignalR hub."""
+    async def _send(self, event_name: str, data: Dict[str, Any]) -> None:
+        """Send message to SignalR hub via SendCommand.
+
+        Args:
+            event_name: The event/command name (e.g., "OnExecutionStarted")
+            data: The data payload to send
+        """
         if not self._client:
             raise RuntimeError("SignalR client not connected")
+        try:
+            # Wrap the event in SendCommand protocol
+            # Server expects: SendCommand(event_name, json_string_of_data)
+            data_json = json.dumps(data)
+            arguments: list[Any] = [event_name, data_json]
+            await self._client.send(method="SendCommand", arguments=arguments)
+            logger.debug(f"Sent command: {event_name} with data: {data}")
+        except Exception as e:
+            logger.error(f"Error sending command {event_name} to SignalR hub: {e}")
+
+    async def _handle_start(self, args: list[Any]) -> None:
+        """Handle Start command from SignalR server.
 
-        await self._client.send(method=method, arguments=[data])
+        Args:
+            args: List containing command arguments, typically [dict_with_args]
+        """
+        logger.info(f"Start command received with args: {args}")
+        if not args or len(args) == 0:
+            logger.warning("Start command received with empty args.")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        self.state.breakpoints = set(command_args.get("breakpoints", []))
+        step_mode = command_args.get("enableStepMode", False)
+        self.state.step_mode = step_mode
 
     async def _handle_resume(self, args: list[Any]) -> None:
-        """Handle resume command from SignalR server."""
-        if self._resume_event and len(args) > 0:
-            self._resume_data = args[0]
+        """Handle Resume command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        logger.info(f"Resume command received with args: {args}")
+        command_args = args[0] if args and len(args) > 0 else {}
+
+        if self._resume_event:
+            self._resume_data = command_args
             self._resume_event.set()
+            logger.info("Resume event set")
+        else:
+            logger.warning("Resume command received but no resume event is waiting")
+
+    async def _handle_step(self, args: list[Any]) -> None:
+        """Handle Step command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        logger.info(f"Step command received with args: {args}")
+        self.state.step_mode = True
+        logger.info("Step mode enabled")
+
+    async def _handle_add_breakpoints(self, args: list[Any]) -> None:
+        """Handle AddBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments with breakpoints list
+        """
+        logger.info(f"AddBreakpoints command received with args: {args}")
+        if not args or len(args) == 0:
+            logger.warning("AddBreakpoints command received with empty args.")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        break_points = command_args.get("breakpoints", [])
+
+        for bp in break_points:
+            node_name = (
+                bp.get("node", {}).get("name")
+                if isinstance(bp.get("node"), dict)
+                else None
+            )
+            if node_name:
+                self.state.add_breakpoint(node_name)
+                logger.info(f"Breakpoint set at: {node_name}")
+            else:
+                logger.warning(f"Breakpoint command received without node name: {bp}")
+
+    async def _handle_remove_breakpoints(self, args: list[Any]) -> None:
+        """Handle RemoveBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments with breakpoints list
+        """
+        logger.info(f"RemoveBreakpoints command received with args: {args}")
+        if not args or len(args) == 0:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        break_points = command_args.get("breakpoints", [])
+
+        if not break_points:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+        else:
+            for bp in break_points:
+                node_name = (
+                    bp.get("node", {}).get("name")
+                    if isinstance(bp.get("node"), dict)
+                    else None
+                )
+                if node_name:
+                    self.state.remove_breakpoint(node_name)
+                    logger.info(f"Breakpoint removed: {node_name}")
+
+    async def _handle_quit(self, args: list[Any]) -> None:
+        """Handle Quit command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        if args:
+            logger.info(f"Quit command received from server with args: {args}")
+        else:
+            logger.info("Quit command received from server")
+        raise DebuggerQuitException("Quit command received from server")
 
     async def _handle_open(self) -> None:
         """Handle SignalR connection open."""

uipath/_cli/_debug/_runtime.py

@@ -35,6 +35,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
         self.context: UiPathRuntimeContext = context
         self.factory: UiPathRuntimeFactory[T, C] = factory
         self.debug_bridge: UiPathDebugBridge = debug_bridge
+        self.execution_id: str = context.job_id or "default"
         self._inner_runtime: Optional[T] = None
 
     @classmethod
@@ -57,7 +58,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
                 raise RuntimeError("Failed to create inner runtime")
 
             await self.debug_bridge.emit_execution_started(
-                execution_id=self.context.job_id or "default"
+                execution_id=self.execution_id
             )
 
             # Try to stream events from inner runtime
@@ -78,8 +79,11 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         except Exception as e:
             # Emit execution error
+            self.context.result = UiPathRuntimeResult(
+                status=UiPathRuntimeStatus.FAULTED,
+            )
             await self.debug_bridge.emit_execution_error(
-                execution_id=self.context.job_id or "default",
+                execution_id=self.execution_id,
                 error=str(e),
             )
             raise

uipath/_cli/_runtime/_contracts.py

@@ -382,7 +382,7 @@ class UiPathRuntimeContext(BaseModel):
     log_handler: Optional[logging.Handler] = None
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
-    breakpoints: Optional[List[str]] = None
+    breakpoints: Optional[List[str] | Literal["*"]] = None
 
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 

uipath/_resources/SDK_REFERENCE.md

@@ -127,19 +127,19 @@ Documents service
 # 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
 
-# Asynchronously create a validation action for a document based on the extraction response.
+# 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) -> uipath.models.documents.ExtractionResponse
+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]
 
-# Asynchronously extract predicted data from a document using an IXP project.
-sdk.documents.extract_async(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> uipath.models.documents.ExtractionResponse
+# 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]
 
 # Get the result of a validation action.
 sdk.documents.get_validation_result(validation_action: uipath.models.documents.ValidationAction) -> uipath.models.documents.ValidatedResult
 
-# Asynchronously get the result of a validation action.
+# Asynchronous version of the [`get_validation_result`][uipath._services.documents_service.DocumentsService.get_validation_result] method.
 sdk.documents.get_validation_result_async(validation_action: uipath.models.documents.ValidationAction) -> uipath.models.documents.ValidatedResult
 
 ```

uipath/_services/documents_service.py

@@ -1,7 +1,8 @@
 import asyncio
 import time
+from contextlib import nullcontext
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple, Union
 from uuid import UUID
 
 from httpx._types import FileContent
@@ -13,6 +14,8 @@ from .._utils import Endpoint
 from ..models.documents import (
     ActionPriority,
     ExtractionResponse,
+    ExtractionResponseIXP,
+    ProjectType,
     ValidatedResult,
     ValidationAction,
 )
@@ -41,11 +44,13 @@ class DocumentsService(FolderContext, BaseService):
             "X-UiPath-Internal-ConsumptionSourceType": "CodedAgents",
         }
 
-    def _get_project_id_by_name(self, project_name: str) -> str:
+    def _get_project_id_by_name(
+        self, project_name: str, project_type: ProjectType
+    ) -> str:
         response = self.request(
             "GET",
             url=Endpoint("/du_/api/framework/projects"),
-            params={"api-version": 1.1, "type": "IXP"},
+            params={"api-version": 1.1, "type": project_type.value},
             headers=self._get_common_headers(),
         )
 
@@ -58,11 +63,13 @@ class DocumentsService(FolderContext, BaseService):
         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:
+    async def _get_project_id_by_name_async(
+        self, project_name: str, project_type: ProjectType
+    ) -> str:
         response = await self.request_async(
             "GET",
             url=Endpoint("/du_/api/framework/projects"),
-            params={"api-version": 1.1, "type": "IXP"},
+            params={"api-version": 1.1, "type": project_type.value},
             headers=self._get_common_headers(),
         )
 
@@ -93,8 +100,10 @@ class DocumentsService(FolderContext, BaseService):
         )
         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)
+    def _get_project_id_and_validate_tag(
+        self, project_name: str, project_type: ProjectType, tag: str
+    ) -> str:
+        project_id = self._get_project_id_by_name(project_name, project_type)
         tags = self._get_project_tags(project_id)
         if tag not in tags:
             raise ValueError(
@@ -104,9 +113,11 @@ class DocumentsService(FolderContext, BaseService):
         return project_id
 
     async def _get_project_id_and_validate_tag_async(
-        self, project_name: str, tag: str
+        self, project_name: str, project_type: ProjectType, tag: str
     ) -> str:
-        project_id = await self._get_project_id_by_name_async(project_name)
+        project_id = await self._get_project_id_by_name_async(
+            project_name, project_type
+        )
         tags = await self._get_project_tags_async(project_id)
         if tag not in tags:
             raise ValueError(
@@ -147,16 +158,71 @@ class DocumentsService(FolderContext, BaseService):
             )
         ).json()["documentId"]
 
+    def _get_document_type_id(
+        self,
+        project_id: str,
+        document_type_name: Optional[str],
+        project_type: ProjectType,
+    ) -> str:
+        if project_type == ProjectType.IXP:
+            return str(UUID(int=0))
+
+        response = self.request(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("documentTypes", [])
+                if extractor["name"].lower() == document_type_name.lower()  # type: ignore
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Document type '{document_type_name}' not found."
+            ) from None
+
+    async def _get_document_type_id_async(
+        self,
+        project_id: str,
+        document_type_name: Optional[str],
+        project_type: ProjectType,
+    ) -> str:
+        if project_type == ProjectType.IXP:
+            return str(UUID(int=0))
+
+        response = await self.request_async(
+            "GET",
+            url=Endpoint(f"/du_/api/framework/projects/{project_id}/document-types"),
+            params={"api-version": 1.1},
+            headers=self._get_common_headers(),
+        )
+
+        try:
+            return next(
+                extractor["id"]
+                for extractor in response.json().get("documentTypes", [])
+                if extractor["name"].lower() == document_type_name.lower()  # type: ignore
+            )
+        except StopIteration:
+            raise ValueError(
+                f"Document type '{document_type_name}' not found."
+            ) from None
+
     def _start_extraction(
         self,
         project_id: str,
         tag: str,
+        document_type_id: 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"
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/start"
             ),
             params={"api-version": 1.1},
             headers=self._get_common_headers(),
@@ -167,13 +233,14 @@ class DocumentsService(FolderContext, BaseService):
         self,
         project_id: str,
         tag: str,
+        document_type_id: 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"
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/start"
                 ),
                 params={"api-version": 1.1},
                 headers=self._get_common_headers(),
@@ -183,7 +250,7 @@ class DocumentsService(FolderContext, BaseService):
 
     def _wait_for_operation(
         self,
-        result_getter: Callable[[], Tuple[str, Any]],
+        result_getter: Callable[[], Tuple[Any, Optional[Any], Optional[Any]]],
         wait_statuses: List[str],
         success_status: str,
     ) -> Any:
@@ -195,19 +262,23 @@ class DocumentsService(FolderContext, BaseService):
             status in wait_statuses
             and (time.monotonic() - start_time) < POLLING_TIMEOUT
         ):
-            status, result = result_getter()
+            status, error, 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}")
+            raise RuntimeError(
+                f"Operation failed with status: {status}, error: {error}"
+            )
 
         return result
 
     async def _wait_for_operation_async(
         self,
-        result_getter: Callable[[], Awaitable[Tuple[str, Any]]],
+        result_getter: Callable[
+            [], Awaitable[Tuple[Any, Optional[Any], Optional[Any]]]
+        ],
         wait_statuses: List[str],
         success_status: str,
     ) -> Any:
@@ -219,55 +290,80 @@ class DocumentsService(FolderContext, BaseService):
             status in wait_statuses
             and (time.monotonic() - start_time) < POLLING_TIMEOUT
         ):
-            status, result = await result_getter()
+            status, error, 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}")
+            raise RuntimeError(
+                f"Operation failed with status: {status}, error: {error}"
+            )
 
         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"],
+        self,
+        project_id: str,
+        tag: str,
+        document_type_id: str,
+        operation_id: str,
+        project_type: ProjectType,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        def result_getter() -> Tuple[str, str, Any]:
+            result = self.request(
+                method="GET",
+                url=Endpoint(
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/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),
-            ),
+            )
+
+        extraction_response = self._wait_for_operation(
+            result_getter=result_getter,
             wait_statuses=["NotStarted", "Running"],
             success_status="Succeeded",
         )
 
         extraction_response["projectId"] = project_id
         extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+
+        if project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(extraction_response)
+
         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(),
+        self,
+        project_id: str,
+        tag: str,
+        document_type_id: str,
+        operation_id: str,
+        project_type: ProjectType,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
+        async def result_getter() -> Tuple[str, str, Any]:
+            result = (
+                await self.request_async(
+                    method="GET",
+                    url=Endpoint(
+                        f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/extraction/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),
             )
-            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,
@@ -277,6 +373,11 @@ class DocumentsService(FolderContext, BaseService):
 
         extraction_response["projectId"] = project_id
         extraction_response["tag"] = tag
+        extraction_response["documentTypeId"] = document_type_id
+
+        if project_type == ProjectType.IXP:
+            return ExtractionResponseIXP.model_validate(extraction_response)
+
         return ExtractionResponse.model_validate(extraction_response)
 
     @traced(name="documents_extract", run_type="uipath")
@@ -286,14 +387,18 @@ class DocumentsService(FolderContext, BaseService):
         tag: str,
         file: Optional[FileContent] = None,
         file_path: Optional[str] = None,
-    ) -> ExtractionResponse:
+        project_type: ProjectType = ProjectType.IXP,
+        document_type_name: Optional[str] = None,
+    ) -> Union[ExtractionResponse, ExtractionResponseIXP]:
         """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).
+            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.
             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`.
 
         Note:
             Either `file` or `file_path` must be provided, but not both.
@@ -302,38 +407,63 @@ class DocumentsService(FolderContext, BaseService):
             ExtractionResponse: The extraction result containing predicted data.
 
         Examples:
+            IXP projects:
             ```python
             with open("path/to/document.pdf", "rb") as file:
                 extraction_response = service.extract(
-                    project_name="MyProject",
+                    project_name="MyIXPProjectName",
                     tag="live",
                     file=file,
                 )
             ```
+
+            DU Modern projects:
+            ```python
+            with open("path/to/document.pdf", "rb") as file:
+                extraction_response = service.extract(
+                    project_name="MyModernProjectName",
+                    tag="Production",
+                    file=file,
+                    project_type=ProjectType.MODERN,
+                    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`"
+            )
 
         project_id = self._get_project_id_and_validate_tag(
-            project_name=project_name, tag=tag
+            project_name=project_name, project_type=project_type, 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
+        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_type_id = self._get_document_type_id(
+            project_id=project_id,
+            document_type_name=document_type_name,
+            project_type=project_type,
+        )
 
         operation_id = self._start_extraction(
-            project_id=project_id, tag=tag, document_id=document_id
+            project_id=project_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            document_id=document_id,
         )
 
         return self._wait_for_extraction(
-            project_id=project_id, tag=tag, operation_id=operation_id
+            project_id=project_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            operation_id=operation_id,
+            project_type=project_type,
         )
 
     @traced(name="documents_extract_async", run_type="uipath")
@@ -343,40 +473,55 @@ class DocumentsService(FolderContext, BaseService):
         tag: str,
         file: Optional[FileContent] = None,
         file_path: Optional[str] = None,
-    ) -> ExtractionResponse:
-        """Asynchronously extract predicted data from a document using an IXP project."""
+        project_type: ProjectType = ProjectType.IXP,
+        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_id = await self._get_project_id_and_validate_tag_async(
-            project_name=project_name, tag=tag
+            project_name=project_name, project_type=project_type, 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:
+        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=file,  # type: ignore
+                file=handle,  # type: ignore
             )
 
+        document_type_id = await self._get_document_type_id_async(
+            project_id=project_id,
+            document_type_name=document_type_name,
+            project_type=project_type,
+        )
+
         operation_id = await self._start_extraction_async(
-            project_id=project_id, tag=tag, document_id=document_id
+            project_id=project_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            document_id=document_id,
         )
 
         return await self._wait_for_extraction_async(
-            project_id=project_id, tag=tag, operation_id=operation_id
+            project_id=project_id,
+            tag=tag,
+            document_type_id=document_type_id,
+            operation_id=operation_id,
+            project_type=project_type,
         )
 
     def _start_validation(
         self,
         project_id: str,
         tag: str,
+        document_type_id: str,
         action_title: str,
         action_priority: ActionPriority,
         action_catalog: str,
@@ -388,7 +533,7 @@ class DocumentsService(FolderContext, BaseService):
         return self.request(
             "POST",
             url=Endpoint(
-                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start"
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/start"
             ),
             params={"api-version": 1.1},
             headers=self._get_common_headers(),
@@ -409,6 +554,7 @@ class DocumentsService(FolderContext, BaseService):
         self,
         project_id: str,
         tag: str,
+        document_type_id: str,
         action_title: str,
         action_priority: ActionPriority,
         action_catalog: str,
@@ -421,7 +567,7 @@ class DocumentsService(FolderContext, BaseService):
             await self.request_async(
                 "POST",
                 url=Endpoint(
-                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{UUID(int=0)}/validation/start"
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/start"
                 ),
                 params={"api-version": 1.1},
                 headers=self._get_common_headers(),
@@ -440,25 +586,25 @@ class DocumentsService(FolderContext, BaseService):
         ).json()["operationId"]
 
     def _get_validation_result(
-        self, project_id: str, tag: str, operation_id: str
+        self, project_id: str, tag: str, document_type_id: 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}"
+                f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/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
+        self, project_id: str, tag: str, document_type_id: 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}"
+                    f"/du_/api/framework/projects/{project_id}/{tag}/document-types/{document_type_id}/validation/result/{operation_id}"
                 ),
                 params={"api-version": 1.1},
                 headers=self._get_common_headers(),
@@ -466,43 +612,58 @@ class DocumentsService(FolderContext, BaseService):
         ).json()
 
     def _wait_for_create_validation_action(
-        self, project_id: str, tag: str, operation_id: str
+        self, project_id: str, tag: str, document_type_id: 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"],
+        def result_getter() -> Tuple[Any, Optional[Any], Optional[Any]]:
+            result = self._get_validation_result(
+                project_id=project_id,
+                tag=tag,
+                document_type_id=document_type_id,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
                 result.get("result", None),
-            ),
+            )
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
             wait_statuses=["NotStarted", "Running"],
             success_status="Succeeded",
         )
 
         response["projectId"] = project_id
         response["tag"] = tag
+        response["documentTypeId"] = document_type_id
         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
+        self, project_id: str, tag: str, document_type_id: str, operation_id: str
     ) -> ValidationAction:
-        async def result_getter() -> Tuple[str, Any]:
+        async def result_getter_async() -> Tuple[Any, Optional[Any], Optional[Any]]:
             result = await self._get_validation_result_async(
-                project_id=project_id, tag=tag, operation_id=operation_id
+                project_id=project_id,
+                tag=tag,
+                document_type_id=document_type_id,
+                operation_id=operation_id,
+            )
+            return (
+                result["status"],
+                result.get("error", None),
+                result.get("result", None),
             )
-            return result["status"], result.get("result", None)
 
         response = await self._wait_for_operation_async(
-            result_getter=result_getter,
+            result_getter=result_getter_async,
             wait_statuses=["NotStarted", "Running"],
             success_status="Succeeded",
         )
 
         response["projectId"] = project_id
         response["tag"] = tag
+        response["documentTypeId"] = document_type_id
         response["operationId"] = operation_id
         return ValidationAction.model_validate(response)
 
@@ -546,7 +707,8 @@ class DocumentsService(FolderContext, BaseService):
         """
         operation_id = self._start_validation(
             project_id=extraction_response.project_id,
-            tag=extraction_response.tag,  # should I validate tag again?
+            tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
             action_title=action_title,
             action_priority=action_priority,
             action_catalog=action_catalog,
@@ -559,6 +721,7 @@ class DocumentsService(FolderContext, BaseService):
         return self._wait_for_create_validation_action(
             project_id=extraction_response.project_id,
             tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
             operation_id=operation_id,
         )
 
@@ -573,11 +736,11 @@ class DocumentsService(FolderContext, BaseService):
         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
+        """Asynchronous version of the [`create_validation_action`][uipath._services.documents_service.DocumentsService.create_validation_action] method."""
         operation_id = await self._start_validation_async(
             project_id=extraction_response.project_id,
-            tag=extraction_response.tag,  # should I validate tag again?
+            tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
             action_title=action_title,
             action_priority=action_priority,
             action_catalog=action_catalog,
@@ -590,6 +753,7 @@ class DocumentsService(FolderContext, BaseService):
         return await self._wait_for_create_validation_action_async(
             project_id=extraction_response.project_id,
             tag=extraction_response.tag,
+            document_type_id=extraction_response.document_type_id,
             operation_id=operation_id,
         )
 
@@ -613,17 +777,22 @@ class DocumentsService(FolderContext, BaseService):
             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"],
+
+        def result_getter() -> Tuple[str, None, Any]:
+            result = self._get_validation_result(
+                project_id=validation_action.project_id,
+                tag=validation_action.tag,
+                document_type_id=validation_action.document_type_id,
+                operation_id=validation_action.operation_id,
+            )
+            return (
+                result["result"]["actionStatus"],
+                None,
                 result["result"].get("validatedExtractionResults", None),
-            ),
+            )
+
+        response = self._wait_for_operation(
+            result_getter=result_getter,
             wait_statuses=["Unassigned", "Pending"],
             success_status="Completed",
         )
@@ -634,16 +803,19 @@ class DocumentsService(FolderContext, BaseService):
     async def get_validation_result_async(
         self, validation_action: ValidationAction
     ) -> ValidatedResult:
-        """Asynchronously get the result of a validation action."""
+        """Asynchronous version of the [`get_validation_result`][uipath._services.documents_service.DocumentsService.get_validation_result] method."""
 
-        async def result_getter() -> Tuple[str, Any]:
+        async def result_getter() -> Tuple[str, None, Any]:
             result = await self._get_validation_result_async(
                 project_id=validation_action.project_id,
                 tag=validation_action.tag,
+                document_type_id=validation_action.document_type_id,
                 operation_id=validation_action.operation_id,
             )
-            return result["result"]["actionStatus"], result["result"].get(
-                "validatedExtractionResults", None
+            return (
+                result["result"]["actionStatus"],
+                None,
+                result["result"].get("validatedExtractionResults", None),
             )
 
         response = await self._wait_for_operation_async(

uipath/models/documents.py

@@ -18,10 +18,25 @@ class FieldType(str, Enum):
 
 
 class ActionPriority(str, Enum):
+    """Priority levels for validation actions. More details can be found in the [official documentation](https://docs.uipath.com/action-center/automation-cloud/latest/user-guide/create-document-validation-action#configuration)."""
+
     LOW = "Low"
+    """Low priority"""
     MEDIUM = "Medium"
+    """Medium priority"""
     HIGH = "High"
+    """High priority"""
     CRITICAL = "Critical"
+    """Critical priority"""
+
+
+class ProjectType(str, Enum):
+    """Project types available and supported by Documents Service."""
+
+    IXP = "IXP"
+    """Represents an [IXP](https://docs.uipath.com/ixp/automation-cloud/latest/overview/managing-projects#creating-a-new-project) project type."""
+    MODERN = "Modern"
+    """Represents a [DU Modern](https://docs.uipath.com/document-understanding/automation-cloud/latest/user-guide/about-document-understanding) project type."""
 
 
 class FieldValueProjection(BaseModel):
@@ -71,9 +86,9 @@ class ExtractionResponse(BaseModel):
 
     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.
+        document_type_id (str): The ID of the document type associated with the extraction.
     """
 
     model_config = ConfigDict(
@@ -82,9 +97,19 @@ class ExtractionResponse(BaseModel):
     )
 
     extraction_result: ExtractionResult = Field(alias="extractionResult")
-    data_projection: List[FieldGroupValueProjection] = Field(alias="dataProjection")
     project_id: str = Field(alias="projectId")
     tag: str
+    document_type_id: str = Field(alias="documentTypeId")
+
+
+class ExtractionResponseIXP(ExtractionResponse):
+    """A model representing the response from a document extraction process for IXP projects.
+
+    Attributes:
+        data_projection (List[FieldGroupValueProjection]): A simplified projection of the extracted data.
+    """
+
+    data_projection: List[FieldGroupValueProjection] = Field(alias="dataProjection")
 
 
 class ValidationAction(BaseModel):
@@ -107,6 +132,7 @@ class ValidationAction(BaseModel):
     action_status: str = Field(alias="actionStatus")
     project_id: str = Field(alias="projectId")
     tag: str
+    document_type_id: str = Field(alias="documentTypeId")
     operation_id: str = Field(alias="operationId")
 
 

{uipath-2.1.111.dist-info → uipath-2.1.112.dist-info}/METADATA

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

@@ -34,8 +34,8 @@ uipath/_cli/_auth/auth_config.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0Q
 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/_debug/_bridge.py,sha256=_CArFkZlwBYUkmpfqehcXyPNVDXv00vPNFfKJiOVJoA,22269
-uipath/_cli/_debug/_runtime.py,sha256=iQ0L7WVvh0eF85D6sckZTTjE5wc_KQjCncT23hEdC6k,5596
+uipath/_cli/_debug/_bridge.py,sha256=iF3lI73TRyVvQDf7Zb-HUxrVrW5oAnWOPT7JIFkFL_I,28433
+uipath/_cli/_debug/_runtime.py,sha256=cGWoyQwHaKG5EQhYqTQfIuCX--n4PBijZQ9iXiOpRIc,5748
 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
@@ -72,7 +72,7 @@ uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=opwfELnvuh3krnPAg0MupkHTEmhCpQ
 uipath/_cli/_evals/mocks/mocks.py,sha256=IrvhtTtIuU5geopvCRglNhxKoOcChnnjQZMoYygx0PU,2225
 uipath/_cli/_push/models.py,sha256=K3k6QUMkiNIb3M4U0EgDlKz1UELxeMXLNVAj3qyhZ4U,470
 uipath/_cli/_push/sw_file_handler.py,sha256=ivHj0qzCvEP45M3x-Oi2edO5I-uhyHzgnidDF3JRoTk,36192
-uipath/_cli/_runtime/_contracts.py,sha256=op8dyKTayWXKsKqVqGj_vGxwthLU8nLxqIx48-ol5Kg,36216
+uipath/_cli/_runtime/_contracts.py,sha256=NU7cZerrpxYTlP8-pamMBytCTMmvWy7vxPMlzFv8aBA,36231
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=JAwTUKvxO4HpnZMwE4E0AegAPw_uYOwgt0OYcu6EvTg,11474
 uipath/_cli/_runtime/_logging.py,sha256=srjAi3Cy6g7b8WNHiYNjaZT4t40F3XRqquuoGd2kh4Y,14019
@@ -108,7 +108,7 @@ uipath/_resources/AGENTS.md,sha256=nRQNAVeEBaBvuMzXw8uXtMnGebLClUgwIMlgb8_qU9o,1
 uipath/_resources/CLAUDE.md,sha256=kYsckFWTVe948z_fNWLysCHvi9_YpchBXl3s1Ek03lU,10
 uipath/_resources/CLI_REFERENCE.md,sha256=M_SCtSjRhj1XwfgSFLfHJJahYXEd_CSQ_EnjLQAn-2Y,6470
 uipath/_resources/REQUIRED_STRUCTURE.md,sha256=3laqGiNa3kauJ7jRI1d7w_fWKUDkqYBjcTT_6_8FAGk,1417
-uipath/_resources/SDK_REFERENCE.md,sha256=0Xbt87pVXzw0ZfpPO4EnVKlwGQRoshVb8zRt8F1jAFs,18211
+uipath/_resources/SDK_REFERENCE.md,sha256=xx6-FzXQpva0eeCeLgscrzaaWrVyFedxxACAD7xVlu4,18663
 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 +118,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=dVv7kYT2wm4gbtqulSAQhtn418xgzV2yt7gB7JvDsWU,24973
+uipath/_services/documents_service.py,sha256=2LZyGVYXtsC9ajsNpmLTmbgAXF13YeS4N_LObh4o4kA,31389
 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
@@ -204,7 +204,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=g3xAhZlGcLuD6a_DHcUQWoLdzh5dENulouYAwrjGHEw,3963
+uipath/models/documents.py,sha256=fLmo75okk1peDIiCmH3hmG8GbOte6fjkhwX8EaiOQJY,5124
 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 +224,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.111.dist-info/METADATA,sha256=VJa6HaV9Xw0fWJy4saCYS5viF9gUsYDItjo_5uXmais,6626
-uipath-2.1.111.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.111.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.111.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.111.dist-info/RECORD,,
+uipath-2.1.112.dist-info/METADATA,sha256=n-2HKHyHbL9qb7eTshpzMv_HAh1ZDEo754AeJ6MwXag,6626
+uipath-2.1.112.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.112.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.112.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.112.dist-info/RECORD,,