uipath 2.0.54__py3-none-any.whl → 2.0.56__py3-none-any.whl

uipath/_cli/_auth/_auth_server.py

@@ -2,7 +2,6 @@ import http.server
 import json
 import os
 import socketserver
-import ssl
 import time
 
 import click
@@ -109,19 +108,15 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
     return SimpleHTTPSRequestHandler
 
 
-class HTTPSServer:
-    def __init__(self, port=6234, cert_file="localhost.crt", key_file="localhost.key"):
-        """Initialize HTTPS server with configurable parameters.
+class HTTPServer:
+    def __init__(self, port=6234):
+        """Initialize HTTP server with configurable parameters.
 
         Args:
             port (int, optional): Port number to run the server on. Defaults to 6234.
-            cert_file (str, optional): SSL certificate file. Defaults to "localhost.crt".
-            key_file (str, optional): SSL key file. Defaults to "localhost.key".
         """
         self.current_path = os.path.dirname(os.path.abspath(__file__))
         self.port = port
-        self.cert_file = os.path.join(self.current_path, "localhost.crt")
-        self.key_file = os.path.join(self.current_path, "localhost.key")
         self.httpd = None
         self.token_data = None
         self.should_shutdown = False
@@ -136,7 +131,7 @@ class HTTPSServer:
         self.should_shutdown = True
 
     def create_server(self, state, code_verifier, domain):
-        """Create and configure the HTTPS server.
+        """Create and configure the HTTP server.
 
         Args:
             state (str): The OAuth state parameter.
@@ -144,20 +139,14 @@ class HTTPSServer:
             domain (str): The domain for authentication.
 
         Returns:
-            socketserver.TCPServer: The configured HTTPS server.
+            socketserver.TCPServer: The configured HTTP server.
         """
-        # Create SSL context
-        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        context.load_cert_chain(self.cert_file, self.key_file)
-
         # Create server with address reuse
         socketserver.TCPServer.allow_reuse_address = True
         handler = make_request_handler_class(
             state, code_verifier, self.token_received_callback, domain
         )
         self.httpd = socketserver.TCPServer(("", self.port), handler)
-        self.httpd.socket = context.wrap_socket(self.httpd.socket, server_side=True)
-
         return self.httpd
 
     def start(self, state, code_verifier, domain):

uipath/_cli/_auth/auth_config.json

@@ -1,6 +1,6 @@
 {
   "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
-  "redirect_uri": "https://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
   "scope": "offline_access OrchestratorApiUserAccess ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization",
   "port": 8104
-}
+}

uipath/_cli/_runtime/_logging.py

@@ -68,7 +68,7 @@ class LogsInterceptor:
         else:
             # Use stdout handler when not running as a job
             self.log_handler = logging.StreamHandler(sys.stdout)
-            formatter = logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s")
+            formatter = logging.Formatter("%(message)s")
             self.log_handler.setFormatter(formatter)
 
         self.log_handler.setLevel(self.numeric_min_level)

uipath/_cli/cli_auth.py

@@ -8,7 +8,7 @@ import click
 from dotenv import load_dotenv
 
 from ..telemetry import track
-from ._auth._auth_server import HTTPSServer
+from ._auth._auth_server import HTTPServer
 from ._auth._oidc_utils import get_auth_config, get_auth_url
 from ._auth._portal_service import PortalService, select_tenant
 from ._auth._utils import update_auth_file, update_env_file
@@ -97,7 +97,7 @@ def auth(domain, force: None | bool = False):
             auth_url,
         )
 
-        server = HTTPSServer(port=auth_config["port"])
+        server = HTTPServer(port=auth_config["port"])
         token_data = server.start(state, code_verifier, domain)
 
         if token_data:

uipath/_cli/cli_run.py

@@ -42,14 +42,14 @@ def python_run_middleware(
     if not entrypoint:
         return MiddlewareResult(
             should_continue=False,
-            info_message="""Error: No entrypoint specified. Please provide a path to a Python script.
+            error_message="""No entrypoint specified. Please provide a path to a Python script.
 Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
         )
 
     if not os.path.exists(entrypoint):
         return MiddlewareResult(
             should_continue=False,
-            error_message=f"""Error: Script not found at path {entrypoint}.
+            error_message=f"""Script not found at path {entrypoint}.
 Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
         )
 

uipath/_services/__init__.py

@@ -1,6 +1,7 @@
 from .actions_service import ActionsService
 from .api_client import ApiClient
 from .assets_service import AssetsService
+from .attachments_service import AttachmentsService
 from .buckets_service import BucketsService
 from .connections_service import ConnectionsService
 from .context_grounding_service import ContextGroundingService
@@ -13,6 +14,7 @@ from .queues_service import QueuesService
 __all__ = [
     "ActionsService",
     "AssetsService",
+    "AttachmentsService",
     "BucketsService",
     "ConnectionsService",
     "ContextGroundingService",

uipath/_services/attachments_service.py

@@ -0,0 +1,595 @@
+import uuid
+from typing import Any, Dict, Optional, Union, overload
+
+from httpx import request
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._utils import Endpoint, RequestSpec, header_folder
+from ..tracing._traced import traced
+from ._base_service import BaseService
+
+
+def _upload_attachment_input_processor(inputs: Dict[str, Any]) -> Dict[str, Any]:
+    """Process attachment upload inputs to avoid logging large content."""
+    processed_inputs = inputs.copy()
+    if "source_path" in processed_inputs:
+        processed_inputs["source_path"] = f"<File at {processed_inputs['source_path']}>"
+    if "content" in processed_inputs:
+        if isinstance(processed_inputs["content"], str):
+            processed_inputs["content"] = "<Redacted String Content>"
+        else:
+            processed_inputs["content"] = "<Redacted Binary Content>"
+    return processed_inputs
+
+
+class AttachmentsService(FolderContext, BaseService):
+    """Service for managing UiPath attachments.
+
+    Attachments allow you to upload and download files to be used within UiPath
+    processes, actions, and other UiPath services.
+
+    Reference: https://docs.uipath.com/orchestrator/reference/api-attachments
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="attachments_download", run_type="uipath")
+    def download(
+        self,
+        *,
+        key: uuid.UUID,
+        destination_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> str:
+        """Download an attachment.
+
+        This method downloads an attachment from UiPath to a local file.
+
+        Args:
+            key (uuid.UUID): The key of the attachment to download.
+            destination_path (str): The local path where the attachment will be saved.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            str: The name of the downloaded attachment.
+
+        Raises:
+            Exception: If the download fails.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            attachment_name = client.attachments.download(
+                key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000"),
+                destination_path="path/to/save/document.pdf"
+            )
+            print(f"Downloaded attachment: {attachment_name}")
+            ```
+        """
+        spec = self._retrieve_download_uri_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        # Get the attachment name
+        attachment_name = result["Name"]
+
+        download_uri = result["BlobFileAccess"]["Uri"]
+        headers = {
+            key: value
+            for key, value in zip(
+                result["BlobFileAccess"]["Headers"]["Keys"],
+                result["BlobFileAccess"]["Headers"]["Values"],
+                strict=False,
+            )
+        }
+
+        with open(destination_path, "wb") as file:
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                file_content = self.request(
+                    "GET", download_uri, headers=headers
+                ).content
+            else:
+                file_content = request("GET", download_uri, headers=headers).content
+            file.write(file_content)
+
+        return attachment_name
+
+    @traced(name="attachments_download", run_type="uipath")
+    async def download_async(
+        self,
+        *,
+        key: uuid.UUID,
+        destination_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> str:
+        """Download an attachment asynchronously.
+
+        This method asynchronously downloads an attachment from UiPath to a local file.
+
+        Args:
+            key (uuid.UUID): The key of the attachment to download.
+            destination_path (str): The local path where the attachment will be saved.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            str: The name of the downloaded attachment.
+
+        Raises:
+            Exception: If the download fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            client = UiPath()
+
+            async def main():
+                attachment_name = await client.attachments.download_async(
+                    key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000"),
+                    destination_path="path/to/save/document.pdf"
+                )
+                print(f"Downloaded attachment: {attachment_name}")
+            ```
+        """
+        spec = self._retrieve_download_uri_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        # Get the attachment name
+        attachment_name = result["Name"]
+
+        download_uri = result["BlobFileAccess"]["Uri"]
+        headers = {
+            key: value
+            for key, value in zip(
+                result["BlobFileAccess"]["Headers"]["Keys"],
+                result["BlobFileAccess"]["Headers"]["Values"],
+                strict=False,
+            )
+        }
+
+        with open(destination_path, "wb") as file:
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                response = await self.request_async(
+                    "GET", download_uri, headers=headers
+                )
+                file.write(response.content)
+            else:
+                file.write(request("GET", download_uri, headers=headers).content)
+
+        return attachment_name
+
+    @overload
+    def upload(
+        self,
+        *,
+        name: str,
+        content: Union[str, bytes],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID: ...
+
+    @overload
+    def upload(
+        self,
+        *,
+        name: str,
+        source_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID: ...
+
+    @traced(
+        name="attachments_upload",
+        run_type="uipath",
+        input_processor=_upload_attachment_input_processor,
+    )
+    def upload(
+        self,
+        *,
+        name: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID:
+        """Upload a file or content to UiPath as an attachment.
+
+        This method uploads content to UiPath and makes it available as an attachment.
+        You can either provide a file path or content in memory.
+
+        Args:
+            name (str): The name of the attachment file.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            source_path (Optional[str]): The local path of the file to upload.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            uuid.UUID: The UUID of the created attachment.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+            Exception: If the upload fails.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            # Upload a file from disk
+            attachment_key = client.attachments.upload(
+                name="my-document.pdf",
+                source_path="path/to/local/document.pdf",
+            )
+            print(f"Uploaded attachment with key: {attachment_key}")
+
+            # Upload content from memory
+            attachment_key = client.attachments.upload(
+                name="notes.txt",
+                content="This is a text file content",
+            )
+            print(f"Uploaded attachment with key: {attachment_key}")
+            ```
+        """
+        # Validate input parameters
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        spec = self._create_attachment_and_retrieve_upload_uri_spec(
+            name=name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            json=spec.json,
+        ).json()
+
+        # Get the ID from the response and convert to UUID
+        attachment_key = uuid.UUID(result["Id"])
+
+        upload_uri = result["BlobFileAccess"]["Uri"]
+        headers = {
+            key: value
+            for key, value in zip(
+                result["BlobFileAccess"]["Headers"]["Keys"],
+                result["BlobFileAccess"]["Headers"]["Values"],
+                strict=False,
+            )
+        }
+
+        if source_path:
+            # Upload from file
+            with open(source_path, "rb") as file:
+                if result["BlobFileAccess"]["RequiresAuth"]:
+                    self.request(
+                        "PUT", upload_uri, headers=headers, files={"file": file}
+                    )
+                else:
+                    request("PUT", upload_uri, headers=headers, files={"file": file})
+        else:
+            # Upload from memory
+            # Convert string to bytes if needed
+            if isinstance(content, str):
+                content = content.encode("utf-8")
+
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                self.request("PUT", upload_uri, headers=headers, content=content)
+            else:
+                request("PUT", upload_uri, headers=headers, content=content)
+
+        return attachment_key
+
+    @overload
+    async def upload_async(
+        self,
+        *,
+        name: str,
+        content: Union[str, bytes],
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID: ...
+
+    @overload
+    async def upload_async(
+        self,
+        *,
+        name: str,
+        source_path: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID: ...
+
+    @traced(
+        name="attachments_upload",
+        run_type="uipath",
+        input_processor=_upload_attachment_input_processor,
+    )
+    async def upload_async(
+        self,
+        *,
+        name: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID:
+        """Upload a file or content to UiPath as an attachment asynchronously.
+
+        This method asynchronously uploads content to UiPath and makes it available as an attachment.
+        You can either provide a file path or content in memory.
+
+        Args:
+            name (str): The name of the attachment file.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            source_path (Optional[str]): The local path of the file to upload.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            uuid.UUID: The UUID of the created attachment.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+            Exception: If the upload fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            client = UiPath()
+
+            async def main():
+                # Upload a file from disk
+                attachment_key = await client.attachments.upload_async(
+                    name="my-document.pdf",
+                    source_path="path/to/local/document.pdf",
+                )
+                print(f"Uploaded attachment with key: {attachment_key}")
+
+                # Upload content from memory
+                attachment_key = await client.attachments.upload_async(
+                    name="notes.txt",
+                    content="This is a text file content",
+                )
+                print(f"Uploaded attachment with key: {attachment_key}")
+            ```
+        """
+        # Validate input parameters
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        spec = self._create_attachment_and_retrieve_upload_uri_spec(
+            name=name,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        result = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+                json=spec.json,
+            )
+        ).json()
+
+        # Get the ID from the response and convert to UUID
+        attachment_key = uuid.UUID(result["Id"])
+
+        upload_uri = result["BlobFileAccess"]["Uri"]
+        headers = {
+            key: value
+            for key, value in zip(
+                result["BlobFileAccess"]["Headers"]["Keys"],
+                result["BlobFileAccess"]["Headers"]["Values"],
+                strict=False,
+            )
+        }
+
+        if source_path:
+            # Upload from file
+            with open(source_path, "rb") as file:
+                if result["BlobFileAccess"]["RequiresAuth"]:
+                    await self.request_async(
+                        "PUT", upload_uri, headers=headers, files={"file": file}
+                    )
+                else:
+                    request("PUT", upload_uri, headers=headers, files={"file": file})
+        else:
+            # Upload from memory
+            # Convert string to bytes if needed
+            if isinstance(content, str):
+                content = content.encode("utf-8")
+
+            if result["BlobFileAccess"]["RequiresAuth"]:
+                await self.request_async(
+                    "PUT", upload_uri, headers=headers, content=content
+                )
+            else:
+                request("PUT", upload_uri, headers=headers, content=content)
+
+        return attachment_key
+
+    @traced(name="attachments_delete", run_type="uipath")
+    def delete(
+        self,
+        *,
+        key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete an attachment.
+
+        This method deletes an attachment from UiPath.
+
+        Args:
+            key (uuid.UUID): The key of the attachment to delete.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Raises:
+            Exception: If the deletion fails.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            client.attachments.delete(
+                key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+            )
+            print("Attachment deleted successfully")
+            ```
+        """
+        spec = self._delete_attachment_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+    @traced(name="attachments_delete", run_type="uipath")
+    async def delete_async(
+        self,
+        *,
+        key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Delete an attachment asynchronously.
+
+        This method asynchronously deletes an attachment from UiPath.
+
+        Args:
+            key (uuid.UUID): The key of the attachment to delete.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Raises:
+            Exception: If the deletion fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            client = UiPath()
+
+            async def main():
+                await client.attachments.delete_async(
+                    key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+                )
+                print("Attachment deleted successfully")
+            ```
+        """
+        spec = self._delete_attachment_spec(
+            key=key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        """Return custom headers for API requests."""
+        return self.folder_headers
+
+    def _create_attachment_and_retrieve_upload_uri_spec(
+        self,
+        name: str,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/orchestrator_/odata/Attachments"),
+            json={
+                "Name": name,
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _retrieve_download_uri_spec(
+        self,
+        key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/orchestrator_/odata/Attachments({key})"),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _delete_attachment_spec(
+        self,
+        key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="DELETE",
+            endpoint=Endpoint(f"/orchestrator_/odata/Attachments({key})"),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )

uipath/_services/jobs_service.py

@@ -1,10 +1,12 @@
 import json
-from typing import Any, Dict, Optional, overload
+import uuid
+from typing import Any, Dict, List, Optional, overload
 
 from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder
+from ..models import Attachment
 from ..models.job import Job
 from ..tracing._traced import traced
 from ._base_service import BaseService
@@ -265,3 +267,255 @@ class JobsService(FolderContext, BaseService):
                 f"/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier={job_key})"
             ),
         )
+
+    @traced(name="jobs_list_attachments", run_type="uipath")
+    def list_attachments(
+        self,
+        *,
+        job_key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[Attachment]:
+        """List attachments associated with a specific job.
+
+        This method retrieves all attachments linked to a job by its key.
+
+        Args:
+            job_key (uuid.UUID): The key of the job to retrieve attachments for.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            List[Attachment]: A list of attachment objects associated with the job.
+
+        Raises:
+            Exception: If the retrieval fails.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            attachments = client.jobs.list_attachments(
+                job_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+            )
+            for attachment in attachments:
+                print(f"Attachment: {attachment.Name}, Key: {attachment.Key}")
+            ```
+        """
+        spec = self._list_job_attachments_spec(
+            job_key=job_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+        ).json()
+
+        return [Attachment.model_validate(item) for item in response]
+
+    @traced(name="jobs_list_attachments", run_type="uipath")
+    async def list_attachments_async(
+        self,
+        *,
+        job_key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> List[Attachment]:
+        """List attachments associated with a specific job asynchronously.
+
+        This method asynchronously retrieves all attachments linked to a job by its key.
+
+        Args:
+            job_key (uuid.UUID): The key of the job to retrieve attachments for.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Returns:
+            List[Attachment]: A list of attachment objects associated with the job.
+
+        Raises:
+            Exception: If the retrieval fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            client = UiPath()
+
+            async def main():
+                attachments = await client.jobs.list_attachments_async(
+                    job_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000")
+                )
+                for attachment in attachments:
+                    print(f"Attachment: {attachment.Name}, Key: {attachment.Key}")
+            ```
+        """
+        spec = self._list_job_attachments_spec(
+            job_key=job_key,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = (
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+                headers=spec.headers,
+            )
+        ).json()
+
+        return [Attachment.model_validate(item) for item in response]
+
+    @traced(name="jobs_link_attachment", run_type="uipath")
+    def link_attachment(
+        self,
+        *,
+        attachment_key: uuid.UUID,
+        job_key: uuid.UUID,
+        category: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ):
+        """Link an attachment to a job.
+
+        This method links an existing attachment to a specific job.
+
+        Args:
+            attachment_key (uuid.UUID): The key of the attachment to link.
+            job_key (uuid.UUID): The key of the job to link the attachment to.
+            category (Optional[str]): Optional category for the attachment in the context of this job.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Raises:
+            Exception: If the link operation fails.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            client.jobs.link_attachment(
+                attachment_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000"),
+                job_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174001"),
+                category="Result"
+            )
+            print("Attachment linked to job successfully")
+            ```
+        """
+        spec = self._link_job_attachment_spec(
+            attachment_key=attachment_key,
+            job_key=job_key,
+            category=category,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        return self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            json=spec.json,
+        )
+
+    @traced(name="jobs_link_attachment", run_type="uipath")
+    async def link_attachment_async(
+        self,
+        *,
+        attachment_key: uuid.UUID,
+        job_key: uuid.UUID,
+        category: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ):
+        """Link an attachment to a job asynchronously.
+
+        This method asynchronously links an existing attachment to a specific job.
+
+        Args:
+            attachment_key (uuid.UUID): The key of the attachment to link.
+            job_key (uuid.UUID): The key of the job to link the attachment to.
+            category (Optional[str]): Optional category for the attachment in the context of this job.
+            folder_key (Optional[str]): The key of the folder. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
+
+        Raises:
+            Exception: If the link operation fails.
+
+        Examples:
+            ```python
+            import asyncio
+            from uipath import UiPath
+
+            client = UiPath()
+
+            async def main():
+                await client.jobs.link_attachment_async(
+                    attachment_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174000"),
+                    job_key=uuid.UUID("123e4567-e89b-12d3-a456-426614174001"),
+                    category="Result"
+                )
+                print("Attachment linked to job successfully")
+            ```
+        """
+        spec = self._link_job_attachment_spec(
+            attachment_key=attachment_key,
+            job_key=job_key,
+            category=category,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        return await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+            json=spec.json,
+        )
+
+    def _list_job_attachments_spec(
+        self,
+        job_key: uuid.UUID,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/api/JobAttachments/GetByJobKey"),
+            params={
+                "jobKey": job_key,
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _link_job_attachment_spec(
+        self,
+        attachment_key: uuid.UUID,
+        job_key: uuid.UUID,
+        category: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint("/orchestrator_/api/JobAttachments/Post"),
+            json={
+                "attachmentId": str(attachment_key),
+                "jobKey": str(job_key),
+                "category": category,
+            },
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )

uipath/_uipath.py

@@ -10,6 +10,7 @@ from ._services import (
     ActionsService,
     ApiClient,
     AssetsService,
+    AttachmentsService,
     BucketsService,
     ConnectionsService,
     ContextGroundingService,
@@ -69,6 +70,10 @@ class UiPath:
     def assets(self) -> AssetsService:
         return AssetsService(self._config, self._execution_context)
 
+    @property
+    def attachments(self) -> AttachmentsService:
+        return AttachmentsService(self._config, self._execution_context)
+
     @property
     def processes(self) -> ProcessesService:
         return ProcessesService(self._config, self._execution_context)

uipath/_utils/_url.py

@@ -80,6 +80,23 @@ class UiPathUrl:
         return org_name, tenant_name
 
     def _is_relative_url(self, url: str) -> bool:
+        # Empty URLs are considered relative
+        if not url:
+            return True
+
         parsed = urlparse(url)
 
-        return parsed.hostname is None and parsed.path == url
+        # Protocol-relative URLs (starting with //) are not relative
+        if url.startswith("//"):
+            return False
+
+        # URLs with schemes are not relative (http:, https:, mailto:, etc.)
+        if parsed.scheme:
+            return False
+
+        # URLs with network locations are not relative
+        if parsed.netloc:
+            return False
+
+        # If we've passed all the checks, it's a relative URL
+        return True

uipath/models/__init__.py

@@ -1,6 +1,7 @@
 from .action_schema import ActionSchema
 from .actions import Action
 from .assets import Asset, UserAsset
+from .attachment import Attachment
 from .buckets import Bucket
 from .connections import Connection, ConnectionToken
 from .context_grounding import ContextGroundingQueryResponse
@@ -26,6 +27,7 @@ from .queues import (
 __all__ = [
     "Action",
     "Asset",
+    "Attachment",
     "UserAsset",
     "ContextGroundingQueryResponse",
     "ContextGroundingIndex",

uipath/models/attachment.py

@@ -0,0 +1,28 @@
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Attachment(BaseModel):
+    """Model representing an attachment in UiPath.
+
+    Attachments can be associated with jobs in UiPath and contain binary files or documents.
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    name: str = Field(alias="Name")
+    creation_time: Optional[datetime] = Field(default=None, alias="CreationTime")
+    last_modification_time: Optional[datetime] = Field(
+        default=None, alias="LastModificationTime"
+    )
+    key: uuid.UUID = Field(alias="Key")

{uipath-2.0.54.dist-info → uipath-2.0.56.dist-info}/METADATA

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

@@ -2,31 +2,31 @@ uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
 uipath/_config.py,sha256=pi3qxPzDTxMEstj_XkGOgKJqD6RTHHv7vYv8sS_-d5Q,92
 uipath/_execution_context.py,sha256=XyfEcdPN-PmM97yO7OVS8Do28N-vpTnQPJrkp8pEpRA,2434
 uipath/_folder_context.py,sha256=UMMoU1VWEfYHAZW3Td2SIFYhw5dYsmaaKFhW_JEm6oc,1921
-uipath/_uipath.py,sha256=mx2L_e7gBm1UI-Q3HQ-GKV55KK4eGi8w3EPpUG2ZWVM,3663
+uipath/_uipath.py,sha256=54u-aPF29DE3fOn8yM1pjVTqSZxSSaIsifiZG9Mt_YM,3824
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=vGz3vJHkUvgK9_lKdzqiwwHkge1TCALRiOzGGwyr-8E,1885
-uipath/_cli/cli_auth.py,sha256=mIavWQ2zG3hWbjDxTVyGlHKq165liaI2Texbb1kHsTE,3968
+uipath/_cli/cli_auth.py,sha256=aIecyySuGXJEQHnS6b-M6sxM7ki5trjqq_J7s-sCdQE,3966
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_init.py,sha256=6qIjGFwfmeDs_7yzDqfl4zdnpDzlIjPAth0dY7kAP04,3736
 uipath/_cli/cli_invoke.py,sha256=IjndcDWBpvAqGCRanQU1vfmxaBF8FhyZ7gWuZqwjHrU,3812
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
 uipath/_cli/cli_pack.py,sha256=8Ahk0vr_8eqMsq9ehhYWNfeII0VIiZVBXMpRF7Dbvtg,15018
 uipath/_cli/cli_publish.py,sha256=Ba0TJ1TSfuQbLU2AIgtM8QWkLHgr4tsAP1CaX12113U,6010
-uipath/_cli/cli_run.py,sha256=XS8IsfnS9d9zxl7rjUWVFsRWjuQTtO48H1EYFR_5CMc,5228
+uipath/_cli/cli_run.py,sha256=0q_DqM2QNfD8yOqUZB_5BTg96pCLzbHE1enD_XAj6CE,5215
 uipath/_cli/middlewares.py,sha256=IiJgjsqrJVKSXx4RcIKHWoH-SqWqpHPbhzkQEybmAos,3937
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
-uipath/_cli/_auth/_auth_server.py,sha256=W0KabhR-RB_uUqGX2dyNM0Juvrh-TABW3A-1cEom3uM,7047
+uipath/_cli/_auth/_auth_server.py,sha256=p93_EvJpdoLLkiVmLygHRKo9ru1-PZOEAaEhNFN3j6c,6424
 uipath/_cli/_auth/_models.py,sha256=sYMCfvmprIqnZxStlD_Dxx2bcxgn0Ri4D7uwemwkcNg,948
 uipath/_cli/_auth/_oidc_utils.py,sha256=WaX9jDlXrlX6yD8i8gsocV8ngjaT72Xd1tvsZMmSbco,2127
 uipath/_cli/_auth/_portal_service.py,sha256=80W0cn3rx6NEi_b15aSQ0ZQWFv7Om7SaOlkUUk2k7pA,7240
 uipath/_cli/_auth/_utils.py,sha256=9nb76xe5XmDZ0TAncp-_1SKqL6FdwRi9eS3C2noN1lY,1591
-uipath/_cli/_auth/auth_config.json,sha256=NTb_ZZor5xEgya2QbK51GiTL5_yVqG_QpV4VYIp8_mk,342
+uipath/_cli/_auth/auth_config.json,sha256=OCNp3tTF2WL83pyJlZw-Wt8Slao9IpmmZJonl2OvaRw,340
 uipath/_cli/_auth/index.html,sha256=ML_xDOcKs0ETYucufJskiYfWSvdrD_E26C0Qd3qpGj8,6280
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
 uipath/_cli/_runtime/_contracts.py,sha256=Rxs-uEOA490fLPNimB8LqZW7KI-72O0BLY4Jm7Fa1ms,14316
-uipath/_cli/_runtime/_logging.py,sha256=rmRBEHNMRK422o_TYk7h2sNfeGfaZdXC6-83VcO5o10,7903
+uipath/_cli/_runtime/_logging.py,sha256=lA2LsakOrcSLnJWgo80-BYzIQBUWfqzzJGI1M61Gu0s,7874
 uipath/_cli/_runtime/_runtime.py,sha256=K8lQjeUE-qXNshmt0UE2SNdbH-MA9goOSqsReJ-_NF4,9681
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
 uipath/_cli/_templates/.rels.template,sha256=-fTcw7OA1AcymHr0LzBqbMAAtzZTRXLTNa_ljq087Jk,406
@@ -39,16 +39,17 @@ uipath/_cli/_utils/_folders.py,sha256=usjLNOMdhvelEv0wsJ-v6q-qiUR1tbwXJL4Sd_SOoc
 uipath/_cli/_utils/_input_args.py,sha256=pyQhEcQXHdFHYTVNzvfWp439aii5StojoptnmCv5lfs,4094
 uipath/_cli/_utils/_parse_ast.py,sha256=3XVjnhJNnSfjXlitct91VOtqSl0l-sqDpoWww28mMc0,20663
 uipath/_cli/_utils/_processes.py,sha256=iCGNf1y_K_r3bdmX9VWA70UP20bdUzKlMRrAxkdkdm4,1669
-uipath/_services/__init__.py,sha256=VPbwLDsvN26nWZgvR-8_-tc3i0rk5doqjTJbSrK0nN4,818
+uipath/_services/__init__.py,sha256=10xtw3ENC30yR9CCq_b94RMZ3YrUeyfHV33yWYUd8tU,896
 uipath/_services/_base_service.py,sha256=y-QATIRF9JnUFKIwmjOWMHlE2BrJYgD8y4sGAve2kEM,5338
 uipath/_services/actions_service.py,sha256=LYKvG4VxNGQgZ46AzGK9kI1Txb-YmVvZj5ScPOue8Ls,15989
 uipath/_services/api_client.py,sha256=hcof0EMa4-phEHD1WlO7Tdfzq6aL18Sbi2aBE7lJm1w,1821
 uipath/_services/assets_service.py,sha256=gfQLCchT6evsmhip1-coX6oFbshoKUWlxwGrS6DGcHU,13200
+uipath/_services/attachments_service.py,sha256=8iRdauPFzhJv65Uus69BBmA3jPckqfwBE4iGbXvktCQ,19653
 uipath/_services/buckets_service.py,sha256=xTIAEs7EbpyZYqd7PG1q0emOOBM_Ca0rVoH417g2bl0,17521
 uipath/_services/connections_service.py,sha256=qh-HNL_GJsyPUD0wSJZRF8ZdrTE9l4HrIilmXGK6dDk,4581
 uipath/_services/context_grounding_service.py,sha256=wRYPnpTFeZunS88OggRZ9qRaILHKdoEP_6VUCaF-Xw0,24097
 uipath/_services/folder_service.py,sha256=HtsBoBejvMuIZ-9gocAG9B8uKOFsAAD4WUozta-isXk,1673
-uipath/_services/jobs_service.py,sha256=_i3op3Xo3mdQdma7AbGQI35NVwj85B4idAHFZ12C_oI,8215
+uipath/_services/jobs_service.py,sha256=Z1CmglIe6pFt0XovPLbuLCp13mWQw92MgjfRivqsodE,16745
 uipath/_services/llm_gateway_service.py,sha256=ySg3sflIoXmY9K7txlSm7bkuI2qzBT0kAKmGlFBk5KA,12032
 uipath/_services/processes_service.py,sha256=12tflrzTNvtA0xGteQwrIZ0s-jCTinTv7gktder5tRE,5659
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
@@ -59,13 +60,14 @@ uipath/_utils/_logs.py,sha256=adfX_0UAn3YBeKJ8DQDeZs94rJyHGQO00uDfkaTpNWQ,510
 uipath/_utils/_read_overwrites.py,sha256=dODvjNnDjcYOxVKnt0KqqqXmysULLBObKaEF8gJteg4,5149
 uipath/_utils/_request_override.py,sha256=fIVHzgHVXITUlWcp8osNBwIafM1qm4_ejx0ng5UzfJ4,573
 uipath/_utils/_request_spec.py,sha256=iCtBLqtbWUpFG5g1wtIZBzSupKsfaRLiQFoFc_4B70Q,747
-uipath/_utils/_url.py,sha256=2PnINXuEPbhd9mlojJJdupm-sOrgV29o5DbWuaFrc-0,2039
+uipath/_utils/_url.py,sha256=-4eluSrIZCUlnQ3qU17WPJkgaC2KwF9W5NeqGnTNGGo,2512
 uipath/_utils/_user_agent.py,sha256=pVJkFYacGwaQBomfwWVAvBQgdBUo62e4n3-fLIajWUU,563
 uipath/_utils/constants.py,sha256=CKv-kTC8Fzu6E_KY9jD_fSt0Gbycn9sZg4O_3pzq2fo,873
-uipath/models/__init__.py,sha256=4851NXFml-lNumkjiiauGLlCb-yFViG2HX-NVh8Nt8Y,1198
+uipath/models/__init__.py,sha256=Kwqv1LzWNfSxJLMQrInVen3KDJ1z0eCcr6szQa0G0VE,1251
 uipath/models/action_schema.py,sha256=lKDhP7Eix23fFvfQrqqNmSOiPyyNF6tiRpUu0VZIn_M,714
 uipath/models/actions.py,sha256=ekSH4YUQR4KPOH-heBm9yOgOfirndx0In4_S4VYWeEU,2993
 uipath/models/assets.py,sha256=Q-7_xmm503XHTKgCDrDtXsFl3VWBSVSyiWYW0mZjsnA,2942
+uipath/models/attachment.py,sha256=prBlhhTvaBnLXJ3PKKxxHWbus35dCuag3_5HngksUjU,843
 uipath/models/buckets.py,sha256=N3Lj_dVCv709-ywhOOdyCSvsuLn41eGuAfSiik6Q6F8,1285
 uipath/models/connections.py,sha256=perIqW99YEg_0yWZPdpZlmNpZcwY_toR1wkqDUBdAN0,2014
 uipath/models/context_grounding.py,sha256=S9PeOlFlw7VxzzJVR_Fs28OObW3MLHUPCFqNgkEz24k,1315
@@ -84,8 +86,8 @@ uipath/tracing/__init__.py,sha256=GimSzv6qkCOlHOG1WtjYKJsZqcXpA28IgoXfR33JhiA,13
 uipath/tracing/_otel_exporters.py,sha256=x0PDPmDKJcxashsuehVsSsqBCzRr6WsNFaq_3_HS5F0,3014
 uipath/tracing/_traced.py,sha256=GFxOp73jk0vGTN_H7YZOOsEl9rVLaEhXGztMiYKIA-8,16634
 uipath/tracing/_utils.py,sha256=5SwsTGpHkIouXBndw-u8eCLnN4p7LM8DsTCCuf2jJgs,10165
-uipath-2.0.54.dist-info/METADATA,sha256=cEs9a2B8OKtGc7iE2247tX1ihUFr8Z8BwdmA05Q5UU8,6304
-uipath-2.0.54.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.54.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.54.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.54.dist-info/RECORD,,
+uipath-2.0.56.dist-info/METADATA,sha256=-6oLullDWbwXLA9RDKohTdX3H6qupXwdkyl8hK6940o,6304
+uipath-2.0.56.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.56.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.56.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.56.dist-info/RECORD,,