uipath 2.0.57__py3-none-any.whl → 2.0.58__py3-none-any.whl

uipath/_services/attachments_service.py

@@ -1,12 +1,17 @@
+import os
+import shutil
+import tempfile
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional, Union, overload
 
-from httpx import request
+import httpx
 
 from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder
+from .._utils.constants import TEMP_ATTACHMENTS_FOLDER
 from ..tracing._traced import traced
 from ._base_service import BaseService
 
@@ -35,6 +40,7 @@ class AttachmentsService(FolderContext, BaseService):
 
     def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
         super().__init__(config=config, execution_context=execution_context)
+        self._temp_dir = os.path.join(tempfile.gettempdir(), TEMP_ATTACHMENTS_FOLDER)
 
     @traced(name="attachments_download", run_type="uipath")
     def download(
@@ -48,6 +54,12 @@ class AttachmentsService(FolderContext, BaseService):
         """Download an attachment.
 
         This method downloads an attachment from UiPath to a local file.
+        If the attachment is not found in UiPath (404 error), it will check
+        for a local file in the temporary directory that matches the UUID.
+
+        Note:
+            The local file fallback functionality is intended for local development
+            and debugging purposes only.
 
         Args:
             key (uuid.UUID): The key of the attachment to download.
@@ -59,7 +71,7 @@ class AttachmentsService(FolderContext, BaseService):
             str: The name of the downloaded attachment.
 
         Raises:
-            Exception: If the download fails.
+            Exception: If the download fails and no local file is found.
 
         Examples:
             ```python
@@ -74,42 +86,75 @@ class AttachmentsService(FolderContext, BaseService):
             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,
+        try:
+            spec = self._retrieve_download_uri_spec(
+                key=key,
+                folder_key=folder_key,
+                folder_path=folder_path,
             )
-        }
 
-        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)
+            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,
+                )
+            }
 
-        return attachment_name
+            with open(destination_path, "wb") as file:
+                if result["BlobFileAccess"]["RequiresAuth"]:
+                    response = self.request(
+                        "GET", download_uri, headers=headers, stream=True
+                    )
+                    for chunk in response.iter_bytes(chunk_size=8192):
+                        file.write(chunk)
+                else:
+                    with httpx.Client() as client:
+                        with client.stream(
+                            "GET", download_uri, headers=headers
+                        ) as response:
+                            for chunk in response.iter_bytes(chunk_size=8192):
+                                file.write(chunk)
+
+            return attachment_name
+        except Exception as e:
+            # If not found in UiPath, check local storage
+            if "404" in str(e):
+                # Check if file exists in temp directory
+                if os.path.exists(self._temp_dir):
+                    # Look for any file starting with our UUID
+                    pattern = f"{key}_*"
+                    matching_files = list(Path(self._temp_dir).glob(pattern))
+
+                    if matching_files:
+                        # Get the full filename
+                        local_file = matching_files[0]
+
+                        # Extract the original name from the filename (part after UUID_)
+                        file_name = os.path.basename(local_file)
+                        original_name = file_name[len(f"{key}_") :]
+
+                        # Copy the file to the destination
+                        shutil.copy2(local_file, destination_path)
+
+                        return original_name
+
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(
+                f"Attachment with key {key} not found in UiPath or local storage"
+            ) from e
 
     @traced(name="attachments_download", run_type="uipath")
     async def download_async(
@@ -123,6 +168,12 @@ class AttachmentsService(FolderContext, BaseService):
         """Download an attachment asynchronously.
 
         This method asynchronously downloads an attachment from UiPath to a local file.
+        If the attachment is not found in UiPath (404 error), it will check
+        for a local file in the temporary directory that matches the UUID.
+
+        Note:
+            The local file fallback functionality is intended for local development
+            and debugging purposes only.
 
         Args:
             key (uuid.UUID): The key of the attachment to download.
@@ -134,7 +185,7 @@ class AttachmentsService(FolderContext, BaseService):
             str: The name of the downloaded attachment.
 
         Raises:
-            Exception: If the download fails.
+            Exception: If the download fails and no local file is found.
 
         Examples:
             ```python
@@ -151,44 +202,77 @@ class AttachmentsService(FolderContext, BaseService):
                 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,
+        try:
+            spec = self._retrieve_download_uri_spec(
+                key=key,
+                folder_key=folder_key,
+                folder_path=folder_path,
             )
-        }
 
-        with open(destination_path, "wb") as file:
-            if result["BlobFileAccess"]["RequiresAuth"]:
-                response = await self.request_async(
-                    "GET", download_uri, headers=headers
+            result = (
+                await self.request_async(
+                    spec.method,
+                    url=spec.endpoint,
+                    params=spec.params,
+                    headers=spec.headers,
                 )
-                file.write(response.content)
-            else:
-                file.write(request("GET", download_uri, headers=headers).content)
+            ).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,
+                )
+            }
 
-        return attachment_name
+            with open(destination_path, "wb") as file:
+                if result["BlobFileAccess"]["RequiresAuth"]:
+                    response = await self.request_async(
+                        "GET", download_uri, headers=headers, stream=True
+                    )
+                    async for chunk in response.aiter_bytes(chunk_size=8192):
+                        file.write(chunk)
+                else:
+                    async with httpx.AsyncClient() as client:
+                        async with client.stream(
+                            "GET", download_uri, headers=headers
+                        ) as response:
+                            async for chunk in response.aiter_bytes(chunk_size=8192):
+                                file.write(chunk)
+
+            return attachment_name
+        except Exception as e:
+            # If not found in UiPath, check local storage
+            if "404" in str(e):
+                # Check if file exists in temp directory
+                if os.path.exists(self._temp_dir):
+                    # Look for any file starting with our UUID
+                    pattern = f"{key}_*"
+                    matching_files = list(Path(self._temp_dir).glob(pattern))
+
+                    if matching_files:
+                        # Get the full filename
+                        local_file = matching_files[0]
+
+                        # Extract the original name from the filename (part after UUID_)
+                        file_name = os.path.basename(local_file)
+                        original_name = file_name[len(f"{key}_") :]
+
+                        # Copy the file to the destination
+                        shutil.copy2(local_file, destination_path)
+
+                        return original_name
+
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(
+                f"Attachment with key {key} not found in UiPath or local storage"
+            ) from e
 
     @overload
     def upload(
@@ -305,7 +389,8 @@ class AttachmentsService(FolderContext, BaseService):
                         "PUT", upload_uri, headers=headers, files={"file": file}
                     )
                 else:
-                    request("PUT", upload_uri, headers=headers, files={"file": file})
+                    with httpx.Client() as client:
+                        client.put(upload_uri, headers=headers, files={"file": file})
         else:
             # Upload from memory
             # Convert string to bytes if needed
@@ -315,7 +400,8 @@ class AttachmentsService(FolderContext, BaseService):
             if result["BlobFileAccess"]["RequiresAuth"]:
                 self.request("PUT", upload_uri, headers=headers, content=content)
             else:
-                request("PUT", upload_uri, headers=headers, content=content)
+                with httpx.Client() as client:
+                    client.put(upload_uri, headers=headers, content=content)
 
         return attachment_key
 
@@ -438,7 +524,8 @@ class AttachmentsService(FolderContext, BaseService):
                         "PUT", upload_uri, headers=headers, files={"file": file}
                     )
                 else:
-                    request("PUT", upload_uri, headers=headers, files={"file": file})
+                    with httpx.Client() as client:
+                        client.put(upload_uri, headers=headers, files={"file": file})
         else:
             # Upload from memory
             # Convert string to bytes if needed
@@ -450,7 +537,8 @@ class AttachmentsService(FolderContext, BaseService):
                     "PUT", upload_uri, headers=headers, content=content
                 )
             else:
-                request("PUT", upload_uri, headers=headers, content=content)
+                with httpx.Client() as client:
+                    client.put(upload_uri, headers=headers, content=content)
 
         return attachment_key
 
@@ -465,6 +553,12 @@ class AttachmentsService(FolderContext, BaseService):
         """Delete an attachment.
 
         This method deletes an attachment from UiPath.
+        If the attachment is not found in UiPath (404 error), it will check
+        for a local file in the temporary directory that matches the UUID.
+
+        Note:
+            The local file fallback functionality is intended for local development
+            and debugging purposes only.
 
         Args:
             key (uuid.UUID): The key of the attachment to delete.
@@ -472,7 +566,7 @@ class AttachmentsService(FolderContext, BaseService):
             folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
 
         Raises:
-            Exception: If the deletion fails.
+            Exception: If the deletion fails and no local file is found.
 
         Examples:
             ```python
@@ -486,17 +580,37 @@ class AttachmentsService(FolderContext, BaseService):
             print("Attachment deleted successfully")
             ```
         """
-        spec = self._delete_attachment_spec(
-            key=key,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
+        try:
+            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,
-        )
+            self.request(
+                spec.method,
+                url=spec.endpoint,
+                headers=spec.headers,
+            )
+        except Exception as e:
+            # If not found in UiPath, check local storage
+            if "404" in str(e):
+                # Check if file exists in temp directory
+                if os.path.exists(self._temp_dir):
+                    # Look for any file starting with our UUID
+                    pattern = f"{key}_*"
+                    matching_files = list(Path(self._temp_dir).glob(pattern))
+
+                    if matching_files:
+                        # Delete all matching files
+                        for file_path in matching_files:
+                            os.remove(file_path)
+                        return
+
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(
+                f"Attachment with key {key} not found in UiPath or local storage"
+            ) from e
 
     @traced(name="attachments_delete", run_type="uipath")
     async def delete_async(
@@ -509,6 +623,12 @@ class AttachmentsService(FolderContext, BaseService):
         """Delete an attachment asynchronously.
 
         This method asynchronously deletes an attachment from UiPath.
+        If the attachment is not found in UiPath (404 error), it will check
+        for a local file in the temporary directory that matches the UUID.
+
+        Note:
+            The local file fallback functionality is intended for local development
+            and debugging purposes only.
 
         Args:
             key (uuid.UUID): The key of the attachment to delete.
@@ -516,7 +636,7 @@ class AttachmentsService(FolderContext, BaseService):
             folder_path (Optional[str]): The path of the folder. Override the default one set in the SDK config.
 
         Raises:
-            Exception: If the deletion fails.
+            Exception: If the deletion fails and no local file is found.
 
         Examples:
             ```python
@@ -532,17 +652,37 @@ class AttachmentsService(FolderContext, BaseService):
                 print("Attachment deleted successfully")
             ```
         """
-        spec = self._delete_attachment_spec(
-            key=key,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
+        try:
+            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,
-        )
+            await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                headers=spec.headers,
+            )
+        except Exception as e:
+            # If not found in UiPath, check local storage
+            if "404" in str(e):
+                # Check if file exists in temp directory
+                if os.path.exists(self._temp_dir):
+                    # Look for any file starting with our UUID
+                    pattern = f"{key}_*"
+                    matching_files = list(Path(self._temp_dir).glob(pattern))
+
+                    if matching_files:
+                        # Delete all matching files
+                        for file_path in matching_files:
+                            os.remove(file_path)
+                        return
+
+            # Re-raise the original exception if we can't find it locally
+            raise Exception(
+                f"Attachment with key {key} not found in UiPath or local storage"
+            ) from e
 
     @property
     def custom_headers(self) -> Dict[str, str]:

uipath/_services/context_grounding_service.py

@@ -3,6 +3,7 @@ from typing import Any, List, Optional, Tuple, Union
 
 import httpx
 from pydantic import TypeAdapter
+from typing_extensions import deprecated
 
 from .._config import Config
 from .._execution_context import ExecutionContext
@@ -234,6 +235,7 @@ class ContextGroundingService(FolderContext, BaseService):
             raise Exception("ContextGroundingIndex not found") from e
 
     @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
+    @deprecated("Use retrieve instead")
     def retrieve_by_id(
         self,
         id: str,
@@ -266,6 +268,7 @@ class ContextGroundingService(FolderContext, BaseService):
         ).json()
 
     @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
+    @deprecated("Use retrieve_async instead")
     async def retrieve_by_id_async(
         self,
         id: str,
@@ -656,11 +659,11 @@ class ContextGroundingService(FolderContext, BaseService):
 
     def _resolve_folder_key(self, folder_key, folder_path):
         if folder_key is None and folder_path is not None:
-            folder_key = self._folders_service.retrieve_key_by_folder_path(folder_path)
+            folder_key = self._folders_service.retrieve_key(folder_path=folder_path)
 
         if folder_key is None and folder_path is None:
             folder_key = self._folder_key or (
-                self._folders_service.retrieve_key_by_folder_path(self._folder_path)
+                self._folders_service.retrieve_key(folder_path=self._folder_path)
                 if self._folder_path
                 else None
             )

uipath/_services/folder_service.py

@@ -1,5 +1,7 @@
 from typing import Optional
 
+from typing_extensions import deprecated
+
 from uipath.tracing._traced import traced
 
 from .._config import Config
@@ -8,20 +10,6 @@ from .._utils import Endpoint, RequestSpec
 from ._base_service import BaseService
 
 
-def _retrieve_spec(folder_path: str) -> RequestSpec:
-    folder_name = folder_path.split("/")[-1]
-    return RequestSpec(
-        method="GET",
-        endpoint=Endpoint(
-            "orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser"
-        ),
-        params={
-            "searchText": folder_name,
-            "take": 1,
-        },
-    )
-
-
 class FolderService(BaseService):
     """Service for managing UiPath Folders.
 
@@ -34,8 +22,13 @@ class FolderService(BaseService):
         super().__init__(config=config, execution_context=execution_context)
 
     @traced(name="folder_retrieve_key_by_folder_path", run_type="uipath")
+    @deprecated("Use retrieve_key instead")
     def retrieve_key_by_folder_path(self, folder_path: str) -> Optional[str]:
-        spec = _retrieve_spec(folder_path)
+        return self.retrieve_key(folder_path=folder_path)
+
+    @traced(name="folder_retrieve_key", run_type="uipath")
+    def retrieve_key(self, *, folder_path: str) -> Optional[str]:
+        spec = self._retrieve_spec(folder_path)
         response = self.request(
             spec.method,
             url=spec.endpoint,
@@ -50,3 +43,16 @@ class FolderService(BaseService):
             ),
             None,
         )
+
+    def _retrieve_spec(self, folder_path: str) -> RequestSpec:
+        folder_name = folder_path.split("/")[-1]
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                "orchestrator_/api/FoldersNavigation/GetFoldersForCurrentUser"
+            ),
+            params={
+                "searchText": folder_name,
+                "take": 1,
+            },
+        )

uipath/_services/jobs_service.py

@@ -1,15 +1,20 @@
 import json
+import os
+import shutil
+import tempfile
 import uuid
-from typing import Any, Dict, List, Optional, overload
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union, cast, 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 .._utils.constants import TEMP_ATTACHMENTS_FOLDER
 from ..models.job import Job
 from ..tracing._traced import traced
 from ._base_service import BaseService
+from .attachments_service import AttachmentsService
 
 
 class JobsService(FolderContext, BaseService):
@@ -22,6 +27,10 @@ class JobsService(FolderContext, BaseService):
 
     def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
         super().__init__(config=config, execution_context=execution_context)
+        self._attachments_service = AttachmentsService(config, execution_context)
+        # Define the temp directory path for local attachments
+        self._temp_dir = os.path.join(tempfile.gettempdir(), TEMP_ATTACHMENTS_FOLDER)
+        os.makedirs(self._temp_dir, exist_ok=True)
 
     @overload
     def resume(self, *, inbox_id: str, payload: Any) -> None: ...
@@ -212,7 +221,6 @@ class JobsService(FolderContext, BaseService):
 
     def _extract_first_inbox_id(self, response: Any) -> str:
         if len(response["value"]) > 0:
-            # FIXME: is this correct?
             return response["value"][0]["ItemKey"]
         else:
             raise Exception("No inbox found")
@@ -275,7 +283,7 @@ class JobsService(FolderContext, BaseService):
         job_key: uuid.UUID,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> List[Attachment]:
+    ) -> List[str]:
         """List attachments associated with a specific job.
 
         This method retrieves all attachments linked to a job by its key.
@@ -286,23 +294,10 @@ class JobsService(FolderContext, BaseService):
             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.
+            List[str]: A list of attachment IDs 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,
@@ -317,7 +312,7 @@ class JobsService(FolderContext, BaseService):
             headers=spec.headers,
         ).json()
 
-        return [Attachment.model_validate(item) for item in response]
+        return [item.get("attachmentId") for item in response]
 
     @traced(name="jobs_list_attachments", run_type="uipath")
     async def list_attachments_async(
@@ -326,7 +321,7 @@ class JobsService(FolderContext, BaseService):
         job_key: uuid.UUID,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> List[Attachment]:
+    ) -> List[str]:
         """List attachments associated with a specific job asynchronously.
 
         This method asynchronously retrieves all attachments linked to a job by its key.
@@ -337,7 +332,7 @@ class JobsService(FolderContext, BaseService):
             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.
+            List[str]: A list of attachment IDs associated with the job.
 
         Raises:
             Exception: If the retrieval fails.
@@ -353,8 +348,8 @@ class JobsService(FolderContext, BaseService):
                 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}")
+                for attachment_id in attachments:
+                    print(f"Attachment ID: {attachment_id}")
             ```
         """
         spec = self._list_job_attachments_spec(
@@ -372,7 +367,7 @@ class JobsService(FolderContext, BaseService):
             )
         ).json()
 
-        return [Attachment.model_validate(item) for item in response]
+        return [item.get("attachmentId") for item in response]
 
     @traced(name="jobs_link_attachment", run_type="uipath")
     def link_attachment(
@@ -397,20 +392,6 @@ class JobsService(FolderContext, BaseService):
 
         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,
@@ -419,8 +400,7 @@ class JobsService(FolderContext, BaseService):
             folder_key=folder_key,
             folder_path=folder_path,
         )
-
-        return self.request(
+        self.request(
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
@@ -450,22 +430,6 @@ class JobsService(FolderContext, BaseService):
 
         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,
@@ -474,8 +438,7 @@ class JobsService(FolderContext, BaseService):
             folder_key=folder_key,
             folder_path=folder_path,
         )
-
-        return await self.request_async(
+        await self.request_async(
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
@@ -519,3 +482,275 @@ class JobsService(FolderContext, BaseService):
                 **header_folder(folder_key, folder_path),
             },
         )
+
+    @traced(name="jobs_create_attachment", run_type="uipath")
+    def create_attachment(
+        self,
+        *,
+        name: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[Union[str, Path]] = None,
+        job_key: Optional[Union[str, uuid.UUID]] = None,
+        category: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID:
+        """Create and upload an attachment, optionally linking it to a job.
+
+        This method handles creating an attachment from a file or memory data.
+        If a job key is provided or available in the execution context, the attachment
+        will be created in UiPath and linked to the job. If no job is available,
+        the file will be saved to a temporary storage folder.
+
+        Note:
+            The local storage functionality (when no job is available) is intended for
+            local development and debugging purposes only.
+
+        Args:
+            name (str): The name of the attachment file.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            source_path (Optional[Union[str, Path]]): The local path of the file to upload.
+            job_key (Optional[Union[str, uuid.UUID]]): The key of the job to link the attachment to.
+            category (Optional[str]): Optional category for the attachment in the context of the 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.
+
+        Returns:
+            uuid.UUID: The unique identifier for the created attachment, regardless of whether it was
+                uploaded to UiPath or stored locally.
+
+        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()
+
+            # Create attachment from file and link to job
+            attachment_id = client.jobs.create_attachment(
+                name="document.pdf",
+                source_path="path/to/local/document.pdf",
+                job_key="38073051"
+            )
+            print(f"Created and linked attachment: {attachment_id}")
+
+            # Create attachment from memory content (no job available - saves to temp storage)
+            attachment_id = client.jobs.create_attachment(
+                name="report.txt",
+                content="This is a text report"
+            )
+            print(f"Created attachment: {attachment_id}")
+            ```
+        """
+        # 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")
+
+        # Get job key from context if not explicitly provided
+        context_job_key = None
+        if job_key is None and hasattr(self._execution_context, "job_key"):
+            context_job_key = self._execution_context.job_key
+
+        # Check if a job is available
+        if job_key is not None or context_job_key is not None:
+            # Job is available - create attachment in UiPath and link to job
+            actual_job_key = job_key if job_key is not None else context_job_key
+
+            # Create the attachment using the attachments service
+            if content is not None:
+                attachment_key = self._attachments_service.upload(
+                    name=name,
+                    content=content,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+            else:
+                # source_path must be provided due to validation check above
+                attachment_key = self._attachments_service.upload(
+                    name=name,
+                    source_path=cast(str, source_path),
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+
+            # Convert to UUID if string
+            if isinstance(actual_job_key, str):
+                actual_job_key = uuid.UUID(actual_job_key)
+
+            # Link attachment to job
+            self.link_attachment(
+                attachment_key=attachment_key,
+                job_key=cast(uuid.UUID, actual_job_key),
+                category=category,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+
+            return attachment_key
+        else:
+            # No job available - save to temp folder
+            # Generate a UUID to use as identifier
+            attachment_id = uuid.uuid4()
+
+            # Create destination file path
+            dest_path = os.path.join(self._temp_dir, f"{attachment_id}_{name}")
+
+            # If we have source_path, copy the file
+            if source_path is not None:
+                source_path_str = (
+                    source_path if isinstance(source_path, str) else str(source_path)
+                )
+                shutil.copy2(source_path_str, dest_path)
+            # If we have content, write it to a file
+            elif content is not None:
+                # Convert string to bytes if needed
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+
+                with open(dest_path, "wb") as f:
+                    f.write(content)
+
+            # Return only the UUID
+            return attachment_id
+
+    @traced(name="jobs_create_attachment", run_type="uipath")
+    async def create_attachment_async(
+        self,
+        *,
+        name: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[Union[str, Path]] = None,
+        job_key: Optional[Union[str, uuid.UUID]] = None,
+        category: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> uuid.UUID:
+        """Create and upload an attachment asynchronously, optionally linking it to a job.
+
+        This method asynchronously handles creating an attachment from a file or memory data.
+        If a job key is provided or available in the execution context, the attachment
+        will be created in UiPath and linked to the job. If no job is available,
+        the file will be saved to a temporary storage folder.
+
+        Note:
+            The local storage functionality (when no job is available) is intended for
+            local development and debugging purposes only.
+
+        Args:
+            name (str): The name of the attachment file.
+            content (Optional[Union[str, bytes]]): The content to upload (string or bytes).
+            source_path (Optional[Union[str, Path]]): The local path of the file to upload.
+            job_key (Optional[Union[str, uuid.UUID]]): The key of the job to link the attachment to.
+            category (Optional[str]): Optional category for the attachment in the context of the 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.
+
+        Returns:
+            uuid.UUID: The unique identifier for the created attachment, regardless of whether it was
+                uploaded to UiPath or stored locally.
+
+        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():
+                # Create attachment from file and link to job
+                attachment_id = await client.jobs.create_attachment_async(
+                    name="document.pdf",
+                    source_path="path/to/local/document.pdf",
+                    job_key="38073051"
+                )
+                print(f"Created and linked attachment: {attachment_id}")
+
+                # Create attachment from memory content (no job available - saves to temp storage)
+                attachment_id = await client.jobs.create_attachment_async(
+                    name="report.txt",
+                    content="This is a text report"
+                )
+                print(f"Created attachment: {attachment_id}")
+            ```
+        """
+        # 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")
+
+        # Get job key from context if not explicitly provided
+        context_job_key = None
+        if job_key is None and hasattr(self._execution_context, "job_key"):
+            context_job_key = self._execution_context.job_key
+
+        # Check if a job is available
+        if job_key is not None or context_job_key is not None:
+            # Job is available - create attachment in UiPath and link to job
+            actual_job_key = job_key if job_key is not None else context_job_key
+
+            # Create the attachment using the attachments service
+            if content is not None:
+                attachment_key = await self._attachments_service.upload_async(
+                    name=name,
+                    content=content,
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+            else:
+                # source_path must be provided due to validation check above
+                attachment_key = await self._attachments_service.upload_async(
+                    name=name,
+                    source_path=cast(str, source_path),
+                    folder_key=folder_key,
+                    folder_path=folder_path,
+                )
+
+            # Convert to UUID if string
+            if isinstance(actual_job_key, str):
+                actual_job_key = uuid.UUID(actual_job_key)
+
+            # Link attachment to job
+            await self.link_attachment_async(
+                attachment_key=attachment_key,
+                job_key=cast(uuid.UUID, actual_job_key),
+                category=category,
+                folder_key=folder_key,
+                folder_path=folder_path,
+            )
+
+            return attachment_key
+        else:
+            # No job available - save to temp folder
+            # Generate a UUID to use as identifier
+            attachment_id = uuid.uuid4()
+
+            # Create destination file path
+            dest_path = os.path.join(self._temp_dir, f"{attachment_id}_{name}")
+
+            # If we have source_path, copy the file
+            if source_path is not None:
+                source_path_str = (
+                    source_path if isinstance(source_path, str) else str(source_path)
+                )
+                shutil.copy2(source_path_str, dest_path)
+            # If we have content, write it to a file
+            elif content is not None:
+                # Convert string to bytes if needed
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+
+                with open(dest_path, "wb") as f:
+                    f.write(content)
+
+            # Return only the UUID
+            return attachment_id

uipath/_utils/constants.py

@@ -25,3 +25,6 @@ ENTRYPOINT = "uipath.connectors"
 ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (
     "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
 )
+
+# Local storage
+TEMP_ATTACHMENTS_FOLDER = "uipath_attachments"

uipath/tracing/_utils.py

@@ -134,16 +134,17 @@ class _SpanUtils:
         if otel_span.parent is not None:
             parent_id = _SpanUtils.span_id_to_uuid4(otel_span.parent.span_id)
 
-        # Map status
-        status = 1  # Default to OK
-        if otel_span.status.status_code == StatusCode.ERROR:
-            status = 2  # Error
-
         # Convert attributes to a format compatible with UiPathSpan
         attributes_dict: dict[str, Any] = (
             dict(otel_span.attributes) if otel_span.attributes else {}
         )
 
+        # Map status
+        status = 1  # Default to OK
+        if otel_span.status.status_code == StatusCode.ERROR:
+            status = 2  # Error
+            attributes_dict["error"] = otel_span.status.description
+
         original_inputs = attributes_dict.get("inputs", None)
         original_outputs = attributes_dict.get("outputs", None)
 

{uipath-2.0.57.dist-info → uipath-2.0.58.dist-info}/METADATA

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

@@ -44,12 +44,12 @@ uipath/_services/_base_service.py,sha256=y-QATIRF9JnUFKIwmjOWMHlE2BrJYgD8y4sGAve
 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/attachments_service.py,sha256=h2pEm5YcW0x5F6Ti3CKB7ufg2FBE7MYhyc1mRmuKca4,26372
 uipath/_services/buckets_service.py,sha256=736isvj01_-Srh0JiorS02pOwjF0_Loaf-xR6u0B7Ww,14932
 uipath/_services/connections_service.py,sha256=qh-HNL_GJsyPUD0wSJZRF8ZdrTE9l4HrIilmXGK6dDk,4581
-uipath/_services/context_grounding_service.py,sha256=nE-RZuean_DXK7a6pcA4S2fcWcfWmQ-rmOihi5_qErU,24072
-uipath/_services/folder_service.py,sha256=HtsBoBejvMuIZ-9gocAG9B8uKOFsAAD4WUozta-isXk,1673
-uipath/_services/jobs_service.py,sha256=Z1CmglIe6pFt0XovPLbuLCp13mWQw92MgjfRivqsodE,16745
+uipath/_services/context_grounding_service.py,sha256=Dd3mlsZB2CpZZLQ-1fBa6FygoSXZfeEDeZ7o4cDXnNY,24193
+uipath/_services/folder_service.py,sha256=h0CWNqF2-8w2QLrfy-D8P3z_qA81Te689OXlFKtnby0,2001
+uipath/_services/jobs_service.py,sha256=I2-iqjMJcfgz5sgVOMWF5PkGzch_1q1swUstdv2PpMo,27308
 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
@@ -62,7 +62,7 @@ uipath/_utils/_request_override.py,sha256=fIVHzgHVXITUlWcp8osNBwIafM1qm4_ejx0ng5
 uipath/_utils/_request_spec.py,sha256=iCtBLqtbWUpFG5g1wtIZBzSupKsfaRLiQFoFc_4B70Q,747
 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/_utils/constants.py,sha256=fApisQxldGrnOFqwCLrQyNxBsReNBnCsp_9cmmL45s4,937
 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
@@ -85,9 +85,9 @@ uipath/telemetry/_track.py,sha256=v0e3hgwtetMsUco4yosBzNU00Ek5SI9RxUTumrTTNyo,38
 uipath/tracing/__init__.py,sha256=GimSzv6qkCOlHOG1WtjYKJsZqcXpA28IgoXfR33JhiA,139
 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.57.dist-info/METADATA,sha256=OKwYNKZD-y2kOHlywNqDxh1b-lU0NpUCb1btkd6IwHY,6304
-uipath-2.0.57.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.57.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.57.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.57.dist-info/RECORD,,
+uipath/tracing/_utils.py,sha256=s0fQPlkrnd484_pcHuNvW6-ElHiZH8mkfMkYFBfwnCQ,10234
+uipath-2.0.58.dist-info/METADATA,sha256=eRDwcjhk6BZCe6_XZs9IOyaOus8gNczSFlxMWusXAr8,6304
+uipath-2.0.58.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.58.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.58.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.58.dist-info/RECORD,,