From 28e6c699d944ab381b6b7421e0fc521978487ace Mon Sep 17 00:00:00 2001 From: Harshit Rohatgi Date: Tue, 7 Apr 2026 15:50:55 +0530 Subject: [PATCH] Revert "Fix/entity as resource overwrite (#1544)" as the upstream change is not checked in yet This reverts commit 11e86d4c9dce3ae2157daccd6f4f998f0c6f74d5. --- packages/uipath-platform/pyproject.toml | 2 +- .../src/uipath/platform/_uipath.py | 4 +- .../src/uipath/platform/common/__init__.py | 2 - .../src/uipath/platform/common/_bindings.py | 20 +- .../platform/entities/_entities_service.py | 186 ++---------------- .../tests/services/test_entities_service.py | 185 ++++------------- packages/uipath-platform/uv.lock | 2 +- packages/uipath/pyproject.toml | 2 +- .../src/uipath/_resources/SDK_REFERENCE.md | 4 +- .../tests/resource_overrides/overwrites.json | 4 - .../test_resource_overrides.py | 5 - packages/uipath/uv.lock | 4 +- 12 files changed, 63 insertions(+), 357 deletions(-) diff --git a/packages/uipath-platform/pyproject.toml b/packages/uipath-platform/pyproject.toml index 748075eb4..b53fb68f9 100644 --- a/packages/uipath-platform/pyproject.toml +++ b/packages/uipath-platform/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "uipath-platform" -version = "0.1.20" +version = "0.1.21" description = "HTTP client library for programmatic access to UiPath Platform" readme = { file = "README.md", content-type = "text/markdown" } requires-python = ">=3.11" diff --git a/packages/uipath-platform/src/uipath/platform/_uipath.py b/packages/uipath-platform/src/uipath/platform/_uipath.py index e1d60fc39..87c3a17f0 100644 --- a/packages/uipath-platform/src/uipath/platform/_uipath.py +++ b/packages/uipath-platform/src/uipath/platform/_uipath.py @@ -139,9 +139,7 @@ def llm(self) -> UiPathLlmChatService: @property def entities(self) -> EntitiesService: - return EntitiesService( - self._config, self._execution_context, folders_service=self.folders - ) + return EntitiesService(self._config, self._execution_context) @cached_property def resource_catalog(self) -> ResourceCatalogService: diff --git a/packages/uipath-platform/src/uipath/platform/common/__init__.py b/packages/uipath-platform/src/uipath/platform/common/__init__.py index 9070d0d70..40fc1ac34 100644 --- a/packages/uipath-platform/src/uipath/platform/common/__init__.py +++ b/packages/uipath-platform/src/uipath/platform/common/__init__.py @@ -7,7 +7,6 @@ from ._base_service import BaseService from ._bindings import ( ConnectionResourceOverwrite, - EntityResourceOverwrite, GenericResourceOverwrite, ResourceOverwrite, ResourceOverwriteParser, @@ -101,7 +100,6 @@ "EndpointManager", "jsonschema_to_pydantic", "ConnectionResourceOverwrite", - "EntityResourceOverwrite", "GenericResourceOverwrite", "ResourceOverwrite", "ResourceOverwriteParser", diff --git a/packages/uipath-platform/src/uipath/platform/common/_bindings.py b/packages/uipath-platform/src/uipath/platform/common/_bindings.py index 1ccb2b1fc..449d2a7ef 100644 --- a/packages/uipath-platform/src/uipath/platform/common/_bindings.py +++ b/packages/uipath-platform/src/uipath/platform/common/_bindings.py @@ -45,7 +45,7 @@ def folder_identifier(self) -> str: class GenericResourceOverwrite(ResourceOverwrite): resource_type: Literal[ - "process", "index", "app", "asset", "bucket", "mcpServer", "queue" + "process", "index", "app", "asset", "bucket", "mcpServer", "queue", "entity" ] name: str = Field(alias="name") folder_path: str = Field(alias="folderPath") @@ -59,20 +59,6 @@ def folder_identifier(self) -> str: return self.folder_path -class EntityResourceOverwrite(ResourceOverwrite): - resource_type: Literal["entity"] - name: str = Field(alias="name") - folder_key: str = Field(alias="folderId") - - @property - def resource_identifier(self) -> str: - return self.name - - @property - def folder_identifier(self) -> str: - return self.folder_key - - class ConnectionResourceOverwrite(ResourceOverwrite): resource_type: Literal["connection"] # In eval context, studio web provides "ConnectionId". @@ -97,9 +83,7 @@ def folder_identifier(self) -> str: ResourceOverwriteUnion = Annotated[ - Union[ - GenericResourceOverwrite, EntityResourceOverwrite, ConnectionResourceOverwrite - ], + Union[GenericResourceOverwrite, ConnectionResourceOverwrite], Field(discriminator="resource_type"), ] diff --git a/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py b/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py index dc08131c5..f30c9492e 100644 --- a/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py +++ b/packages/uipath-platform/src/uipath/platform/entities/_entities_service.py @@ -1,4 +1,3 @@ -import logging from typing import Any, Dict, List, Optional, Type import sqlparse @@ -8,21 +7,16 @@ from uipath.core.tracing import traced from ..common._base_service import BaseService -from ..common._bindings import EntityResourceOverwrite, _resource_overwrites from ..common._config import UiPathApiConfig from ..common._execution_context import UiPathExecutionContext from ..common._models import Endpoint, RequestSpec -from ..orchestrator._folder_service import FolderService from .entities import ( Entity, EntityRecord, EntityRecordsBatchResponse, - EntityRouting, QueryRoutingOverrideContext, ) -logger = logging.getLogger(__name__) - _FORBIDDEN_DML = {"INSERT", "UPDATE", "DELETE", "MERGE", "REPLACE"} _FORBIDDEN_DDL = {"DROP", "ALTER", "CREATE", "TRUNCATE"} _DISALLOWED_KEYWORDS = [ @@ -53,32 +47,9 @@ class EntitiesService(BaseService): """ def __init__( - self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, - folders_service: Optional[FolderService] = None, - folders_map: Optional[Dict[str, str]] = None, + self, config: UiPathApiConfig, execution_context: UiPathExecutionContext ) -> None: super().__init__(config=config, execution_context=execution_context) - self._folders_service = folders_service - self._folders_map = folders_map or {} - - def with_folders_map(self, folders_map: Dict[str, str]) -> "EntitiesService": - """Return a new EntitiesService configured with the given folders map. - - The map is used to build a routing context automatically when - ``query_entity_records`` is called without an explicit routing context. - Folder paths in the map are resolved to folder keys via ``FolderService``. - - Args: - folders_map: Mapping of entity name to folder path. - """ - return EntitiesService( - config=self._config, - execution_context=self._execution_context, - folders_service=self._folders_service, - folders_map=folders_map, - ) @traced(name="entity_retrieve", run_type="uipath") def retrieve(self, entity_key: str) -> Entity: @@ -446,6 +417,7 @@ class CustomerRecord: def query_entity_records( self, sql_query: str, + routing_context: Optional[QueryRoutingOverrideContext] = None, ) -> List[Dict[str, Any]]: """Query entity records using a validated SQL query. @@ -455,10 +427,9 @@ def query_entity_records( sql_query (str): A SQL SELECT query to execute against Data Service entities. Only SELECT statements are allowed. Queries without WHERE must include a LIMIT clause. Subqueries and multi-statement queries are not permitted. - - Notes: - A routing context is always derived from the configured ``folders_map`` - when present and included in the request body. + routing_context (Optional[QueryRoutingOverrideContext]): Per-entity routing context + for multi-folder queries. When present, included in the request body + and takes precedence over the folder header on the backend. Returns: List[Dict[str, Any]]: A list of result records as dictionaries. @@ -467,12 +438,15 @@ def query_entity_records( ValueError: If the SQL query fails validation (e.g., non-SELECT, missing WHERE/LIMIT, forbidden keywords, subqueries). """ - return self._query_entities_for_records(sql_query) + return self._query_entities_for_records( + sql_query, routing_context=routing_context + ) @traced(name="entity_query_records", run_type="uipath") async def query_entity_records_async( self, sql_query: str, + routing_context: Optional[QueryRoutingOverrideContext] = None, ) -> List[Dict[str, Any]]: """Asynchronously query entity records using a validated SQL query. @@ -482,10 +456,9 @@ async def query_entity_records_async( sql_query (str): A SQL SELECT query to execute against Data Service entities. Only SELECT statements are allowed. Queries without WHERE must include a LIMIT clause. Subqueries and multi-statement queries are not permitted. - - Notes: - A routing context is always derived from the configured ``folders_map`` - when present and included in the request body. + routing_context (Optional[QueryRoutingOverrideContext]): Per-entity routing context + for multi-folder queries. When present, included in the request body + and takes precedence over the folder header on the backend. Returns: List[Dict[str, Any]]: A list of result records as dictionaries. @@ -494,14 +467,17 @@ async def query_entity_records_async( ValueError: If the SQL query fails validation (e.g., non-SELECT, missing WHERE/LIMIT, forbidden keywords, subqueries). """ - return await self._query_entities_for_records_async(sql_query) + return await self._query_entities_for_records_async( + sql_query, routing_context=routing_context + ) def _query_entities_for_records( self, sql_query: str, + *, + routing_context: Optional[QueryRoutingOverrideContext] = None, ) -> List[Dict[str, Any]]: self._validate_sql_query(sql_query) - routing_context = self._build_routing_context_from_map() spec = self._query_entity_records_spec(sql_query, routing_context) response = self.request(spec.method, spec.endpoint, json=spec.json) return response.json().get("results", []) @@ -509,9 +485,10 @@ def _query_entities_for_records( async def _query_entities_for_records_async( self, sql_query: str, + *, + routing_context: Optional[QueryRoutingOverrideContext] = None, ) -> List[Dict[str, Any]]: self._validate_sql_query(sql_query) - routing_context = await self._build_routing_context_from_map_async() spec = self._query_entity_records_spec(sql_query, routing_context) response = await self.request_async(spec.method, spec.endpoint, json=spec.json) return response.json().get("results", []) @@ -1015,131 +992,6 @@ def _query_entity_records_spec( json=body, ) - def _build_routing_context_from_map( - self, - ) -> Optional[QueryRoutingOverrideContext]: - """Build a routing context from the configured folders_map and context overwrites. - - Folder paths in the map are resolved to folder keys via FolderService. - Entity overwrites from the active ``ResourceOverwritesContext`` are - merged in, supplying ``override_entity_name`` when the overwrite - provides a different entity name. - - Returns: - A QueryRoutingOverrideContext if routing entries exist, - None otherwise. - """ - resolved = self._resolve_folder_paths_to_ids() - return self._build_routing_context_from_resolved_map(resolved) - - async def _build_routing_context_from_map_async( - self, - ) -> Optional[QueryRoutingOverrideContext]: - """Async version of _build_routing_context_from_map.""" - resolved = await self._resolve_folder_paths_to_ids_async() - return self._build_routing_context_from_resolved_map(resolved) - - def _resolve_folder_paths_to_ids(self) -> Optional[dict[str, str]]: - if not self._folders_map: - return None - - resolved: dict[str, str] = {} - for folder_path in set(self._folders_map.values()): - if self._folders_service is not None: - folder_key = self._folders_service.retrieve_folder_key(folder_path) - if folder_key is not None: - resolved[folder_path] = folder_key - continue - resolved[folder_path] = folder_path - - return resolved - - async def _resolve_folder_paths_to_ids_async(self) -> Optional[dict[str, str]]: - if not self._folders_map: - return None - - resolved: dict[str, str] = {} - for folder_path in set(self._folders_map.values()): - if self._folders_service is not None: - folder_key = await self._folders_service.retrieve_folder_key_async( - folder_path - ) - if folder_key is not None: - resolved[folder_path] = folder_key - continue - resolved[folder_path] = folder_path - - return resolved - - @staticmethod - def _get_entity_overwrites_from_context() -> Dict[str, EntityResourceOverwrite]: - """Extract entity overwrites from the active ResourceOverwritesContext. - - Returns: - A dict mapping original entity name to its EntityResourceOverwrite. - """ - context_overwrites = _resource_overwrites.get() - if not context_overwrites: - return {} - - result: Dict[str, EntityResourceOverwrite] = {} - for key, overwrite in context_overwrites.items(): - if isinstance(overwrite, EntityResourceOverwrite): - # Key format is "entity." - original_name = key.split(".", 1)[1] if "." in key else key - result[original_name] = overwrite - return result - - def _build_routing_context_from_resolved_map( - self, - resolved: Optional[dict[str, str]], - ) -> Optional[QueryRoutingOverrideContext]: - entity_overwrites = self._get_entity_overwrites_from_context() - - routings: List[EntityRouting] = [] - - # Add routings from folders_map - if self._folders_map and resolved is not None: - for name, folder_path in self._folders_map.items(): - overwrite = entity_overwrites.pop(name, None) - override_name = ( - overwrite.resource_identifier - if overwrite and overwrite.resource_identifier != name - else None - ) - folder_id = ( - overwrite.folder_identifier - if overwrite - else resolved.get(folder_path, folder_path) - ) - routings.append( - EntityRouting( - entity_name=name, - folder_id=folder_id, - override_entity_name=override_name, - ) - ) - - # Add routings from context overwrites not already in folders_map - for original_name, overwrite in entity_overwrites.items(): - override_name = ( - overwrite.resource_identifier - if overwrite.resource_identifier != original_name - else None - ) - routings.append( - EntityRouting( - entity_name=original_name, - folder_id=overwrite.folder_identifier, - override_entity_name=override_name, - ) - ) - - if not routings: - return None - - return QueryRoutingOverrideContext(entity_routings=routings) - def _insert_batch_spec(self, entity_key: str, records: List[Any]) -> RequestSpec: return RequestSpec( method="POST", diff --git a/packages/uipath-platform/tests/services/test_entities_service.py b/packages/uipath-platform/tests/services/test_entities_service.py index 4993a1367..8a9abafef 100644 --- a/packages/uipath-platform/tests/services/test_entities_service.py +++ b/packages/uipath-platform/tests/services/test_entities_service.py @@ -8,7 +8,7 @@ from pytest_httpx import HTTPXMock from uipath.platform import UiPathApiConfig, UiPathExecutionContext -from uipath.platform.entities import Entity +from uipath.platform.entities import Entity, EntityRouting, QueryRoutingOverrideContext from uipath.platform.entities._entities_service import EntitiesService @@ -390,21 +390,28 @@ async def test_query_entity_records_async_calls_request_for_valid_sql( assert result == [{"id": "c1"}] service.request_async.assert_called_once() - def test_query_entity_records_builds_routing_context_from_folders_map( + def test_query_entity_records_with_routing_context( self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, + service: EntitiesService, ) -> None: - service = EntitiesService( - config=config, - execution_context=execution_context, - folders_map={"Customers": "solution_folder", "Orders": "folder-2"}, - ) response = MagicMock() response.json.return_value = {"results": [{"id": 1}]} service.request = MagicMock(return_value=response) # type: ignore[method-assign] - result = service.query_entity_records("SELECT id FROM Customers LIMIT 10") + routing = QueryRoutingOverrideContext( + entity_routings=[ + EntityRouting(entity_name="Customers", folder_id="folder-1"), + EntityRouting( + entity_name="Orders", + folder_id="folder-2", + override_entity_name="OrdersV2", + ), + ] + ) + + result = service.query_entity_records( + "SELECT id FROM Customers LIMIT 10", routing_context=routing + ) assert result == [{"id": 1}] call_kwargs = service.request.call_args @@ -412,38 +419,39 @@ def test_query_entity_records_builds_routing_context_from_folders_map( assert body["query"] == "SELECT id FROM Customers LIMIT 10" assert body["routingContext"] == { "entityRoutings": [ - {"entityName": "Customers", "folderId": "solution_folder"}, - {"entityName": "Orders", "folderId": "folder-2"}, + {"entityName": "Customers", "folderId": "folder-1"}, + { + "entityName": "Orders", + "folderId": "folder-2", + "overrideEntityName": "OrdersV2", + }, ] } @pytest.mark.anyio - async def test_query_entity_records_async_builds_routing_context_from_folders_map( + async def test_query_entity_records_async_with_routing_context( self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, + service: EntitiesService, ) -> None: - service = EntitiesService( - config=config, - execution_context=execution_context, - folders_map={"Customers": "solution_folder"}, - ) response = MagicMock() response.json.return_value = {"results": [{"id": "c1"}]} service.request_async = AsyncMock(return_value=response) # type: ignore[method-assign] + routing = QueryRoutingOverrideContext( + entity_routings=[ + EntityRouting(entity_name="Customers", folder_id="folder-1"), + ] + ) + result = await service.query_entity_records_async( - "SELECT id FROM Customers WHERE id = 'c1'" + "SELECT id FROM Customers WHERE id = 'c1'", + routing_context=routing, ) assert result == [{"id": "c1"}] call_kwargs = service.request_async.call_args body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json") - assert body["routingContext"] == { - "entityRoutings": [ - {"entityName": "Customers", "folderId": "solution_folder"}, - ] - } + assert "routingContext" in body def test_query_entity_records_without_routing_context_omits_key( self, @@ -458,128 +466,3 @@ def test_query_entity_records_without_routing_context_omits_key( call_kwargs = service.request.call_args body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json") assert "routingContext" not in body - - def test_query_entity_records_picks_up_entity_overwrites_from_context( - self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, - ) -> None: - from uipath.platform.common._bindings import ( - EntityResourceOverwrite, - _resource_overwrites, - ) - - service = EntitiesService( - config=config, - execution_context=execution_context, - ) - response = MagicMock() - response.json.return_value = {"results": [{"id": 1}]} - service.request = MagicMock(return_value=response) # type: ignore[method-assign] - - overwrite = EntityResourceOverwrite( - resource_type="entity", - name="Overwritten Customers", - folder_key="overwritten-folder-id", - ) - token = _resource_overwrites.set({"entity.Customers": overwrite}) - try: - service.query_entity_records("SELECT id FROM Customers LIMIT 10") - finally: - _resource_overwrites.reset(token) - - call_kwargs = service.request.call_args - body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json") - assert body["routingContext"] == { - "entityRoutings": [ - { - "entityName": "Customers", - "folderId": "overwritten-folder-id", - "overrideEntityName": "Overwritten Customers", - }, - ] - } - - def test_query_entity_records_merges_folders_map_with_context_overwrites( - self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, - ) -> None: - from uipath.platform.common._bindings import ( - EntityResourceOverwrite, - _resource_overwrites, - ) - - service = EntitiesService( - config=config, - execution_context=execution_context, - folders_map={"Customers": "original-folder", "Orders": "orders-folder"}, - ) - response = MagicMock() - response.json.return_value = {"results": []} - service.request = MagicMock(return_value=response) # type: ignore[method-assign] - - # Overwrite only Customers — Orders should keep its folders_map value - overwrite = EntityResourceOverwrite( - resource_type="entity", - name="Overwritten Customers", - folder_key="overwritten-folder-id", - ) - token = _resource_overwrites.set({"entity.Customers": overwrite}) - try: - service.query_entity_records("SELECT id FROM Customers LIMIT 10") - finally: - _resource_overwrites.reset(token) - - call_kwargs = service.request.call_args - body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json") - routings = body["routingContext"]["entityRoutings"] - # Customers overwritten by context - assert { - "entityName": "Customers", - "folderId": "overwritten-folder-id", - "overrideEntityName": "Overwritten Customers", - } in routings - # Orders unchanged from folders_map - assert {"entityName": "Orders", "folderId": "orders-folder"} in routings - - def test_query_entity_records_context_overwrite_same_name_no_override_field( - self, - config: UiPathApiConfig, - execution_context: UiPathExecutionContext, - ) -> None: - from uipath.platform.common._bindings import ( - EntityResourceOverwrite, - _resource_overwrites, - ) - - service = EntitiesService( - config=config, - execution_context=execution_context, - ) - response = MagicMock() - response.json.return_value = {"results": []} - service.request = MagicMock(return_value=response) # type: ignore[method-assign] - - # Same entity name — only folder changes, no override_entity_name needed - overwrite = EntityResourceOverwrite( - resource_type="entity", - name="Customers", - folder_key="different-folder-id", - ) - token = _resource_overwrites.set({"entity.Customers": overwrite}) - try: - service.query_entity_records("SELECT id FROM Customers LIMIT 10") - finally: - _resource_overwrites.reset(token) - - call_kwargs = service.request.call_args - body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json") - assert body["routingContext"] == { - "entityRoutings": [ - { - "entityName": "Customers", - "folderId": "different-folder-id", - }, - ] - } diff --git a/packages/uipath-platform/uv.lock b/packages/uipath-platform/uv.lock index b01388722..648df8ab4 100644 --- a/packages/uipath-platform/uv.lock +++ b/packages/uipath-platform/uv.lock @@ -1088,7 +1088,7 @@ dev = [ [[package]] name = "uipath-platform" -version = "0.1.20" +version = "0.1.21" source = { editable = "." } dependencies = [ { name = "httpx" }, diff --git a/packages/uipath/pyproject.toml b/packages/uipath/pyproject.toml index 58f523a02..207f46657 100644 --- a/packages/uipath/pyproject.toml +++ b/packages/uipath/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "uipath" -version = "2.10.42" +version = "2.10.43" description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools." readme = { file = "README.md", content-type = "text/markdown" } requires-python = ">=3.11" diff --git a/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md b/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md index 5b03700be..4af1b60ae 100644 --- a/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md +++ b/packages/uipath/src/uipath/_resources/SDK_REFERENCE.md @@ -500,10 +500,10 @@ sdk.entities.list_records(entity_key: str, schema: Optional[Type[Any]]=None, sta sdk.entities.list_records_async(entity_key: str, schema: Optional[Type[Any]]=None, start: Optional[int]=None, limit: Optional[int]=None) -> typing.List[uipath.platform.entities.entities.EntityRecord] # Query entity records using a validated SQL query. -sdk.entities.query_entity_records(sql_query: str) -> typing.List[typing.Dict[str, typing.Any]] +sdk.entities.query_entity_records(sql_query: str, routing_context: Optional[uipath.platform.entities.entities.QueryRoutingOverrideContext]=None) -> typing.List[typing.Dict[str, typing.Any]] # Asynchronously query entity records using a validated SQL query. -sdk.entities.query_entity_records_async(sql_query: str) -> typing.List[typing.Dict[str, typing.Any]] +sdk.entities.query_entity_records_async(sql_query: str, routing_context: Optional[uipath.platform.entities.entities.QueryRoutingOverrideContext]=None) -> typing.List[typing.Dict[str, typing.Any]] # Retrieve an entity by its key. sdk.entities.retrieve(entity_key: str) -> uipath.platform.entities.entities.Entity diff --git a/packages/uipath/tests/resource_overrides/overwrites.json b/packages/uipath/tests/resource_overrides/overwrites.json index e0bca84ba..c58744a69 100644 --- a/packages/uipath/tests/resource_overrides/overwrites.json +++ b/packages/uipath/tests/resource_overrides/overwrites.json @@ -28,9 +28,5 @@ "mcpServer.mcp_server_name": { "name": "Overwritten MCP Server Name", "folderPath": "Overwritten/MCPServer/Folder" - }, - "entity.entity_name": { - "name": "Overwritten Entity Name", - "folderId": "overwritten-entity-folder-id-123" } } \ No newline at end of file diff --git a/packages/uipath/tests/resource_overrides/test_resource_overrides.py b/packages/uipath/tests/resource_overrides/test_resource_overrides.py index 8d39a762d..c15bc113b 100644 --- a/packages/uipath/tests/resource_overrides/test_resource_overrides.py +++ b/packages/uipath/tests/resource_overrides/test_resource_overrides.py @@ -310,11 +310,6 @@ def test_parse_overwrites_with_type_adapter(self, overwrites_data): assert mcp_server.resource_identifier == "Overwritten MCP Server Name" assert mcp_server.folder_identifier == "Overwritten/MCPServer/Folder" - # Verify entity overwrite - entity = parsed_overwrites["entity.entity_name"] - assert entity.resource_identifier == "Overwritten Entity Name" - assert entity.folder_identifier == "overwritten-entity-folder-id-123" - def test_overrides_decorator_should_pop_kwargs_dict_when_present(self): from uipath.platform.common import resource_override diff --git a/packages/uipath/uv.lock b/packages/uipath/uv.lock index 49fb5bc70..b8a817758 100644 --- a/packages/uipath/uv.lock +++ b/packages/uipath/uv.lock @@ -2543,7 +2543,7 @@ wheels = [ [[package]] name = "uipath" -version = "2.10.42" +version = "2.10.43" source = { editable = "." } dependencies = [ { name = "applicationinsights" }, @@ -2682,7 +2682,7 @@ dev = [ [[package]] name = "uipath-platform" -version = "0.1.20" +version = "0.1.21" source = { editable = "../uipath-platform" } dependencies = [ { name = "httpx" },