uipath 2.1.49__py3-none-any.whl → 2.1.51__py3-none-any.whl

uipath/_services/__init__.py

@@ -5,6 +5,7 @@ from .attachments_service import AttachmentsService
 from .buckets_service import BucketsService
 from .connections_service import ConnectionsService
 from .context_grounding_service import ContextGroundingService
+from .entities_service import EntitiesService
 from .folder_service import FolderService
 from .jobs_service import JobsService
 from .llm_gateway_service import UiPathLlmChatService, UiPathOpenAIService
@@ -25,4 +26,5 @@ __all__ = [
     "UiPathOpenAIService",
     "UiPathLlmChatService",
     "FolderService",
+    "EntitiesService",
 ]

uipath/_services/context_grounding_service.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any, List, Optional, Tuple, Union
 
 import httpx
@@ -353,7 +352,7 @@ class ContextGroundingService(FolderContext, BaseService):
         response = self.request(
             spec.method,
             spec.endpoint,
-            content=spec.content,
+            json=spec.json,
         )
 
         return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
@@ -403,7 +402,7 @@ class ContextGroundingService(FolderContext, BaseService):
         response = await self.request_async(
             spec.method,
             spec.endpoint,
-            content=spec.content,
+            json=spec.json,
         )
 
         return TypeAdapter(List[ContextGroundingQueryResponse]).validate_python(
@@ -592,21 +591,19 @@ class ContextGroundingService(FolderContext, BaseService):
         return RequestSpec(
             method="POST",
             endpoint=Endpoint("/ecs_/v2/indexes/create"),
-            content=json.dumps(
-                {
-                    "name": name,
-                    "description": description,
-                    "dataSource": {
-                        "@odata.type": ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
-                        "folder": storage_bucket_folder_path,
-                        "bucketName": storage_bucket_name,
-                        "fileNameGlob": file_name_glob
-                        if file_name_glob is not None
-                        else "*",
-                        "directoryPath": "/",
-                    },
-                }
-            ),
+            json={
+                "name": name,
+                "description": description,
+                "dataSource": {
+                    "@odata.type": ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
+                    "folder": storage_bucket_folder_path,
+                    "bucketName": storage_bucket_name,
+                    "fileNameGlob": file_name_glob
+                    if file_name_glob is not None
+                    else "*",
+                    "directoryPath": "/",
+                },
+            },
             headers={
                 **header_folder(folder_key, None),
             },
@@ -657,12 +654,10 @@ class ContextGroundingService(FolderContext, BaseService):
         return RequestSpec(
             method="POST",
             endpoint=Endpoint("/ecs_/v1/search"),
-            content=json.dumps(
-                {
-                    "query": {"query": query, "numberOfResults": number_of_results},
-                    "schema": {"name": name},
-                }
-            ),
+            json={
+                "query": {"query": query, "numberOfResults": number_of_results},
+                "schema": {"name": name},
+            },
             headers={
                 **header_folder(folder_key, None),
             },

uipath/_services/entities_service.py

@@ -0,0 +1,383 @@
+from typing import Any, List, Optional, Type
+
+from httpx import Response
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._utils import Endpoint, RequestSpec
+from ..models.entities import (
+    Entity,
+    EntityRecord,
+    EntityRecordsBatchResponse,
+)
+from ..tracing import traced
+from ._base_service import BaseService
+
+
+class EntitiesService(BaseService):
+    """Service for managing UiPath Data Service entities.
+
+    Entities are database tables in UiPath Data Service that can store
+    structured data for automation processes.
+    """
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced(name="entity_retrieve", run_type="uipath")
+    def retrieve(self, entity_key: str) -> Entity:
+        """Retrieve an entity by its key.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+
+        Returns:
+            Entity: The entity with all its metadata and field definitions.
+        """
+        spec = self._retrieve_spec(entity_key)
+        response = self.request(spec.method, spec.endpoint)
+
+        return Entity.model_validate(response.json())
+
+    @traced(name="entity_retrieve", run_type="uipath")
+    async def retrieve_async(self, entity_key: str) -> Entity:
+        """Asynchronously retrieve an entity by its key.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+
+        Returns:
+            Entity: The entity with all its metadata and field definitions.
+        """
+        spec = self._retrieve_spec(entity_key)
+
+        response = await self.request_async(spec.method, spec.endpoint)
+
+        return Entity.model_validate(response.json())
+
+    @traced(name="list_entities", run_type="uipath")
+    def list_entities(self) -> List[Entity]:
+        """List all entities in the Data Service.
+
+        Returns:
+            List[Entity]: A list of all entities with their metadata and field definitions.
+        """
+        spec = self._list_entities_spec()
+        response = self.request(spec.method, spec.endpoint)
+
+        entities_data = response.json()
+        return [Entity.model_validate(entity) for entity in entities_data]
+
+    @traced(name="list_entities", run_type="uipath")
+    async def list_entities_async(self) -> List[Entity]:
+        """Asynchronously list all entities in the Data Service.
+
+        Returns:
+            List[Entity]: A list of all entities with their metadata and field definitions.
+        """
+        spec = self._list_entities_spec()
+        response = await self.request_async(spec.method, spec.endpoint)
+
+        entities_data = response.json()
+        return [Entity.model_validate(entity) for entity in entities_data]
+
+    @traced(name="entity_list_records", run_type="uipath")
+    def list_records(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,  # Optional schema
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[EntityRecord]:
+        """List records from an entity with optional pagination and schema validation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            schema (Optional[Type[Any]]): Optional schema class for additional validation of records.
+            start (Optional[int]): Starting index for pagination.
+            limit (Optional[int]): Maximum number of records to return.
+
+        Returns:
+            List[EntityRecord]: A list of entity records.
+        """
+        # Example method to generate the API request specification (mocked here)
+        spec = self._list_records_spec(entity_key, start, limit)
+
+        # Make the HTTP request (assumes self.request exists)
+        response = self.request(spec.method, spec.endpoint, params=spec.params)
+
+        # Parse the response JSON and extract the "value" field
+        records_data = response.json().get("value", [])
+
+        # Validate and wrap records
+        return [
+            EntityRecord.from_data(data=record, model=schema) for record in records_data
+        ]
+
+    @traced(name="entity_list_records", run_type="uipath")
+    async def list_records_async(
+        self,
+        entity_key: str,
+        schema: Optional[Type[Any]] = None,  # Optional schema
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> List[EntityRecord]:
+        """Asynchronously list records from an entity with optional pagination and schema validation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            schema (Optional[Type[Any]]): Optional schema class for additional validation of records.
+            start (Optional[int]): Starting index for pagination.
+            limit (Optional[int]): Maximum number of records to return.
+
+        Returns:
+            List[EntityRecord]: A list of entity records.
+        """
+        spec = self._list_records_spec(entity_key, start, limit)
+
+        # Make the HTTP request (assumes self.request exists)
+        response = await self.request_async(
+            spec.method, spec.endpoint, params=spec.params
+        )
+
+        # Parse the response JSON and extract the "value" field
+        records_data = response.json().get("value", [])
+
+        # Validate and wrap records
+        return [
+            EntityRecord.from_data(data=record, model=schema) for record in records_data
+        ]
+
+    @traced(name="entity_record_insert_batch", run_type="uipath")
+    def insert_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Insert multiple records into an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to insert.
+            schema (Optional[Type[Any]]): Optional schema class for validation of records.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        spec = self._insert_batch_spec(entity_key, records)
+        response = self.request(spec.method, spec.endpoint, json=spec.json)
+
+        return self.validate_entity_batch(response, schema)
+
+    @traced(name="entity_record_insert_batch", run_type="uipath")
+    async def insert_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously insert multiple records into an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to insert.
+            schema (Optional[Type[Any]]): Optional schema class for validation of records.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        spec = self._insert_batch_spec(entity_key, records)
+        response = await self.request_async(spec.method, spec.endpoint, json=spec.json)
+
+        return self.validate_entity_batch(response, schema)
+
+    @traced(name="entity_record_update_batch", run_type="uipath")
+    def update_records(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Update multiple records in an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to update.
+            schema (Optional[Type[Any]]): Optional schema class for validation of records.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        valid_records = [
+            EntityRecord.from_data(data=record.model_dump(by_alias=True), model=schema)
+            for record in records
+        ]
+
+        spec = self._update_batch_spec(entity_key, valid_records)
+        response = self.request(spec.method, spec.endpoint, json=spec.json)
+
+        return self.validate_entity_batch(response, schema)
+
+    @traced(name="entity_record_update_batch", run_type="uipath")
+    async def update_records_async(
+        self,
+        entity_key: str,
+        records: List[Any],
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously update multiple records in an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            records (List[Any]): List of records to update.
+            schema (Optional[Type[Any]]): Optional schema class for validation of records.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        valid_records = [
+            EntityRecord.from_data(data=record.model_dump(by_alias=True), model=schema)
+            for record in records
+        ]
+
+        spec = self._update_batch_spec(entity_key, valid_records)
+        response = await self.request_async(spec.method, spec.endpoint, json=spec.json)
+
+        return self.validate_entity_batch(response, schema)
+
+    @traced(name="entity_record_delete_batch", run_type="uipath")
+    def delete_records(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+    ) -> EntityRecordsBatchResponse:
+        """Delete multiple records from an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_ids (List[str]): List of record IDs to delete.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        spec = self._delete_batch_spec(entity_key, record_ids)
+        response = self.request(spec.method, spec.endpoint, json=spec.json)
+
+        delete_records_response = EntityRecordsBatchResponse.model_validate(
+            response.json()
+        )
+
+        return delete_records_response
+
+    @traced(name="entity_record_delete_batch", run_type="uipath")
+    async def delete_records_async(
+        self,
+        entity_key: str,
+        record_ids: List[str],
+    ) -> EntityRecordsBatchResponse:
+        """Asynchronously delete multiple records from an entity in a single batch operation.
+
+        Args:
+            entity_key (str): The unique key/identifier of the entity.
+            record_ids (List[str]): List of record IDs to delete.
+
+        Returns:
+            EntityRecordsBatchResponse: Response containing successful and failed record operations.
+        """
+        spec = self._delete_batch_spec(entity_key, record_ids)
+        response = await self.request_async(spec.method, spec.endpoint, json=spec.json)
+
+        delete_records_response = EntityRecordsBatchResponse.model_validate(
+            response.json()
+        )
+
+        return delete_records_response
+
+    def validate_entity_batch(
+        self,
+        batch_response: Response,
+        schema: Optional[Type[Any]] = None,
+    ) -> EntityRecordsBatchResponse:
+        # Validate the response format
+        insert_records_response = EntityRecordsBatchResponse.model_validate(
+            batch_response.json()
+        )
+
+        # Validate individual records
+        validated_successful_records = [
+            EntityRecord.from_data(
+                data=successful_record.model_dump(by_alias=True), model=schema
+            )
+            for successful_record in insert_records_response.success_records
+        ]
+
+        validated_failed_records = [
+            EntityRecord.from_data(
+                data=failed_record.model_dump(by_alias=True), model=schema
+            )
+            for failed_record in insert_records_response.failure_records
+        ]
+
+        return EntityRecordsBatchResponse(
+            success_records=validated_successful_records,
+            failure_records=validated_failed_records,
+        )
+
+    def _retrieve_spec(
+        self,
+        entity_key: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"datafabric_/api/Entity/{entity_key}"),
+        )
+
+    def _list_entities_spec(self) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("datafabric_/api/Entity"),
+        )
+
+    def _list_records_spec(
+        self,
+        entity_key: str,
+        start: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/read"
+            ),
+            params=({"start": start, "limit": limit}),
+        )
+
+    def _insert_batch_spec(self, entity_key: str, records: List[Any]) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/insert-batch"
+            ),
+            json=[record.__dict__ for record in records],
+        )
+
+    def _update_batch_spec(
+        self, entity_key: str, records: List[EntityRecord]
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/update-batch"
+            ),
+            json=[record.model_dump(by_alias=True) for record in records],
+        )
+
+    def _delete_batch_spec(self, entity_key: str, record_ids: List[str]) -> RequestSpec:
+        return RequestSpec(
+            method="POST",
+            endpoint=Endpoint(
+                f"datafabric_/api/EntityService/entity/{entity_key}/delete-batch"
+            ),
+            json=record_ids,
+        )

uipath/_services/jobs_service.py

@@ -1,4 +1,3 @@
-import json
 import os
 import shutil
 import tempfile
@@ -81,7 +80,7 @@ class JobsService(FolderContext, BaseService):
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
-            content=spec.content,
+            json=spec.json,
         )
 
     async def resume_async(
@@ -142,7 +141,7 @@ class JobsService(FolderContext, BaseService):
             spec.method,
             url=spec.endpoint,
             headers=spec.headers,
-            content=spec.content,
+            json=spec.json,
         )
 
     @property
@@ -412,7 +411,7 @@ class JobsService(FolderContext, BaseService):
             endpoint=Endpoint(
                 f"/orchestrator_/api/JobTriggers/DeliverPayload/{inbox_id}"
             ),
-            content=json.dumps({"payload": payload}),
+            json={"payload": payload},
             headers={
                 **header_folder(folder_key, folder_path),
             },

uipath/_services/llm_gateway_service.py

@@ -16,7 +16,6 @@ Classes:
     UiPathLlmChatService: Service using UiPath's normalized API format
 """
 
-import json
 from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
@@ -195,7 +194,7 @@ class UiPathOpenAIService(BaseService):
         response = await self.request_async(
             "POST",
             endpoint,
-            content=json.dumps({"input": input}),
+            json={"input": input},
             params={"api-version": API_VERSION},
             headers=DEFAULT_LLM_HEADERS,
         )
@@ -322,7 +321,7 @@ class UiPathOpenAIService(BaseService):
         response = await self.request_async(
             "POST",
             endpoint,
-            content=json.dumps(request_body),
+            json=request_body,
             params={"api-version": API_VERSION},
             headers=DEFAULT_LLM_HEADERS,
         )
@@ -534,7 +533,7 @@ class UiPathLlmChatService(BaseService):
         response = await self.request_async(
             "POST",
             endpoint,
-            content=json.dumps(request_body),
+            json=request_body,
             params={"api-version": NORMALIZED_API_VERSION},
             headers=headers,
         )

uipath/_uipath.py

@@ -13,6 +13,7 @@ from ._services import (
     BucketsService,
     ConnectionsService,
     ContextGroundingService,
+    EntitiesService,
     FolderService,
     JobsService,
     ProcessesService,
@@ -134,3 +135,7 @@ class UiPath:
     @property
     def llm(self) -> UiPathLlmChatService:
         return UiPathLlmChatService(self._config, self._execution_context)
+
+    @property
+    def entities(self) -> EntitiesService:
+        return EntitiesService(self._config, self._execution_context)