uipath 2.0.0.dev2__py3-none-any.whl → 2.0.1.dev1__py3-none-any.whl

uipath/_services/assets_service.py

@@ -0,0 +1,257 @@
+from typing import Dict, Optional
+
+from httpx import Response
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._models import UserAsset
+from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
+from ._base_service import BaseService
+
+
+class AssetsService(FolderContext, BaseService):
+    """Service for managing UiPath assets.
+
+    Assets are key-value pairs that can be used to store configuration data,
+    credentials, and other settings used by automation processes.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @infer_bindings()
+    def retrieve(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> UserAsset:
+        """Retrieve an asset by its name.
+
+        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
+
+        Args:
+            name (str): The name of the asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+           UserAsset: The asset data.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            client.assets.retrieve(name="MyAsset")
+            ```
+        """
+        spec = self._retrieve_spec(name, folder_key=folder_key, folder_path=folder_path)
+        response = self.request(
+            spec.method, url=spec.endpoint, content=spec.content, headers=spec.headers
+        )
+
+        return UserAsset.model_validate(response.json())
+
+    async def retrieve_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> UserAsset:
+        """Asynchronously retrieve an asset by its name.
+
+        Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
+
+        Args:
+            name (str): The name of the asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            UserAsset: The asset data.
+        """
+        spec = self._retrieve_spec(name, folder_key=folder_key, folder_path=folder_path)
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, content=spec.content, headers=spec.headers
+        )
+
+        return UserAsset.model_validate(response.json())
+
+    @infer_bindings()
+    def retrieve_credential(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Gets a specified Orchestrator credential.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable)
+
+        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
+
+        Args:
+            name (str): The name of the credential asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted credential password.
+        """
+        spec = self._retrieve_spec(name, folder_key=folder_key, folder_path=folder_path)
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        user_asset = UserAsset.model_validate(response.json())
+
+        return user_asset.credential_password
+
+    @infer_bindings()
+    async def retrieve_credential_async(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Optional[str]:
+        """Asynchronously gets a specified Orchestrator credential.
+
+        The robot id is retrieved from the execution context (`UIPATH_ROBOT_KEY` environment variable)
+
+        Related Activity: [Get Credential](https://docs.uipath.com/activities/other/latest/workflow/get-robot-credential)
+
+        Args:
+            name (str): The name of the credential asset.
+            folder_key (Optional[str]): The key of the folder to execute the process in. Override the default one set in the SDK config.
+            folder_path (Optional[str]): The path of the folder to execute the process in. Override the default one set in the SDK config.
+
+        Returns:
+            Optional[str]: The decrypted credential password.
+
+        """
+        spec = self._retrieve_spec(name, folder_key=folder_key, folder_path=folder_path)
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        user_asset = UserAsset.model_validate(response.json())
+
+        return user_asset.credential_password
+
+    def update(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Update an asset's value.
+
+        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
+
+        Args:
+            robot_asset (UserAsset): The asset object containing the updated values.
+
+        Returns:
+            Response: The HTTP response confirming the update.
+        """
+        spec = self._update_spec(
+            robot_asset, folder_key=folder_key, folder_path=folder_path
+        )
+
+        return self.request(
+            spec.method,
+            url=spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+    async def update_async(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Response:
+        """Asynchronously update an asset's value.
+
+        Related Activity: [Set Asset](https://docs.uipath.com/activities/other/latest/workflow/set-asset)
+
+        Args:
+            robot_asset (UserAsset): The asset object containing the updated values.
+
+        Returns:
+            Response: The HTTP response confirming the update.
+        """
+        spec = self._update_spec(
+            robot_asset, folder_key=folder_key, folder_path=folder_path
+        )
+
+        return await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _retrieve_spec(
+        self,
+        name: str,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
+            ),
+            content=str(
+                {"assetName": name, "robotKey": self._execution_context.robot_key}
+            ),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+
+    def _update_spec(
+        self,
+        robot_asset: UserAsset,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.SetRobotAssetByRobotKey"
+            ),
+            content=str(
+                {
+                    "robotKey": self._execution_context.robot_key,
+                    "robotAsset": robot_asset,
+                }
+            ),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )

uipath/_services/buckets_service.py

@@ -0,0 +1,268 @@
+from typing import Any, Dict, Optional, Union
+
+from httpx import request
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._utils import Endpoint, RequestSpec, infer_bindings
+from ._base_service import BaseService
+
+
+class BucketsService(FolderContext, BaseService):
+    """Service for managing UiPath storage buckets.
+
+    Buckets are cloud storage containers that can be used to store and manage files
+    used by automation processes.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def download(
+        self,
+        bucket_key: str,
+        blob_file_path: str,
+        destination_path: str,
+    ) -> None:
+        """Download a file from a bucket.
+
+        Args:
+            bucket_key: The key of the bucket
+            blob_file_path: The path to the file in the bucket
+            destination_path: The local path where the file will be saved
+        """
+        bucket = self.retrieve_by_key(bucket_key)
+        bucket_id = bucket["Id"]
+
+        endpoint = Endpoint(
+            f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetReadUri"
+        )
+
+        result = self.request("GET", endpoint, params={"path": blob_file_path}).json()
+        read_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        with open(destination_path, "wb") as file:
+            # the self.request adds auth bearer token
+            if result["RequiresAuth"]:
+                file_content = self.request("GET", read_uri, headers=headers).content
+            else:
+                file_content = request("GET", read_uri, headers=headers).content
+            file.write(file_content)
+
+    def upload(
+        self,
+        *,
+        bucket_key: Optional[str] = None,
+        bucket_name: Optional[str] = None,
+        blob_file_path: str,
+        content_type: str,
+        source_path: str,
+    ) -> None:
+        """Upload a file to a bucket.
+
+        Args:
+            bucket_key: The key of the bucket
+            bucket_name: The name of the bucket
+            blob_file_path: The path where the file will be stored in the bucket
+            content_type: The MIME type of the file
+            source_path: The local path of the file to upload
+        """
+        if bucket_key:
+            bucket = self.retrieve_by_key(bucket_key)
+        elif bucket_name:
+            bucket = self.retrieve(bucket_name)
+        else:
+            raise ValueError("Must specify a bucket name or bucket key")
+
+        bucket_id = bucket["Id"]
+
+        endpoint = Endpoint(
+            f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetWriteUri"
+        )
+
+        result = self.request(
+            "GET",
+            endpoint,
+            params={"path": blob_file_path, "contentType": content_type},
+        ).json()
+        write_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        with open(source_path, "rb") as file:
+            if result["RequiresAuth"]:
+                self.request("PUT", write_uri, headers=headers, files={"file": file})
+            else:
+                request("PUT", write_uri, headers=headers, files={"file": file})
+
+    def upload_from_memory(
+        self,
+        *,
+        bucket_key: Optional[str] = None,
+        bucket_name: Optional[str] = None,
+        blob_file_path: str,
+        content_type: str,
+        content: Union[str, bytes],
+    ) -> None:
+        """Upload content from memory to a bucket.
+
+        Args:
+            bucket_key: The key of the bucket
+            bucket_name: The name of the bucket
+            blob_file_path: The path where the content will be stored in the bucket
+            content_type: The MIME type of the content
+            content: The content to upload (string or bytes)
+        """
+        if bucket_key:
+            bucket = self.retrieve_by_key(bucket_key)
+        elif bucket_name:
+            bucket = self.retrieve(bucket_name)
+        else:
+            raise ValueError("Must specify a bucket name or bucket key")
+
+        bucket_id = bucket["Id"]
+
+        endpoint = Endpoint(
+            f"/orchestrator_/odata/Buckets({bucket_id})/UiPath.Server.Configuration.OData.GetWriteUri"
+        )
+
+        result = self.request(
+            "GET",
+            endpoint,
+            params={"path": blob_file_path, "contentType": content_type},
+        ).json()
+        write_uri = result["Uri"]
+
+        headers = {
+            key: value
+            for key, value in zip(
+                result["Headers"]["Keys"], result["Headers"]["Values"], strict=False
+            )
+        }
+
+        # Convert string to bytes if needed
+        if isinstance(content, str):
+            content = content.encode("utf-8")
+
+        if result["RequiresAuth"]:
+            self.request("PUT", write_uri, headers=headers, content=content)
+        else:
+            request("PUT", write_uri, headers=headers, content=content)
+
+    @infer_bindings()
+    def retrieve(self, name: str) -> Any:
+        """Retrieve bucket information by its name.
+
+        Args:
+            name (str): The name of the bucket to retrieve.
+
+        Returns:
+            Response: The HTTP response containing the bucket details, including
+                its ID, name, and configuration.
+        """
+        spec = self._retrieve_spec(name)
+
+        try:
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+            )
+        except Exception as e:
+            raise Exception(f"Bucket with name {name} not found") from e
+
+        return response.json()["value"][0]
+
+    @infer_bindings()
+    async def retrieve_async(self, name: str) -> Any:
+        """Asynchronously retrieve bucket information by its name.
+
+        Args:
+            name (str): The name of the bucket to retrieve.
+
+        Returns:
+            Response: The HTTP response containing the bucket details, including
+                its ID, name, and configuration.
+        """
+        spec = self._retrieve_spec(name)
+
+        try:
+            response = await self.request_async(
+                spec.method,
+                url=spec.endpoint,
+                params=spec.params,
+            )
+        except Exception as e:
+            raise Exception(f"Bucket with name {name} not found") from e
+
+        return response.json()["value"][0]
+
+    def retrieve_by_key(self, key: str) -> Any:
+        """Retrieve bucket information by its key.
+
+        Args:
+            key (str): The key of the bucket
+
+        Returns:
+            Response: The HTTP response containing the bucket details, including
+                its ID, name, and configuration.
+        """
+        spec = self._retrieve_by_key_spec(key)
+
+        try:
+            response = self.request(spec.method, url=spec.endpoint)
+        except Exception as e:
+            raise Exception(f"Bucket with key {key} not found") from e
+
+        return response.json()
+
+    async def retrieve_by_key_async(self, key: str) -> Any:
+        """Asynchronously retrieve bucket information by its key.
+
+        Args:
+            key (str): The key of the bucket
+
+        Returns:
+            Response: The HTTP response containing the bucket details, including
+                its ID, name, and configuration.
+        """
+        spec = self._retrieve_by_key_spec(key)
+
+        try:
+            response = await self.request_async(spec.method, url=spec.endpoint)
+        except Exception as e:
+            raise Exception(f"Bucket with key {key} not found") from e
+
+        return response.json()
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _retrieve_spec(self, name: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/orchestrator_/odata/Buckets"),
+            params={"$filter": f"Name eq '{name}'", "$top": 1},
+        )
+
+    def _retrieve_by_key_spec(self, key: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Buckets/UiPath.Server.Configuration.OData.GetByKey(identifier={key})"
+            ),
+        )

uipath/_services/connections_service.py

@@ -0,0 +1,185 @@
+import importlib
+import logging
+from typing import Any, Dict, Protocol, TypeVar, Union
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._models import Connection, ConnectionToken
+from .._utils import Endpoint, RequestSpec
+from .._utils.constants import ENTRYPOINT
+from ._base_service import BaseService
+
+T_co = TypeVar("T_co", covariant=True)
+
+logger: logging.Logger = logging.getLogger("uipath")
+
+
+class PluginNotFoundError(AttributeError):
+    """Raised when a plugin is not installed or failed to load."""
+
+    pass
+
+
+class Connector(Protocol[T_co]):
+    def __call__(self, *, client: Any, instance_id: Union[str, int]) -> T_co: ...
+
+
+class ConnectionsService(BaseService):
+    """Service for managing UiPath external service connections.
+
+    This service provides methods to retrieve and manage connections to external
+    systems and services that your automation processes interact with. It supports
+    both direct connection information retrieval and secure token management.
+
+    The service implements a flexible connector system that allows for type-safe
+    instantiation of specific service connectors, making it easier to interact
+    with different types of external services.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+        self._plugins: Dict[str, Any] = {}
+        self._plugins_loaded = False
+        self._load_connectors()
+
+    def __call__(self, connector: Connector[T_co], key: str) -> T_co:
+        connection = self.retrieve(key)
+        return connector(client=self.client, instance_id=connection.element_instance_id)
+
+    def __getattr__(self, name: str) -> Any:
+        """Get a plugin by name.
+
+        Args:
+            name: The name of the plugin to get
+
+        Returns:
+            The plugin instance
+
+        Raises:
+            PluginNotFoundError: If the plugin is not installed
+            ImportError: If the plugin fails to load
+        """
+        if not self._plugins_loaded:
+            self._load_connectors()
+
+        if name in self._plugins:
+            return self._plugins[name]
+
+        try:
+            plugin: Any = getattr(self.client, name)
+            self._plugins[name] = plugin
+            return plugin
+        except AttributeError as e:
+            raise PluginNotFoundError(f"Plugin '{name}' is not installed") from e
+
+    def retrieve(self, key: str) -> Connection:
+        """Retrieve connection details by its key.
+
+        This method fetches the configuration and metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            key (str): The unique identifier of the connection to retrieve.
+
+        Returns:
+            Connection: The connection details, including configuration parameters
+                and authentication information.
+        """
+        spec = self._retrieve_spec(key)
+        response = self.request(spec.method, url=spec.endpoint)
+        return Connection.model_validate(response.json())
+
+    async def retrieve_async(self, key: str) -> Connection:
+        """Asynchronously retrieve connection details by its key.
+
+        This method fetches the configuration and metadata for a connection,
+        which can be used to establish communication with an external service.
+
+        Args:
+            key (str): The unique identifier of the connection to retrieve.
+
+        Returns:
+            Connection: The connection details, including configuration parameters
+                and authentication information.
+        """
+        spec = self._retrieve_spec(key)
+        response = await self.request_async(spec.method, url=spec.endpoint)
+        return Connection.model_validate(response.json())
+
+    def retrieve_token(self, key: str) -> ConnectionToken:
+        """Retrieve an authentication token for a connection.
+
+        This method obtains a fresh authentication token that can be used to
+        communicate with the external service. This is particularly useful for
+        services that use token-based authentication.
+
+        Args:
+            key (str): The unique identifier of the connection.
+
+        Returns:
+            ConnectionToken: The authentication token details, including the token
+                value and any associated metadata.
+        """
+        spec = self._retrieve_token_spec(key)
+        response = self.request(spec.method, url=spec.endpoint, params=spec.params)
+        return ConnectionToken.model_validate(response.json())
+
+    async def retrieve_token_async(self, key: str) -> ConnectionToken:
+        """Asynchronously retrieve an authentication token for a connection.
+
+        This method obtains a fresh authentication token that can be used to
+        communicate with the external service. This is particularly useful for
+        services that use token-based authentication.
+
+        Args:
+            key (str): The unique identifier of the connection.
+
+        Returns:
+            ConnectionToken: The authentication token details, including the token
+                value and any associated metadata.
+        """
+        spec = self._retrieve_token_spec(key)
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params
+        )
+        return ConnectionToken.model_validate(response.json())
+
+    def _retrieve_spec(self, key: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}"),
+        )
+
+    def _retrieve_token_spec(self, key: str) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}/token"),
+            params={"type": "direct"},
+        )
+
+    def _load_connectors(self) -> None:
+        """Load all available connector plugins.
+
+        Raises:
+            ImportError: If a plugin fails to load
+        """
+        try:
+            entry_points: Any = importlib.metadata.entry_points()
+            if hasattr(entry_points, "select"):
+                connectors = list(entry_points.select(group=ENTRYPOINT))
+            else:
+                connectors = list(entry_points.get(ENTRYPOINT, []))
+
+            for entry_point in connectors:
+                try:
+                    register_func = entry_point.load()
+                    register_func(self)
+                except Exception as e:
+                    logger.error(
+                        f"[ERROR] Failed to load plugin {entry_point.name}: {str(e)}"
+                    )
+
+            self._plugins_loaded = True
+        except Exception as e:
+            self._plugins_loaded = False
+            raise ImportError(f"Failed to load plugins: {str(e)}") from e