uipath 2.1.48__py3-none-any.whl → 2.1.50__py3-none-any.whl

uipath/_cli/_runtime/_contracts.py

@@ -315,7 +315,7 @@ class UiPathRuntimeContext(BaseModel):
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
 
-    model_config = {"arbitrary_types_allowed": True}
+    model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
     @classmethod
     def with_defaults(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:

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/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/_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)

uipath/models/entities.py

@@ -0,0 +1,286 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
+
+from pydantic import BaseModel, ConfigDict, Field, create_model
+
+
+class ReferenceType(Enum):
+    ManyToOne = "ManyToOne"
+
+
+class FieldDisplayType(Enum):
+    Basic = "Basic"
+    Relationship = "Relationship"
+    File = "File"
+    ChoiceSetSingle = "ChoiceSetSingle"
+    ChoiceSetMultiple = "ChoiceSetMultiple"
+    AutoNumber = "AutoNumber"
+
+
+class DataDirectionType(Enum):
+    ReadOnly = "ReadOnly"
+    ReadAndWrite = "ReadAndWrite"
+
+
+class JoinType(Enum):
+    LeftJoin = "LeftJoin"
+
+
+class EntityType(Enum):
+    Entity = "Entity"
+    ChoiceSet = "ChoiceSet"
+    InternalEntity = "InternalEntity"
+    SystemEntity = "SystemEntity"
+
+
+class EntityFieldMetadata(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+    )
+    type: str
+    required: bool
+    name: str
+
+
+class ExternalConnection(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    connection_id: str = Field(alias="connectionId")
+    element_instance_id: str = Field(alias="elementInstanceId")
+    folder_id: str = Field(alias="folderKey")  # named folderKey in TS SDK
+    connector_id: str = Field(alias="connectorKey")  # named connectorKey in TS SDK
+    connector_name: str = Field(alias="connectorName")
+    connection_name: str = Field(alias="connectionName")
+
+
+class ExternalFieldMapping(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    external_field_name: str = Field(alias="externalFieldName")
+    external_field_display_name: str = Field(alias="externalFieldDisplayName")
+    external_object_id: str = Field(alias="externalObjectId")
+    external_field_type: str = Field(alias="externalFieldType")
+    internal_field_id: str = Field(alias="internalFieldId")
+    direction_type: DataDirectionType = Field(alias="directionType")
+
+
+class FieldDataType(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    name: str
+    length_limit: Optional[int] = Field(default=None, alias="LengthLimit")
+    max_value: Optional[int] = Field(default=None, alias="MaxValue")
+    min_value: Optional[int] = Field(default=None, alias="MinValue")
+    decimal_precision: Optional[int] = Field(default=None, alias="DecimalPrecision")
+
+
+class FieldMetadata(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: Optional[str] = Field(default=None, alias="id")
+    name: str
+    is_primary_key: bool = Field(alias="isPrimaryKey")
+    is_foreign_key: bool = Field(alias="isForeignKey")
+    is_external_field: bool = Field(alias="isExternalField")
+    is_hidden_field: bool = Field(alias="isHiddenField")
+    is_unique: bool = Field(alias="isUnique")
+    reference_name: Optional[str] = Field(default=None, alias="referenceName")
+    reference_entity: Optional["Entity"] = Field(default=None, alias="referenceEntity")
+    reference_choiceset: Optional["Entity"] = Field(
+        default=None, alias="referenceChoiceset"
+    )
+    reference_field: Optional["EntityField"] = Field(
+        default=None, alias="referenceField"
+    )
+    reference_type: ReferenceType = Field(alias="referenceType")
+    sql_type: "FieldDataType" = Field(alias="sqlType")
+    is_required: bool = Field(alias="isRequired")
+    display_name: str = Field(alias="displayName")
+    description: Optional[str] = Field(default=None, alias="description")
+    is_system_field: bool = Field(alias="isSystemField")
+    field_display_type: Optional[str] = Field(
+        default=None, alias="fieldDisplayType"
+    )  # Should be FieldDisplayType enum
+    choiceset_id: Optional[str] = Field(default=None, alias="choicesetId")
+    default_value: Optional[str] = Field(default=None, alias="defaultValue")
+    is_attachment: bool = Field(alias="isAttachment")
+    is_rbac_enabled: bool = Field(alias="isRbacEnabled")
+
+
+class ExternalField(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    field_metadata: FieldMetadata = Field(alias="fieldMetadata")
+    external_field_mapping_detail: ExternalFieldMapping = Field(
+        alias="externalFieldMappingDetail"
+    )
+
+
+class EntityField(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+    )
+    id: Optional[str] = Field(default=None, alias="id")
+    definition: Optional[FieldMetadata] = Field(default=None, alias="definition")
+
+
+class ExternalObject(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    external_object_name: str = Field(alias="externalObjectName")
+    external_object_display_name: str = Field(alias="externalObjectDisplayName")
+    primary_key: str = Field(alias="primaryKey")
+    external_connection_id: str = Field(alias="externalConnectionId")
+    entity_id: str = Field(alias="entityId")
+    is_primary_source: bool = Field(alias="isPrimarySource")
+
+
+class ExternalSourceFields(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    fields: List[ExternalField]
+    external_object_detail: ExternalObject = Field(alias="externalObject")
+    external_connection_detail: ExternalConnection = Field(alias="externalConnection")
+
+
+class SourceJoinCriteria(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+    id: str
+    entity_id: str = Field(alias="entityId")
+    join_field_name: str = Field(alias="joinFieldName")
+    join_type: str = Field(alias="joinType")
+    related_source_object_id: str = Field(alias="relatedSourceObjectId")
+    related_source_object_field_name: str = Field(alias="relatedSourceObjectFieldName")
+    related_source_field_name: str = Field(alias="relatedSourceFieldName")
+
+
+class EntityRecord(BaseModel):
+    model_config = {
+        "validate_by_name": True,
+        "validate_by_alias": True,
+        "extra": "allow",
+    }
+
+    id: str = Field(alias="Id")  # Mandatory field validated by Pydantic
+
+    @classmethod
+    def from_data(
+        cls, data: Dict[str, Any], model: Optional[Any] = None
+    ) -> "EntityRecord":
+        """Create an EntityRecord instance by validating raw data and optionally instantiating a custom model.
+
+        :param data: Raw data dictionary for the entity.
+        :param model: Optional user-defined class for validation.
+        :return: EntityRecord instance
+        """
+        # Validate the "Id" field is mandatory and must be a string
+        id_value = data.get("Id", None)
+        if id_value is None or not isinstance(id_value, str):
+            raise ValueError("Field 'Id' is mandatory and must be a string.")
+
+        if model:
+            # Check if the model is a plain Python class or Pydantic model
+            cls._validate_against_user_model(data, model)
+
+        return cls(**data)
+
+    @staticmethod
+    def _validate_against_user_model(
+        data: Dict[str, Any], user_class: Type[Any]
+    ) -> None:
+        user_class_annotations = getattr(user_class, "__annotations__", None)
+        if user_class_annotations is None:
+            raise ValueError(
+                f"User-provided class '{user_class.__name__}' is missing type annotations."
+            )
+
+        # Dynamically define a Pydantic model based on the user's class annotations
+        # Fields must be valid type annotations directly
+        pydantic_fields = {}
+
+        for name, annotation in user_class_annotations.items():
+            is_optional = False
+
+            origin = get_origin(annotation)
+            args = get_args(annotation)
+
+            # Handle Optional[...] or X | None
+            if origin is Union and type(None) in args:
+                is_optional = True
+
+            # Check for optional fields
+            if is_optional:
+                pydantic_fields[name] = (annotation, None)  # Not required
+            else:
+                pydantic_fields[name] = (annotation, ...)  # type: ignore
+
+        # Dynamically create the Pydantic model class
+        dynamic_model = create_model(
+            f"Dynamic_{user_class.__name__}",
+            **pydantic_fields,  # type: ignore
+        )
+
+        # Validate input data
+        dynamic_model.model_validate(data)
+
+
+class Entity(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    name: str
+    display_name: str = Field(alias="displayName")
+    entity_type: str = Field(alias="entityType")
+    description: Optional[str] = Field(default=None, alias="description")
+    fields: Optional[List[FieldMetadata]] = Field(default=None, alias="fields")
+    external_fields: Optional[List[ExternalSourceFields]] = Field(
+        default=None, alias="externalFields"
+    )
+    source_join_criteria: Optional[List[SourceJoinCriteria]] = Field(
+        default=None, alias="sourceJoinCriteria"
+    )
+    record_count: Optional[int] = Field(default=None, alias="recordCount")
+    storage_size_in_mb: Optional[float] = Field(default=None, alias="storageSizeInMB")
+    used_storage_size_in_mb: Optional[float] = Field(
+        default=None, alias="usedStorageSizeInMB"
+    )
+    attachment_size_in_byte: Optional[int] = Field(
+        default=None, alias="attachmentSizeInBytes"
+    )
+    is_rbac_enabled: bool = Field(alias="isRbacEnabled")
+    id: str
+
+
+class EntityRecordsBatchResponse(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+    )
+
+    success_records: List[EntityRecord] = Field(alias="successRecords")
+    failure_records: List[EntityRecord] = Field(alias="failureRecords")
+
+
+Entity.model_rebuild()

{uipath-2.1.48.dist-info → uipath-2.1.50.dist-info}/METADATA

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

@@ -2,7 +2,7 @@ uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
 uipath/_config.py,sha256=pi3qxPzDTxMEstj_XkGOgKJqD6RTHHv7vYv8sS_-d5Q,92
 uipath/_execution_context.py,sha256=Qo8VMUFgtiL-40KsZrvul5bGv1CRERle_fCw1ORCggY,2374
 uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,1861
-uipath/_uipath.py,sha256=lDsF2rBurqxm24DlRan25z9SU9t9b2RkAGvoI645QSw,4314
+uipath/_uipath.py,sha256=p2ccvWpzBXAGFSSF_YaaSWdEqzMmRt786d0pFWrCEwU,4463
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=kf4GINkunFGMZkTk2Z4f1Q3-OsxpNnV6u_9BsBt1i0E,2229
@@ -59,7 +59,7 @@ uipath/_cli/_evals/_models/_agent_execution_output.py,sha256=llvApU4JkTnNgQ5DvHP
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=tVHykSget-G3sOCs9bSchMYUTpFqzXVlYYbY8L9SI0c,1518
 uipath/_cli/_evals/_models/_evaluators.py,sha256=l57NEVyYmzSKuoIXuGkE94Br01hAMg35fiS2MlTkaQM,2115
 uipath/_cli/_push/sw_file_handler.py,sha256=AX4TKM-q6CNGw3JyBW02M8ktPZuFMcAU9LN3Ii0Q2QI,18202
-uipath/_cli/_runtime/_contracts.py,sha256=iAjrYaKS4y4unaNnwiCityfvWMg15f7quNn32f6LFkU,28406
+uipath/_cli/_runtime/_contracts.py,sha256=Mwdb11OULGg9xGSu_A6KCl7A5jw-fKe5tBiv62MZNVM,28424
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
 uipath/_cli/_runtime/_logging.py,sha256=MGklGKPjYKjs7J5Jy9eplA9zCDsdtEbkZdCbTwgut_4,8311
@@ -83,7 +83,7 @@ uipath/_cli/_utils/_project_files.py,sha256=a_mhBN0CLp2h56DYswjE79BP3M_LpIMYteJc
 uipath/_cli/_utils/_studio_project.py,sha256=HvzcpIIIA4hUIvMbId1dsAhmFLMuhnS2ZtyNdcpXJ8c,15422
 uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4oo,1541
 uipath/_cli/_utils/_uv_helpers.py,sha256=6SvoLnZPoKIxW0sjMvD1-ENV_HOXDYzH34GjBqwT138,3450
-uipath/_services/__init__.py,sha256=10xtw3ENC30yR9CCq_b94RMZ3YrUeyfHV33yWYUd8tU,896
+uipath/_services/__init__.py,sha256=W08UO7ZBQRD8LBHsC6gaM4YBSUl8az0S4d6iZSKsdPE,965
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
 uipath/_services/api_client.py,sha256=kGm04ijk9AOEQd2BMxvQg-2QoB8dmyoDwFFDPyutAGw,1966
@@ -92,6 +92,7 @@ uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZf
 uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
 uipath/_services/connections_service.py,sha256=Rf-DCm43tsDM6Cfp41iwGR4gUk_YCdobGcmbSoKvQ6E,7480
 uipath/_services/context_grounding_service.py,sha256=EBf7lIIYz_s1ubf_07OAZXQHjS8kpZ2vqxo4mI3VL-A,25009
+uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
 uipath/_services/jobs_service.py,sha256=UwsY0Cir7Yd5_mTeH0uHLmcmQZpdbT8KNx3z3F0cHZA,32775
 uipath/_services/llm_gateway_service.py,sha256=oZR--75V8ULdLjVC7lo-lJ5786J_qfXUDe0R9iWNAKs,24306
@@ -129,6 +130,7 @@ uipath/models/buckets.py,sha256=N3Lj_dVCv709-ywhOOdyCSvsuLn41eGuAfSiik6Q6F8,1285
 uipath/models/connections.py,sha256=V6Ecx10HBDO2HGaIGG8NGx4q2sEhViAoPOUgPosPfvE,2418
 uipath/models/context_grounding.py,sha256=3MaF2Fv2QYle8UUWvKGkCN5XGpx2T4a34fdbBqJ2fCs,1137
 uipath/models/context_grounding_index.py,sha256=OhRyxZDHDSrEmBFK0-JLqMMMT64jir4XkHtQ54IKtc0,2683
+uipath/models/entities.py,sha256=x6jbq4o_QhgL_pCgvHFsp9O8l333kQhn8e9ZCBs72UM,9823
 uipath/models/errors.py,sha256=WCxxHBlLzLF17YxjqsFkkyBLwEQM_dc6fFU5qmBjD4A,597
 uipath/models/exceptions.py,sha256=F0ITAhJsl6Agvmnv4nxvgY5oC_lrYIlxWTLs0yx859M,1636
 uipath/models/interrupt_models.py,sha256=UzuVTMVesI204YQ4qFQFaN-gN3kksddkrujofcaC7zQ,881
@@ -145,8 +147,8 @@ uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,185
 uipath/tracing/_utils.py,sha256=wJRELaPu69iY0AhV432Dk5QYf_N_ViRU4kAUG1BI1ew,10384
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.48.dist-info/METADATA,sha256=PYtAIE5tJUVOv7QMf82ym3nhNYhitzMO9K6d0yg_yKQ,6482
-uipath-2.1.48.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.48.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.48.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.48.dist-info/RECORD,,
+uipath-2.1.50.dist-info/METADATA,sha256=4B2v7QjV8SWARnJFUKuv90VmWABDavf8JxerIpwMLfM,6482
+uipath-2.1.50.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.50.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.50.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.50.dist-info/RECORD,,