uipath 2.0.0.dev3__py3-none-any.whl → 2.0.1__py3-none-any.whl

uipath/_services/processes_service.py

@@ -0,0 +1,168 @@
+import json
+import os
+from typing import Any, Dict, Optional
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._models.job import Job
+from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
+from .._utils.constants import ENV_JOB_ID, HEADER_JOB_KEY
+from ._base_service import BaseService
+
+
+class ProcessesService(FolderContext, BaseService):
+    """Service for managing and executing UiPath automation processes.
+
+    Processes (also known as automations or workflows) are the core units of
+    automation in UiPath, representing sequences of activities that perform
+    specific business tasks.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def invoke(
+        self,
+        name: str,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Job:
+        """Start execution of a process by its name.
+
+        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
+
+        Args:
+            name (str): The name of the process to execute.
+            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
+            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:
+            Job: The job execution details.
+
+        Examples:
+            ```python
+            from uipath import UiPath
+
+            client = UiPath()
+
+            client.processes.invoke(name="MyProcess")
+            ```
+
+            ```python
+            # if you want to execute the process in a specific folder
+            # another one than the one set in the SDK config
+            from uipath import UiPath
+
+            client = UiPath()
+
+            client.processes.invoke(name="MyProcess", folder_path="my-folder-key")
+            ```
+        """
+        spec = self._invoke_spec(
+            name,
+            input_arguments=input_arguments,
+            folder_key=folder_key,
+            folder_path=folder_path,
+        )
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return Job.model_validate(response.json()["value"][0])
+
+    @infer_bindings()
+    async def invoke_async(
+        self,
+        name: str,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> Job:
+        """Asynchronously start execution of a process by its name.
+
+        Related Activity: [Invoke Process](https://docs.uipath.com/activities/other/latest/workflow/invoke-process)
+
+        Args:
+            name (str): The name of the process to execute.
+            input_arguments (Optional[Dict[str, Any]]): The input arguments to pass to the process.
+            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:
+            Job: The job execution details.
+
+        Examples:
+            ```python
+            import asyncio
+
+            from uipath import UiPath
+
+            sdk = UiPath()
+
+            async def main():
+                job = await sdk.processes.invoke_async("testAppAction")
+                print(job)
+
+            asyncio.run(main())
+            ```
+        """
+        spec = self._invoke_spec(
+            name,
+            input_arguments=input_arguments,
+            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 Job.model_validate(response.json()["value"][0])
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _invoke_spec(
+        self,
+        name: str,
+        input_arguments: Optional[Dict[str, Any]] = None,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> RequestSpec:
+        request_scope = RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+            ),
+            content=str(
+                {
+                    "startInfo": {
+                        "ReleaseName": name,
+                        "InputArguments": json.dumps(input_arguments)
+                        if input_arguments
+                        else "{}",
+                    }
+                }
+            ),
+            headers={
+                **header_folder(folder_key, folder_path),
+            },
+        )
+        job_key = os.environ.get(ENV_JOB_ID, None)
+        if job_key:
+            request_scope.headers[HEADER_JOB_KEY] = job_key
+        return request_scope

uipath/_services/queues_service.py

@@ -0,0 +1,314 @@
+from typing import Any, Dict, List, Union
+
+from httpx import Response
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._models import CommitType, QueueItem, TransactionItem, TransactionItemResult
+from .._utils import Endpoint, RequestSpec
+from ._base_service import BaseService
+
+
+class QueuesService(FolderContext, BaseService):
+    """Service for managing UiPath queues and queue items.
+
+    Queues are a fundamental component of UiPath automation that enable distributed
+    and scalable processing of work items.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    def list_items(self) -> Response:
+        """Retrieves a list of queue items from the Orchestrator.
+
+        Returns:
+            Response: HTTP response containing the list of queue items.
+        """
+        spec = self._list_items_spec()
+        return self.request(spec.method, url=spec.endpoint)
+
+    async def list_items_async(self) -> Response:
+        """Asynchronously retrieves a list of queue items from the Orchestrator.
+
+        Returns:
+            Response: HTTP response containing the list of queue items.
+        """
+        spec = self._list_items_spec()
+        return await self.request_async(spec.method, url=spec.endpoint)
+
+    def create_item(self, item: Union[Dict[str, Any], QueueItem]) -> Response:
+        """Creates a new queue item in the Orchestrator.
+
+        Args:
+            item: Queue item data, either as a dictionary or QueueItem instance.
+
+        Returns:
+            Response: HTTP response containing the created queue item details.
+
+        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
+        """
+        spec = self._create_item_spec(item)
+        return self.request(spec.method, url=spec.endpoint, json=spec.json)
+
+    async def create_item_async(
+        self, item: Union[Dict[str, Any], QueueItem]
+    ) -> Response:
+        """Asynchronously creates a new queue item in the Orchestrator.
+
+        Args:
+            item: Queue item data, either as a dictionary or QueueItem instance.
+
+        Returns:
+            Response: HTTP response containing the created queue item details.
+
+        Related Activity: [Add Queue Item](https://docs.uipath.com/ACTIVITIES/other/latest/workflow/add-queue-item)
+        """
+        spec = self._create_item_spec(item)
+        return await self.request_async(spec.method, url=spec.endpoint, json=spec.json)
+
+    def create_items(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+    ) -> Response:
+        """Creates multiple queue items in bulk.
+
+        Args:
+            items: List of queue items to create, each either a dictionary or QueueItem instance.
+            queue_name: Name of the target queue.
+            commit_type: Type of commit operation to use for the bulk operation.
+
+        Returns:
+            Response: HTTP response containing the bulk operation result.
+        """
+        spec = self._create_items_spec(items, queue_name, commit_type)
+        return self.request(spec.method, url=spec.endpoint, json=spec.json)
+
+    async def create_items_async(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+    ) -> Response:
+        """Asynchronously creates multiple queue items in bulk.
+
+        Args:
+            items: List of queue items to create, each either a dictionary or QueueItem instance.
+            queue_name: Name of the target queue.
+            commit_type: Type of commit operation to use for the bulk operation.
+
+        Returns:
+            Response: HTTP response containing the bulk operation result.
+        """
+        spec = self._create_items_spec(items, queue_name, commit_type)
+        return await self.request_async(spec.method, url=spec.endpoint, json=spec.json)
+
+    def create_transaction_item(
+        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
+    ) -> Response:
+        """Creates a new transaction item in a queue.
+
+        Args:
+            item: Transaction item data, either as a dictionary or TransactionItem instance.
+            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
+
+        Returns:
+            Response: HTTP response containing the transaction item details.
+        """
+        spec = self._create_transaction_item_spec(item, no_robot)
+        return self.request(spec.method, url=spec.endpoint, json=spec.json)
+
+    async def create_transaction_item_async(
+        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
+    ) -> Response:
+        """Asynchronously creates a new transaction item in a queue.
+
+        Args:
+            item: Transaction item data, either as a dictionary or TransactionItem instance.
+            no_robot: If True, the transaction will not be associated with a robot. Defaults to False.
+
+        Returns:
+            Response: HTTP response containing the transaction item details.
+        """
+        spec = self._create_transaction_item_spec(item, no_robot)
+        return await self.request_async(spec.method, url=spec.endpoint, json=spec.json)
+
+    def update_progress_of_transaction_item(
+        self, transaction_key: str, progress: str
+    ) -> Response:
+        """Updates the progress of a transaction item.
+
+        Args:
+            transaction_key: Unique identifier of the transaction.
+            progress: Progress message to set.
+
+        Returns:
+            Response: HTTP response confirming the progress update.
+
+        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
+        """
+        spec = self._update_progress_of_transaction_item_spec(transaction_key, progress)
+        return self.request(spec.method, url=spec.endpoint, json=spec.json)
+
+    async def update_progress_of_transaction_item_async(
+        self, transaction_key: str, progress: str
+    ) -> Response:
+        """Asynchronously updates the progress of a transaction item.
+
+        Args:
+            transaction_key: Unique identifier of the transaction.
+            progress: Progress message to set.
+
+        Returns:
+            Response: HTTP response confirming the progress update.
+
+        Related Activity: [Set Transaction Progress](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-progress)
+        """
+        spec = self._update_progress_of_transaction_item_spec(transaction_key, progress)
+        return await self.request_async(spec.method, url=spec.endpoint, json=spec.json)
+
+    def complete_transaction_item(
+        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
+    ) -> Response:
+        """Completes a transaction item with the specified result.
+
+        Args:
+            transaction_key: Unique identifier of the transaction to complete.
+            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
+
+        Returns:
+            Response: HTTP response confirming the transaction completion.
+
+        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
+        """
+        spec = self._complete_transaction_item_spec(transaction_key, result)
+        return self.request(spec.method, url=spec.endpoint, json=spec.json)
+
+    async def complete_transaction_item_async(
+        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
+    ) -> Response:
+        """Asynchronously completes a transaction item with the specified result.
+
+        Args:
+            transaction_key: Unique identifier of the transaction to complete.
+            result: Result data for the transaction, either as a dictionary or TransactionItemResult instance.
+
+        Returns:
+            Response: HTTP response confirming the transaction completion.
+
+        Related Activity: [Set Transaction Status](https://docs.uipath.com/activities/other/latest/workflow/set-transaction-status)
+        """
+        spec = self._complete_transaction_item_spec(transaction_key, result)
+        return await self.request_async(spec.method, url=spec.endpoint, json=spec.json)
+
+    @property
+    def custom_headers(self) -> Dict[str, str]:
+        return self.folder_headers
+
+    def _list_items_spec(self) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.GetQueueItems"
+            ),
+        )
+
+    def _create_item_spec(self, item: Union[Dict[str, Any], QueueItem]) -> RequestSpec:
+        if isinstance(item, dict):
+            queue_item = QueueItem(**item)
+        elif isinstance(item, QueueItem):
+            queue_item = item
+
+        json_payload = {
+            "itemData": queue_item.model_dump(exclude_unset=True, by_alias=True)
+        }
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.AddQueueItem"
+            ),
+            json=json_payload,
+        )
+
+    def _create_items_spec(
+        self,
+        items: List[Union[Dict[str, Any], QueueItem]],
+        queue_name: str,
+        commit_type: CommitType,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.BulkAddQueueItems"
+            ),
+            json={
+                "queueName": queue_name,
+                "commitType": commit_type.value,
+                "queueItems": [
+                    item.model_dump(exclude_unset=True, by_alias=True)
+                    if isinstance(item, QueueItem)
+                    else QueueItem(**item).model_dump(exclude_unset=True, by_alias=True)
+                    for item in items
+                ],
+            },
+        )
+
+    def _create_transaction_item_spec(
+        self, item: Union[Dict[str, Any], TransactionItem], no_robot: bool = False
+    ) -> RequestSpec:
+        if isinstance(item, dict):
+            transaction_item = TransactionItem(**item)
+        elif isinstance(item, TransactionItem):
+            transaction_item = item
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                "/orchestrator_/odata/Queues/UiPathODataSvc.StartTransaction"
+            ),
+            json={
+                "transactionData": {
+                    **transaction_item.model_dump(exclude_unset=True, by_alias=True),
+                    **(
+                        {"RobotIdentifier": self._execution_context.robot_key}
+                        if not no_robot
+                        else {}
+                    ),
+                }
+            },
+        )
+
+    def _update_progress_of_transaction_item_spec(
+        self, transaction_key: str, progress: str
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/QueueItems({transaction_key})/UiPathODataSvc.SetTransactionProgress"
+            ),
+            json={"progress": progress},
+        )
+
+    def _complete_transaction_item_spec(
+        self, transaction_key: str, result: Union[Dict[str, Any], TransactionItemResult]
+    ) -> RequestSpec:
+        if isinstance(result, dict):
+            transaction_result = TransactionItemResult(**result)
+        elif isinstance(result, TransactionItemResult):
+            transaction_result = result
+
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"/orchestrator_/odata/Queues({transaction_key})/UiPathODataSvc.SetTransactionResult"
+            ),
+            json={
+                "transactionResult": transaction_result.model_dump(
+                    exclude_unset=True, by_alias=True
+                )
+            },
+        )

uipath/_uipath.py

@@ -0,0 +1,98 @@
+from os import environ as env
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from ._config import Config
+from ._execution_context import ExecutionContext
+from ._services import (
+    ActionsService,
+    ApiClient,
+    AssetsService,
+    BucketsService,
+    ConnectionsService,
+    ContextGroundingService,
+    FolderService,
+    JobsService,
+    ProcessesService,
+    QueuesService,
+)
+from ._utils import setup_logging
+from ._utils.constants import (
+    ENV_BASE_URL,
+    ENV_UIPATH_ACCESS_TOKEN,
+    ENV_UNATTENDED_USER_ACCESS_TOKEN,
+)
+
+load_dotenv()
+
+
+class UiPath:
+    def __init__(
+        self,
+        *,
+        base_url: Optional[str] = None,
+        secret: Optional[str] = None,
+        debug: bool = False,
+    ) -> None:
+        base_url_value = base_url or env.get(ENV_BASE_URL)
+        secret_value = (
+            secret
+            or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
+            or env.get(ENV_UIPATH_ACCESS_TOKEN)
+        )
+
+        self._config = Config(
+            base_url=base_url_value,  # type: ignore
+            secret=secret_value,  # type: ignore
+        )
+        self._folders_service: Optional[FolderService] = None
+
+        setup_logging(debug)
+        self._execution_context = ExecutionContext()
+
+    @property
+    def api_client(self) -> ApiClient:
+        return ApiClient(self._config, self._execution_context)
+
+    @property
+    def assets(self) -> AssetsService:
+        return AssetsService(self._config, self._execution_context)
+
+    @property
+    def processes(self) -> ProcessesService:
+        return ProcessesService(self._config, self._execution_context)
+
+    @property
+    def actions(self) -> ActionsService:
+        return ActionsService(self._config, self._execution_context)
+
+    @property
+    def buckets(self) -> BucketsService:
+        return BucketsService(self._config, self._execution_context)
+
+    @property
+    def connections(self) -> ConnectionsService:
+        return ConnectionsService(self._config, self._execution_context)
+
+    @property
+    def context_grounding(self) -> ContextGroundingService:
+        if not self._folders_service:
+            self._folders_service = FolderService(self._config, self._execution_context)
+        return ContextGroundingService(
+            self._config, self._execution_context, self._folders_service
+        )
+
+    @property
+    def queues(self) -> QueuesService:
+        return QueuesService(self._config, self._execution_context)
+
+    @property
+    def jobs(self) -> JobsService:
+        return JobsService(self._config, self._execution_context)
+
+    @property
+    def folders(self) -> FolderService:
+        if not self._folders_service:
+            self._folders_service = FolderService(self._config, self._execution_context)
+        return self._folders_service

uipath/_utils/__init__.py

@@ -0,0 +1,17 @@
+from ._endpoint import Endpoint
+from ._infer_bindings import get_inferred_bindings_names, infer_bindings
+from ._logs import setup_logging
+from ._request_override import header_folder
+from ._request_spec import RequestSpec
+from ._user_agent import header_user_agent, user_agent_value
+
+__all__ = [
+    "Endpoint",
+    "setup_logging",
+    "RequestSpec",
+    "header_folder",
+    "get_inferred_bindings_names",
+    "infer_bindings",
+    "header_user_agent",
+    "user_agent_value",
+]

uipath/_utils/_endpoint.py

@@ -0,0 +1,79 @@
+from typing import Any
+
+
+class Endpoint(str):
+    """A string subclass representing a normalized API endpoint path.
+
+    This class ensures consistent endpoint formatting by:
+    - Adding a leading slash if missing
+    - Removing trailing slashes (except for root '/')
+    - Stripping query parameters
+
+    The class supports string formatting for dynamic path parameters.
+
+    Examples:
+        >>> endpoint = Endpoint("/api/v1/users/{id}")
+        >>> endpoint.format(id=123)
+        '/api/v1/users/123'
+
+        >>> endpoint = Endpoint("projects")
+        >>> str(endpoint)
+        '/projects'
+
+    Args:
+        endpoint (str): The endpoint path to normalize. May include format placeholders
+            for dynamic values (e.g. "/users/{id}").
+
+    Raises:
+        ValueError: If format() is called with None or empty string arguments.
+    """
+
+    def __new__(cls, endpoint: str) -> "Endpoint":
+        if not endpoint.startswith("/"):
+            endpoint = f"/{endpoint}"
+
+        if endpoint != "/" and endpoint.endswith("/"):
+            endpoint = endpoint[:-1]
+
+        endpoint = endpoint.split("?")[0]
+
+        return super().__new__(cls, endpoint)
+
+    def format(self, *args: Any, **kwargs: Any) -> str:
+        """Formats the endpoint with the given arguments."""
+        for index, arg in enumerate(args):
+            if not self._is_valid_value(arg):
+                raise ValueError(f"Positional argument `{index}` is `{arg}`.")
+
+        for key, value in kwargs.items():
+            if not self._is_valid_value(value):
+                raise ValueError(f"Keyword argument `{key}` is `{value}`.")
+
+        return super().format(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return f"Endpoint({super().__str__()!r})"
+
+    def _is_valid_value(self, value: Any) -> bool:
+        return value is not None and value != ""
+
+    @property
+    def service(self) -> str:
+        """Extracts and returns the service name from the endpoint path.
+
+        The service name is expected to be the first path segment after the leading slash,
+        with any underscores removed.
+
+        Examples:
+            >>> endpoint = Endpoint("/cloud_/projects")
+            >>> endpoint.service
+            'cloud'
+
+            >>> endpoint = Endpoint("/automation_hub_/assets")
+            >>> endpoint.service
+            'automationhub'
+
+        Returns:
+            str: The service name with underscores removed.
+        """
+        return self.split("/")[1].replace("_", "")