uipath 2.1.107__tar.gz → 2.1.108__tar.gz

{uipath-2.1.107 → uipath-2.1.108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.107
+Version: 2.1.108
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.107 → uipath-2.1.108}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.107"
+version = "2.1.108"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.107 → uipath-2.1.108}/src/uipath/_cli/_runtime/_contracts.py

@@ -460,12 +460,12 @@ class UiPathRuntimeContext(BaseModel):
         return instance
 
 
-class UiPathRuntimeError(Exception):
+class UiPathBaseRuntimeError(Exception):
     """Base exception class for UiPath runtime errors with structured error information."""
 
     def __init__(
         self,
-        code: UiPathErrorCode,
+        code: str,
         title: str,
         detail: str,
         category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
@@ -484,10 +484,8 @@ class UiPathRuntimeError(Exception):
         if status is None:
             status = self._extract_http_status()
 
-        code_value = code.value
-
         self.error_info = UiPathErrorContract(
-            code=f"{prefix}.{code_value}",
+            code=f"{prefix}.{code}",
             title=title,
             detail=detail,
             category=category,
@@ -529,6 +527,28 @@ class UiPathRuntimeError(Exception):
         return self.error_info.model_dump()
 
 
+class UiPathRuntimeError(UiPathBaseRuntimeError):
+    """Exception class for UiPath runtime errors."""
+
+    def __init__(
+        self,
+        code: UiPathErrorCode,
+        title: str,
+        detail: str,
+        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        prefix: str = "Python",
+        include_traceback: bool = True,
+    ):
+        super().__init__(
+            code=code.value,
+            title=title,
+            detail=detail,
+            category=category,
+            prefix=prefix,
+            include_traceback=include_traceback,
+        )
+
+
 class UiPathRuntimeStreamNotSupportedError(NotImplementedError):
     """Raised when a runtime does not support streaming."""
 

{uipath-2.1.107 → uipath-2.1.108}/src/uipath/_resources/SDK_REFERENCE.md

@@ -70,93 +70,6 @@ sdk.assets.update_async(robot_asset: uipath.models.assets.UserAsset, folder_key:
 
 ```
 
-### Attachments
-
-Attachments service
-
-```python
-# Delete an attachment.
-sdk.attachments.delete(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Delete an attachment asynchronously.
-sdk.attachments.delete_async(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download an attachment.
-sdk.attachments.download(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Download an attachment asynchronously.
-sdk.attachments.download_async(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Upload a file or content to UiPath as an attachment.
-sdk.attachments.upload(name: str, content: Union[str, bytes, NoneType]=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.
-sdk.attachments.upload_async(name: str, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
-
-```
-
-### Buckets
-
-Buckets service
-
-```python
-# Download a file from a bucket.
-sdk.buckets.download(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download a file from a bucket asynchronously.
-sdk.buckets.download_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Retrieve bucket information by its name.
-sdk.buckets.retrieve(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Asynchronously retrieve bucket information by its name.
-sdk.buckets.retrieve_async(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Upload a file to a bucket.
-sdk.buckets.upload(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Upload a file to a bucket asynchronously.
-sdk.buckets.upload_async(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-```
-
-### Connections
-
-Connections service
-
-```python
-# Lists all connections with optional filtering.
-sdk.connections.list(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Asynchronously lists all connections with optional filtering.
-sdk.connections.list_async(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Synchronously retrieve connection API metadata.
-sdk.connections.metadata(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Asynchronously retrieve connection API metadata.
-sdk.connections.metadata_async(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Retrieve connection details by its key.
-sdk.connections.retrieve(key: str) -> uipath.models.connections.Connection
-
-# Asynchronously retrieve connection details by its key.
-sdk.connections.retrieve_async(key: str) -> uipath.models.connections.Connection
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload_async(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve an authentication token for a connection.
-sdk.connections.retrieve_token(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-# Asynchronously retrieve an authentication token for a connection.
-sdk.connections.retrieve_token_async(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-```
-
 ### Context Grounding
 
 Context Grounding service
@@ -274,16 +187,6 @@ sdk.entities.update_records_async(entity_key: str, records: List[Any], schema: O
 
 ```
 
-### Folders
-
-Folders service
-
-```python
-# Retrieve the folder key by folder path with pagination support.
-sdk.folders.retrieve_key(folder_path: str) -> typing.Optional[str]
-
-```
-
 ### Jobs
 
 Jobs service

{uipath-2.1.107 → uipath-2.1.108}/src/uipath/_uipath.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 from typing import Optional
 
 from pydantic import ValidationError
@@ -51,10 +52,6 @@ class UiPath:
                     raise BaseUrlMissingError() from e
                 elif error["loc"][0] == "secret":
                     raise SecretMissingError() from e
-        self._folders_service: Optional[FolderService] = None
-        self._buckets_service: Optional[BucketsService] = None
-        self._attachments_service: Optional[AttachmentsService] = None
-        self._connections_service: Optional[ConnectionsService] = None
         setup_logging(should_debug=debug)
         self._execution_context = ExecutionContext()
 
@@ -66,13 +63,9 @@ class UiPath:
     def assets(self) -> AssetsService:
         return AssetsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def attachments(self) -> AttachmentsService:
-        if not self._attachments_service:
-            self._attachments_service = AttachmentsService(
-                self._config, self._execution_context
-            )
-        return self._attachments_service
+        return AttachmentsService(self._config, self._execution_context)
 
     @property
     def processes(self) -> ProcessesService:
@@ -82,39 +75,21 @@ class UiPath:
     def actions(self) -> ActionsService:
         return ActionsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def buckets(self) -> BucketsService:
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
         return BucketsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def connections(self) -> ConnectionsService:
-        if not self._connections_service:
-            if not self._folders_service:
-                self._folders_service = FolderService(
-                    self._config, self._execution_context
-                )
-            self._connections_service = ConnectionsService(
-                self._config, self._execution_context, self._folders_service
-            )
-        return self._connections_service
+        return ConnectionsService(self._config, self._execution_context, self.folders)
 
     @property
     def context_grounding(self) -> ContextGroundingService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
         return ContextGroundingService(
             self._config,
             self._execution_context,
-            self._folders_service,
-            self._buckets_service,
+            self.folders,
+            self.buckets,
         )
 
     @property
@@ -129,11 +104,9 @@ class UiPath:
     def jobs(self) -> JobsService:
         return JobsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def folders(self) -> FolderService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        return self._folders_service
+        return FolderService(self._config, self._execution_context)
 
     @property
     def llm_openai(self) -> UiPathOpenAIService:

uipath-2.1.108/tests/sdk/test_uipath_caching.py

@@ -0,0 +1,326 @@
+"""Tests for service caching behavior in UiPath SDK.
+
+This module tests that services using @cached_property are properly cached
+and thread-safe, while stateless services create new instances as expected.
+"""
+
+import threading
+import time
+from typing import Any
+
+import pytest
+from pytest import MonkeyPatch
+
+from uipath import UiPath
+
+
+@pytest.fixture
+def sdk(monkeypatch: MonkeyPatch) -> UiPath:
+    """Create a UiPath SDK instance with mocked credentials."""
+    monkeypatch.setenv("UIPATH_URL", "https://test.example.com")
+    monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test_token_1234567890")
+    return UiPath()
+
+
+class TestCachedServices:
+    """Test suite for services that should be cached."""
+
+    def test_buckets_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that buckets property returns the same instance on multiple accesses."""
+        buckets1 = sdk.buckets
+        buckets2 = sdk.buckets
+
+        assert buckets1 is buckets2, "BucketsService should return cached instance"
+        assert id(buckets1) == id(buckets2), "Instance IDs should match"
+
+    def test_attachments_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that attachments property returns the same instance."""
+        attachments1 = sdk.attachments
+        attachments2 = sdk.attachments
+
+        assert attachments1 is attachments2, (
+            "AttachmentsService should return cached instance"
+        )
+        assert id(attachments1) == id(attachments2), "Instance IDs should match"
+
+    def test_connections_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that connections property returns the same instance."""
+        connections1 = sdk.connections
+        connections2 = sdk.connections
+
+        assert connections1 is connections2, (
+            "ConnectionsService should return cached instance"
+        )
+        assert id(connections1) == id(connections2), "Instance IDs should match"
+
+    def test_folders_service_returns_cached_instance(self, sdk: UiPath) -> None:
+        """Verify that folders property returns the same instance."""
+        folders1 = sdk.folders
+        folders2 = sdk.folders
+
+        assert folders1 is folders2, "FolderService should return cached instance"
+        assert id(folders1) == id(folders2), "Instance IDs should match"
+
+    @pytest.mark.parametrize(
+        "service_property",
+        [
+            "attachments",
+            "buckets",
+            "connections",
+            "folders",
+        ],
+    )
+    def test_all_cached_services_return_same_instance(
+        self, sdk: UiPath, service_property: str
+    ) -> None:
+        """Verify that all cached services return the same instance."""
+        service1 = getattr(sdk, service_property)
+        service2 = getattr(sdk, service_property)
+
+        assert service1 is service2, f"{service_property} should return cached instance"
+
+    def test_cached_services_share_config(self, sdk: UiPath) -> None:
+        """Verify that cached instances share the same config object."""
+        buckets1 = sdk.buckets
+        buckets2 = sdk.buckets
+
+        assert buckets1._config is buckets2._config, "Config should be shared"
+        assert buckets1._execution_context is buckets2._execution_context, (
+            "Execution context should be shared"
+        )
+
+    def test_different_sdk_instances_have_different_services(
+        self, monkeypatch: MonkeyPatch
+    ) -> None:
+        """Verify that different SDK instances have different service instances."""
+        monkeypatch.setenv("UIPATH_URL", "https://test.example.com")
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "test_token_1234567890")
+        sdk1 = UiPath()
+        sdk2 = UiPath()
+
+        assert sdk1.buckets is not sdk2.buckets, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.attachments is not sdk2.attachments, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.connections is not sdk2.connections, (
+            "Different SDK instances should have different service instances"
+        )
+        assert sdk1.folders is not sdk2.folders, (
+            "Different SDK instances should have different service instances"
+        )
+
+
+class TestThreadSafety:
+    """Test suite for thread safety of cached services."""
+
+    def test_buckets_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify that cached_property handles concurrent access safely."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            # Small delay to increase chance of race condition
+            time.sleep(0.001)
+            instances.append(sdk.buckets)
+
+        # Create 10 threads accessing the service simultaneously
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+
+        for thread in threads:
+            thread.join()
+
+        # All threads should get the same instance
+        assert len(set(id(instance) for instance in instances)) == 1, (
+            "All threads should receive the same cached instance"
+        )
+
+        for instance in instances[1:]:
+            assert instances[0] is instance, "All instances should be identical"
+
+    def test_attachments_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify attachments service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.attachments)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+    def test_connections_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify connections service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.connections)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+    def test_folders_service_thread_safe_initialization(self, sdk: UiPath) -> None:
+        """Verify folders service thread safety."""
+        instances: list[Any] = []
+
+        def access_service() -> None:
+            time.sleep(0.001)
+            instances.append(sdk.folders)
+
+        threads = [threading.Thread(target=access_service) for _ in range(10)]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(set(id(instance) for instance in instances)) == 1
+
+
+class TestStatelessServices:
+    """Test suite for services that should NOT be cached."""
+
+    def test_assets_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that assets service creates new instances (stateless)."""
+        assets1 = sdk.assets
+        assets2 = sdk.assets
+
+        # These should be different instances
+        assert assets1 is not assets2, "Assets service should create new instances"
+
+    def test_actions_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that actions service creates new instances (stateless)."""
+        actions1 = sdk.actions
+        actions2 = sdk.actions
+
+        assert actions1 is not actions2, "Actions service should create new instances"
+
+    def test_queues_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that queues service creates new instances (stateless)."""
+        queues1 = sdk.queues
+        queues2 = sdk.queues
+
+        assert queues1 is not queues2, "Queues service should create new instances"
+
+    def test_jobs_service_creates_new_instances(self, sdk: UiPath) -> None:
+        """Verify that jobs service creates new instances (stateless)."""
+        jobs1 = sdk.jobs
+        jobs2 = sdk.jobs
+
+        assert jobs1 is not jobs2, "Jobs service should create new instances"
+
+    @pytest.mark.parametrize(
+        "service_property",
+        [
+            "api_client",
+            "assets",
+            "actions",
+            "processes",
+            "queues",
+            "jobs",
+            "documents",
+            "llm_openai",
+            "llm",
+            "entities",
+        ],
+    )
+    def test_stateless_services_create_new_instances(
+        self, sdk: UiPath, service_property: str
+    ) -> None:
+        """Verify that stateless services create new instances."""
+        service1 = getattr(sdk, service_property)
+        service2 = getattr(sdk, service_property)
+
+        assert service1 is not service2, (
+            f"{service_property} should create new instances"
+        )
+
+
+class TestServiceDependencies:
+    """Test suite for services with dependencies on cached services."""
+
+    def test_connections_uses_cached_folders(self, sdk: UiPath) -> None:
+        """Verify that connections service uses the cached folders service."""
+
+        # Access connections (which depends on folders)
+        _ = sdk.connections
+
+        # Access folders directly
+        folders = sdk.folders
+
+        # The folders instance used by connections should be the same cached instance
+        assert folders is sdk.folders, "Folders should be cached and reused"
+
+    def test_context_grounding_uses_cached_dependencies(self, sdk: UiPath) -> None:
+        """Verify that context_grounding uses cached folders and buckets."""
+
+        # Access dependencies first
+        folders = sdk.folders
+        buckets = sdk.buckets
+
+        # Access context_grounding (creates new instance but uses cached deps)
+        cg1 = sdk.context_grounding
+        cg2 = sdk.context_grounding
+
+        # context_grounding itself is not cached (creates new instances)
+        assert cg1 is not cg2, "ContextGroundingService should create new instances"
+
+        # But it should use the same cached dependencies
+        assert folders is sdk.folders, "Folders should remain cached"
+        assert buckets is sdk.buckets, "Buckets should remain cached"
+
+    def test_processes_uses_cached_attachments(self, sdk: UiPath) -> None:
+        """Verify that processes service uses the cached attachments service."""
+
+        # Access attachments directly
+        attachments = sdk.attachments
+
+        # Access processes (which depends on attachments)
+        _ = sdk.processes
+
+        # Attachments should still be cached
+        assert attachments is sdk.attachments, "Attachments should remain cached"
+
+
+class TestCachingBehavior:
+    """Test suite for general caching behavior."""
+
+    def test_cached_property_attribute_name(self, sdk: UiPath) -> None:
+        """Verify that @cached_property stores values in expected attribute names."""
+
+        # Access the service
+        _ = sdk.buckets
+
+        # @cached_property stores the value in an attribute with the property name
+        assert hasattr(sdk, "buckets"), "Cached value should be stored as attribute"
+
+    def test_service_initialization_order(self, sdk: UiPath) -> None:
+        """Verify that services can be accessed in any order."""
+
+        # Access in different order
+        connections = sdk.connections  # Depends on folders
+        folders = sdk.folders
+        buckets = sdk.buckets
+        attachments = sdk.attachments
+
+        # All should be cached and reusable
+        assert connections is sdk.connections
+        assert folders is sdk.folders
+        assert buckets is sdk.buckets
+        assert attachments is sdk.attachments

{uipath-2.1.107 → uipath-2.1.108}/uv.lock

@@ -2823,7 +2823,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.107"
+version = "2.1.108"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },