uipath 2.0.41__py3-none-any.whl → 2.0.43__py3-none-any.whl

uipath/_services/context_grounding_service.py

@@ -1,6 +1,7 @@
 import json
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple, Union
 
+import httpx
 from pydantic import TypeAdapter
 
 from .._config import Config
@@ -14,6 +15,7 @@ from ..models import IngestionInProgressException
 from ..models.context_grounding import ContextGroundingQueryResponse
 from ..models.context_grounding_index import ContextGroundingIndex
 from ..tracing._traced import traced
+from . import BucketsService
 from ._base_service import BaseService
 from .folder_service import FolderService
 
@@ -36,28 +38,136 @@ class ContextGroundingService(FolderContext, BaseService):
         config: Config,
         execution_context: ExecutionContext,
         folders_service: FolderService,
+        buckets_service: BucketsService,
     ) -> None:
         self._folders_service = folders_service
+        self._buckets_service = buckets_service
         super().__init__(config=config, execution_context=execution_context)
 
+    @traced(name="add_to_index", run_type="uipath")
+    def add_to_index(
+        self,
+        name: str,
+        content_type: str,
+        blob_file_path: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Add content to the index.
+
+        Args:
+            name (str): The name of the index to add content to.
+            content_type (str): The type of content being added.
+            blob_file_path (str): The path where the blob will be stored in the storage bucket.
+            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
+            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+        """
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        index = self.retrieve(name=name, folder_key=folder_key, folder_path=folder_path)
+        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
+        if source_path:
+            self._buckets_service.upload(
+                name=bucket_name,
+                blob_file_path=blob_file_path,
+                source_path=source_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+        else:
+            self._buckets_service.upload_from_memory(
+                name=bucket_name,
+                content=content,
+                blob_file_path=blob_file_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+        self.ingest_data(index, folder_key=folder_key, folder_path=folder_path)
+
+    @traced(name="add_to_index", run_type="uipath")
+    async def add_to_index_async(
+        self,
+        name: str,
+        content_type: str,
+        blob_file_path: str,
+        content: Optional[Union[str, bytes]] = None,
+        source_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> None:
+        """Asynchronously add content to the index.
+
+        Args:
+            name (str): The name of the index to add content to.
+            content_type (str): The type of content being added.
+            blob_file_path (str): The path where the blob will be stored in the storage bucket.
+            content (Optional[Union[str, bytes]]): The content to be added, either as a string or bytes.
+            source_path (Optional[str]): The source path of the content if it is being uploaded from a file.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+
+        Raises:
+            ValueError: If neither content nor source_path is provided, or if both are provided.
+        """
+        if not (content or source_path):
+            raise ValueError("Content or source_path is required")
+        if content and source_path:
+            raise ValueError("Content and source_path are mutually exclusive")
+
+        index = await self.retrieve_async(
+            name=name, folder_key=folder_key, folder_path=folder_path
+        )
+        bucket_name, bucket_folder_path = self._extract_bucket_info(index)
+        if source_path:
+            await self._buckets_service.upload_async(
+                name=bucket_name,
+                blob_file_path=blob_file_path,
+                source_path=source_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+        else:
+            await self._buckets_service.upload_from_memory_async(
+                name=bucket_name,
+                content=content,  # type: ignore
+                blob_file_path=blob_file_path,
+                folder_path=bucket_folder_path,
+                content_type=content_type,
+            )
+
+        await self.ingest_data_async(
+            index, folder_key=folder_key, folder_path=folder_path
+        )
+
     @traced(name="contextgrounding_retrieve", run_type="uipath")
     def retrieve(
         self,
         name: str,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> Optional[ContextGroundingIndex]:
+    ) -> ContextGroundingIndex:
         """Retrieve context grounding index information by its name.
 
-        This method fetches details about a specific context index, which can be
-        used to understand what type of contextual information is available for
-        automation processes.
-
         Args:
             name (str): The name of the context index to retrieve.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
 
         Returns:
-            Optional[ContextGroundingIndex]: The index information, including its configuration and metadata if found, otherwise None.
+            ContextGroundingIndex: The index information, including its configuration and metadata if found.
+
+        Raises:
+            Exception: If no index with the given name is found.
         """
         spec = self._retrieve_spec(
             name,
@@ -71,14 +181,14 @@ class ContextGroundingService(FolderContext, BaseService):
             params=spec.params,
             headers=spec.headers,
         ).json()
-        return next(
-            (
+        try:
+            return next(
                 ContextGroundingIndex.model_validate(item)
                 for item in response["value"]
                 if item["name"] == name
-            ),
-            None,
-        )
+            )
+        except StopIteration as e:
+            raise Exception("ContextGroundingIndex not found") from e
 
     @traced(name="contextgrounding_retrieve", run_type="uipath")
     async def retrieve_async(
@@ -86,19 +196,19 @@ class ContextGroundingService(FolderContext, BaseService):
         name: str,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> Optional[ContextGroundingIndex]:
-        """Retrieve asynchronously context grounding index information by its name.
-
-        This method fetches details about a specific context index, which can be
-        used to understand what type of contextual information is available for
-        automation processes.
+    ) -> ContextGroundingIndex:
+        """Asynchronously retrieve context grounding index information by its name.
 
         Args:
             name (str): The name of the context index to retrieve.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
 
         Returns:
-            Optional[ContextGroundingIndex]: The index information, including its configuration and metadata if found, otherwise None.
+            ContextGroundingIndex: The index information, including its configuration and metadata if found.
 
+        Raises:
+            Exception: If no index with the given name is found.
         """
         spec = self._retrieve_spec(
             name,
@@ -111,16 +221,17 @@ class ContextGroundingService(FolderContext, BaseService):
                 spec.method,
                 spec.endpoint,
                 params=spec.params,
+                headers=spec.headers,
             )
         ).json()
-        return next(
-            (
+        try:
+            return next(
                 ContextGroundingIndex.model_validate(item)
                 for item in response["value"]
                 if item["name"] == name
-            ),
-            None,
-        )
+            )
+        except StopIteration as e:
+            raise Exception("ContextGroundingIndex not found") from e
 
     @traced(name="contextgrounding_retrieve_by_id", run_type="uipath")
     def retrieve_by_id(
@@ -136,6 +247,8 @@ class ContextGroundingService(FolderContext, BaseService):
 
         Args:
             id (str): The unique identifier of the context index.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
 
         Returns:
             Any: The index information, including its configuration and metadata.
@@ -166,10 +279,11 @@ class ContextGroundingService(FolderContext, BaseService):
 
         Args:
             id (str): The unique identifier of the context index.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
 
         Returns:
             Any: The index information, including its configuration and metadata.
-
         """
         spec = self._retrieve_by_id_spec(
             id,
@@ -282,82 +396,6 @@ class ContextGroundingService(FolderContext, BaseService):
             response.json()
         )
 
-    @traced(name="contextgrounding_get_or_create_index", run_type="uipath")
-    def get_or_create_index(
-        self,
-        name: str,
-        *,
-        description: Optional[str] = None,
-        storage_bucket_name: str,
-        file_name_glob: Optional[str] = None,
-        storage_bucket_folder_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> ContextGroundingIndex:
-        spec = self._create_spec(
-            name,
-            description,
-            storage_bucket_name,
-            file_name_glob,
-            storage_bucket_folder_path,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        index = self.retrieve(
-            name=name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        if index:
-            return index
-
-        response = self.request(
-            spec.method,
-            spec.endpoint,
-            content=spec.content,
-            headers=spec.headers,
-        ).json()
-        return ContextGroundingIndex.model_validate(response)
-
-    @traced(name="contextgrounding_get_or_create_index", run_type="uipath")
-    async def get_or_create_index_async(
-        self,
-        name: str,
-        *,
-        description: Optional[str] = None,
-        storage_bucket_name: str,
-        file_name_glob: Optional[str] = None,
-        storage_bucket_folder_path: Optional[str] = None,
-        folder_key: Optional[str] = None,
-        folder_path: Optional[str] = None,
-    ) -> ContextGroundingIndex:
-        index = await self.retrieve_async(
-            name=name,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        if index:
-            return index
-
-        spec = self._create_spec(
-            name,
-            description,
-            storage_bucket_name,
-            file_name_glob,
-            storage_bucket_folder_path,
-            folder_key=folder_key,
-            folder_path=folder_path,
-        )
-        response = (
-            await self.request_async(
-                spec.method,
-                spec.endpoint,
-                content=spec.content,
-                headers=spec.headers,
-            )
-        ).json()
-        return ContextGroundingIndex.model_validate(response)
-
     @traced(name="contextgrounding_ingest_data", run_type="uipath")
     def ingest_data(
         self,
@@ -365,6 +403,13 @@ class ContextGroundingService(FolderContext, BaseService):
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> None:
+        """Ingest data into the context grounding index.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
         if not index.id:
             return
         spec = self._ingest_spec(
@@ -372,11 +417,18 @@ class ContextGroundingService(FolderContext, BaseService):
             folder_key=folder_key,
             folder_path=folder_path,
         )
-        self.request(
-            spec.method,
-            spec.endpoint,
-            headers=spec.headers,
-        )
+        try:
+            self.request(
+                spec.method,
+                spec.endpoint,
+                headers=spec.headers,
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code != 409:
+                raise e
+            raise IngestionInProgressException(
+                index_name=index.name, search_operation=False
+            ) from e
 
     @traced(name="contextgrounding_ingest_data", run_type="uipath")
     async def ingest_data_async(
@@ -385,6 +437,13 @@ class ContextGroundingService(FolderContext, BaseService):
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> None:
+        """Asynchronously ingest data into the context grounding index.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to perform data ingestion.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
         if not index.id:
             return
         spec = self._ingest_spec(
@@ -392,11 +451,18 @@ class ContextGroundingService(FolderContext, BaseService):
             folder_key=folder_key,
             folder_path=folder_path,
         )
-        await self.request_async(
-            spec.method,
-            spec.endpoint,
-            headers=spec.headers,
-        )
+        try:
+            await self.request_async(
+                spec.method,
+                spec.endpoint,
+                headers=spec.headers,
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code != 409:
+                raise e
+            raise IngestionInProgressException(
+                index_name=index.name, search_operation=False
+            ) from e
 
     @traced(name="contextgrounding_delete_index", run_type="uipath")
     def delete_index(
@@ -405,6 +471,15 @@ class ContextGroundingService(FolderContext, BaseService):
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> None:
+        """Delete a context grounding index.
+
+        This method removes the specified context grounding index from Orchestrator.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
         if not index.id:
             return
         spec = self._delete_by_id_spec(
@@ -425,6 +500,15 @@ class ContextGroundingService(FolderContext, BaseService):
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> None:
+        """Asynchronously delete a context grounding index.
+
+        This method removes the specified context grounding index from Orchestrator.
+
+        Args:
+            index (ContextGroundingIndex): The context grounding index to delete.
+            folder_key (Optional[str]): The key of the folder where the index resides.
+            folder_path (Optional[str]): The path of the folder where the index resides.
+        """
         if not index.id:
             return
         spec = self._delete_by_id_spec(
@@ -465,7 +549,10 @@ class ContextGroundingService(FolderContext, BaseService):
         return RequestSpec(
             method="GET",
             endpoint=Endpoint("/ecs_/v2/indexes"),
-            params={"$filter": f"Name eq '{name}'"},
+            params={
+                "$filter": f"Name eq '{name}'",
+                "$expand": "dataSource",
+            },
             headers={
                 **header_folder(folder_key, None),
             },
@@ -582,3 +669,9 @@ class ContextGroundingService(FolderContext, BaseService):
             raise ValueError("Folder key or folder path is required")
 
         return folder_key
+
+    def _extract_bucket_info(self, index: ContextGroundingIndex) -> Tuple[str, str]:
+        try:
+            return index.data_source.bucketName, index.data_source.folder  # type: ignore
+        except AttributeError as e:
+            raise Exception("Cannot extract bucket data from index") from e

uipath/_uipath.py

@@ -56,6 +56,7 @@ class UiPath:
                 elif error["loc"][0] == "secret":
                     raise SecretMissingError() from e
         self._folders_service: Optional[FolderService] = None
+        self._buckets_service: Optional[BucketsService] = None
 
         setup_logging(debug)
         self._execution_context = ExecutionContext()
@@ -78,6 +79,10 @@ class UiPath:
 
     @property
     def buckets(self) -> BucketsService:
+        if not self._buckets_service:
+            self._buckets_service = BucketsService(
+                self._config, self._execution_context
+            )
         return BucketsService(self._config, self._execution_context)
 
     @property
@@ -88,8 +93,15 @@ class UiPath:
     def context_grounding(self) -> ContextGroundingService:
         if not self._folders_service:
             self._folders_service = FolderService(self._config, self._execution_context)
+        if not self._buckets_service:
+            self._buckets_service = BucketsService(
+                self._config, self._execution_context
+            )
         return ContextGroundingService(
-            self._config, self._execution_context, self._folders_service
+            self._config,
+            self._execution_context,
+            self._folders_service,
+            self._buckets_service,
         )
 
     @property

uipath/_utils/_read_overwrites.py

@@ -0,0 +1,141 @@
+import json
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, Generator, Optional, Tuple
+
+
+class OverwritesManager:
+    """Manages overwrites for different resource types and methods.
+
+    This class handles reading and accessing bindings overwrites from a JSON file.
+    The overwrites are stored under the 'resourceOverwrites' key, where each key is a
+    resource key (e.g., 'asset.MyAssetKeyFromBindingsJson') and the value contains
+    'name' and 'folderPath' fields.
+
+    This is a singleton class to ensure only one instance exists throughout the application.
+    """
+
+    _instance = None
+    _overwrites_file_path: Path = Path("uipath.json")
+    _overwrites: Dict[str, Any] = {}
+
+    def __new__(
+        cls, overwrites_file_path: Optional[Path] = None
+    ) -> "OverwritesManager":
+        """Create or return the singleton instance.
+
+        Args:
+            overwrites_file_path: Optional path to the overwrites JSON file.
+                If not provided, defaults to 'uipath.json' in the project root.
+
+        Returns:
+            The singleton instance of OverwritesManager.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._overwrites_file_path = (
+                overwrites_file_path or cls._overwrites_file_path
+            )
+            cls._instance._read_overwrites_file()
+        elif (
+            overwrites_file_path
+            and overwrites_file_path != cls._instance._overwrites_file_path
+        ):
+            # If a new file path is provided and it's different from the current one,
+            # update the path and re-read the file
+            cls._instance._overwrites_file_path = overwrites_file_path
+            cls._instance._read_overwrites_file()
+        return cls._instance
+
+    def _read_overwrites_file(self) -> None:
+        """Read the overwrites JSON file and cache the data.
+
+        Raises:
+            FileNotFoundError: If the overwrites file doesn't exist.
+            json.JSONDecodeError: If the file contains invalid JSON.
+        """
+        try:
+            with open(self._overwrites_file_path, "r") as f:
+                self._overwrites = json.load(f)
+        except FileNotFoundError:
+            self._overwrites = {}
+
+    def get_overwrite(
+        self, resource_type: str, resource_name: str
+    ) -> Optional[Tuple[str, str]]:
+        """Get an overwrite value for a specific resource.
+
+        Args:
+            resource_type: The type of resource (e.g., 'process', 'asset').
+            resource_name: The name of the resource.
+
+        Returns:
+            A tuple of (name, folder_path) if found, None otherwise.
+        """
+        overwrites = self._overwrites.get("resourceOverwrites", {})
+        key = f"{resource_type}.{resource_name}"
+
+        if key not in overwrites:
+            return None
+
+        overwrite = overwrites[key]
+        return (
+            overwrite.get("name", resource_name),
+            overwrite.get("folderPath", ""),
+        )
+
+    def get_and_apply_overwrite(
+        self, resource_type: str, resource_name: str, folder_path: Optional[str] = None
+    ) -> Tuple[str, str]:
+        """Get and apply overwrites for a resource, falling back to provided values if no overwrites exist.
+
+        Args:
+            resource_type: The type of resource (e.g., 'process', 'asset').
+            resource_name: The name of the resource.
+            folder_path: Optional folder path to use if no overwrite exists.
+
+        Returns:
+            A tuple of (name, folder_path) with overwritten values if available,
+            otherwise the original values.
+        """
+        overwrite = self.get_overwrite(resource_type, resource_name)
+        if overwrite:
+            name, overwrite_folder_path = overwrite
+            # Only use overwrite folder path if no folder_path was provided
+            if folder_path is None:
+                folder_path = overwrite_folder_path
+            return name, folder_path
+        return resource_name, folder_path or ""
+
+
+@contextmanager
+def read_resource_overwrites(
+    resource_type: str,
+    resource_name: str,
+    folder_path: Optional[str] = None,
+    overwrites_file_path: Optional[Path] = None,
+) -> Generator[Tuple[str, str], None, None]:
+    """Context manager for reading and applying resource overwrites.
+
+    Args:
+        resource_type: The type of resource (e.g., 'process', 'asset').
+        resource_name: The name of the resource.
+        folder_path: Optional folder path to use if no overwrite exists.
+        overwrites_file_path: Optional path to the overwrites JSON file.
+
+    Yields:
+        A tuple of (name, folder_path) with overwritten values if available,
+        otherwise the original values.
+
+    Example:
+        ```python
+        with read_resource_overwrites("asset", "MyAsset") as (name, folder_path):
+            # Use name and folder_path here
+            pass
+        ```
+    """
+    manager = OverwritesManager(overwrites_file_path)
+    try:
+        yield manager.get_and_apply_overwrite(resource_type, resource_name, folder_path)
+    finally:
+        pass

uipath/models/context_grounding_index.py

@@ -25,6 +25,7 @@ class ContextGroundingDataSource(BaseModel):
     )
     id: Optional[str] = Field(default=None, alias="id")
     folder: Optional[str] = Field(default=None, alias="folder")
+    bucketName: Optional[str] = Field(default=None, alias="bucketName")
 
 
 class ContextGroundingIndex(BaseModel):

uipath/models/exceptions.py

@@ -1,6 +1,13 @@
+from typing import Optional
+
+
 class IngestionInProgressException(Exception):
     """An exception that is triggered when a search is attempted on an index that is currently undergoing ingestion."""
 
-    def __init__(self, index_name):
-        self.message = f"index {index_name} cannot be searched during ingestion"
+    def __init__(self, index_name: Optional[str], search_operation: bool = True):
+        index_name = index_name or "Unknown index name"
+        if search_operation:
+            self.message = f"index '{index_name}' cannot be searched during ingestion"
+        else:
+            self.message = f"index '{index_name}' is currently queued for ingestion"
         super().__init__(self.message)

{uipath-2.0.41.dist-info → uipath-2.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.41
+Version: 2.0.43
 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