uipath 2.1.107__py3-none-any.whl → 2.1.109__py3-none-any.whl

uipath/_cli/cli_add.py

@@ -0,0 +1,114 @@
+import logging
+import os
+import re
+from pathlib import Path
+from string import Template
+
+import click
+
+from ..telemetry import track
+from ._utils._console import ConsoleLogger
+from ._utils._resources import Resources
+
+logger = logging.getLogger(__name__)
+console = ConsoleLogger()
+
+
+def to_pascal_case(text: str) -> str:
+    """Convert kebab-case or snake_case to PascalCase."""
+    return "".join(word.capitalize() for word in re.sub(r"[-_]", " ", text).split())
+
+
+def to_snake_case(text: str) -> str:
+    """Convert kebab-case or PascalCase to snake_case."""
+    return re.sub(r"(?<!^)(?=[A-Z])|-", "_", text).lower()
+
+
+def generate_evaluator_template(evaluator_name: str) -> str:
+    """Generate a generic evaluator template."""
+    class_name = to_pascal_case(evaluator_name)
+    if not class_name.endswith("Evaluator"):
+        class_name = class_name + "Evaluator"
+
+    variables = {
+        "class_name": class_name,
+        "evaluator_name": evaluator_name,
+        "criteria_class": class_name.replace("Evaluator", "EvaluationCriteria"),
+        "config_class": class_name + "Config",
+    }
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", "custom_evaluator.py.template"
+    )
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+
+    return Template(content).substitute(variables)
+
+
+def create_evaluator(evaluator_name):
+    cwd = Path.cwd()
+    custom_evaluators_dir = cwd / "evals" / "evaluators" / "custom"
+
+    if not custom_evaluators_dir.exists():
+        console.info(
+            f"Creating {click.style('evals/evaluators/custom', fg='cyan')} folder"
+        )
+        custom_evaluators_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = to_snake_case(evaluator_name)
+    if not filename.endswith(".py"):
+        filename = filename + ".py"
+
+    file_path = custom_evaluators_dir / filename
+
+    if file_path.exists():
+        console.error(f"Evaluator file already exists: {file_path}")
+
+    template_content = generate_evaluator_template(evaluator_name)
+
+    with open(file_path, "w") as f:
+        f.write(template_content)
+
+    relative_path = f"evals/evaluators/custom/{filename}"
+
+    console.success(f"Created new evaluator: {click.style(relative_path, fg='cyan')}")
+    console.hint("Next steps:")
+    console.hint(
+        f"  1. Edit {click.style(relative_path, fg='cyan')} to implement your evaluation logic"
+    )
+    console.hint(
+        f"  2. Run {click.style(f'uipath register evaluator {filename}', fg='cyan')} to generate the evaluator spec"
+    )
+
+
+@click.command()
+@click.argument("resource", required=True)
+@click.argument("args", nargs=-1)
+@track
+def add(resource: str, args: tuple[str]) -> None:
+    """Create a local resource.
+
+    Examples:
+        uipath add evaluator my-custom-evaluator
+    """
+    match Resources.from_string(resource):
+        case Resources.EVALUATOR:
+            usage_hint = f"Usage: {click.style('uipath add evaluator <evaluator_name>', fg='cyan')}"
+            if len(args) < 1:
+                console.hint(usage_hint)
+                console.error("Missing required argument: evaluator_name")
+                return
+            if len(args) > 1:
+                console.hint(usage_hint)
+                console.error(
+                    f"Too many arguments provided: {args}. Expected only evaluator_name."
+                )
+
+            evaluator_name = args[0]
+
+            if not isinstance(evaluator_name, str) or not evaluator_name.strip():
+                console.hint(usage_hint)
+                console.error("Invalid evaluator_name: must be a non-empty string")
+                return
+
+            create_evaluator(evaluator_name)

uipath/_cli/cli_eval.py

@@ -130,7 +130,11 @@ def eval(
 
         eval_context.no_report = no_report
         eval_context.workers = workers
-        eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
+
+        # Load eval set to resolve the path
+        eval_set_path = eval_set or EvalHelpers.auto_discover_eval_set()
+        _, resolved_eval_set_path = EvalHelpers.load_eval_set(eval_set_path, eval_ids)
+        eval_context.eval_set = resolved_eval_set_path
         eval_context.eval_ids = eval_ids
 
         console_reporter = ConsoleProgressReporter()

uipath/_cli/cli_pull.py

@@ -24,20 +24,6 @@ from ._utils._project_files import ProjectPullError, pull_project
 console = ConsoleLogger()
 
 
-class InteractiveConflictHandler:
-    """Handler that prompts user for each conflict."""
-
-    def __init__(self, console: ConsoleLogger):
-        self.console = console
-
-    def should_overwrite(
-        self, file_path: str, local_hash: str, remote_hash: str
-    ) -> bool:
-        self.console.warning(f" File {file_path} differs from remote version.")
-        response = click.confirm("Do you want to overwrite it?", default=False)
-        return response
-
-
 @click.command()
 @click.argument(
     "root",
@@ -66,22 +52,21 @@ def pull(root: Path) -> None:
     project_id = os.getenv(UIPATH_PROJECT_ID)
     if not project_id:
         console.error("UIPATH_PROJECT_ID environment variable not found.")
+        return
 
-    default_download_configuration = {
+    download_configuration = {
         "source_code": root,
         "evals": root / "evals",
     }
 
-    async def pull_with_updates():
-        try:
-            async for update in pull_project(
-                project_id,
-                default_download_configuration,
-                InteractiveConflictHandler(console),
-            ):
+    try:
+
+        async def run_pull():
+            async for update in pull_project(project_id, download_configuration):
+                console.info(f"Processing: {update.file_path}")
                 console.info(update.message)
-        except ProjectPullError as e:
-            console.error(e.message, include_traceback=True)
 
-    with console.spinner("Pulling UiPath project files..."):
-        asyncio.run(pull_with_updates())
+        asyncio.run(run_pull())
+        console.success("Project pulled successfully")
+    except ProjectPullError as e:
+        console.error(f"Failed to pull UiPath project: {str(e)}")

uipath/_cli/cli_push.py

@@ -61,6 +61,8 @@ async def upload_source_files_to_project(
     async for update in sw_file_handler.upload_source_files(settings):
         yield update
 
+    await sw_file_handler.upload_coded_evals_files()
+
 
 @click.command()
 @click.argument(

uipath/_cli/cli_register.py

@@ -0,0 +1,45 @@
+# type: ignore
+import logging
+
+import click
+
+from ..telemetry import track
+from ._evals._helpers import register_evaluator
+from ._utils._console import ConsoleLogger
+from ._utils._resources import Resources
+
+logger = logging.getLogger(__name__)
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument("resource", required=True)
+@click.argument("args", nargs=-1)
+@track
+def register(resource: str, args: tuple[str]) -> None:
+    """Register a local resource.
+
+    Examples:
+        uipath register evaluator my-custom-evaluator.py
+    """
+    match Resources.from_string(resource):
+        case Resources.EVALUATOR:
+            usage_hint = f"Usage: {click.style('uipath register evaluator <evaluator_file_name> (ex. my_custom_evaluator.py)', fg='cyan')}"
+            if len(args) < 1:
+                console.hint(usage_hint)
+                console.error("Missing required argument: evaluator_file_name.")
+                return
+            if len(args) > 1:
+                console.hint(usage_hint)
+                console.error(
+                    f"Too many arguments provided: {args}. Expected only evaluator_file_name (ex. my_custom_evaluator.py)"
+                )
+
+            filename = args[0]
+
+            if not isinstance(filename, str) or not filename.strip():
+                console.hint(usage_hint)
+                console.error("Invalid filename: must be a non-empty string")
+                return
+
+            register_evaluator(filename)

uipath/_events/_events.py

@@ -3,9 +3,9 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
 from opentelemetry.sdk.trace import ReadableSpan
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, SkipValidation, model_validator
 
-from uipath._cli._evals._models._evaluation_set import EvaluationItem
+from uipath._cli._evals._models._evaluation_set import AnyEvaluationItem, AnyEvaluator
 from uipath.eval.models import EvalItemResult
 
 
@@ -21,12 +21,13 @@ class EvalSetRunCreatedEvent(BaseModel):
     entrypoint: str
     eval_set_id: str
     no_of_evals: int
-    evaluators: List[Any]
+    # skip validation to avoid abstract class instantiation
+    evaluators: SkipValidation[List[AnyEvaluator]]
 
 
 class EvalRunCreatedEvent(BaseModel):
     execution_id: str
-    eval_item: EvaluationItem
+    eval_item: AnyEvaluationItem
 
 
 class EvalItemExceptionDetails(BaseModel):
@@ -40,7 +41,7 @@ class EvalRunUpdatedEvent(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     execution_id: str
-    eval_item: EvaluationItem
+    eval_item: AnyEvaluationItem
     eval_results: List[EvalItemResult]
     success: bool
     agent_output: Any

uipath/_resources/SDK_REFERENCE.md

@@ -70,93 +70,6 @@ sdk.assets.update_async(robot_asset: uipath.models.assets.UserAsset, folder_key:
 
 ```
 
-### Attachments
-
-Attachments service
-
-```python
-# Delete an attachment.
-sdk.attachments.delete(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Delete an attachment asynchronously.
-sdk.attachments.delete_async(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download an attachment.
-sdk.attachments.download(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Download an attachment asynchronously.
-sdk.attachments.download_async(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Upload a file or content to UiPath as an attachment.
-sdk.attachments.upload(name: str, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
-
-# Upload a file or content to UiPath as an attachment asynchronously.
-sdk.attachments.upload_async(name: str, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
-
-```
-
-### Buckets
-
-Buckets service
-
-```python
-# Download a file from a bucket.
-sdk.buckets.download(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download a file from a bucket asynchronously.
-sdk.buckets.download_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Retrieve bucket information by its name.
-sdk.buckets.retrieve(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Asynchronously retrieve bucket information by its name.
-sdk.buckets.retrieve_async(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Upload a file to a bucket.
-sdk.buckets.upload(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Upload a file to a bucket asynchronously.
-sdk.buckets.upload_async(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-```
-
-### Connections
-
-Connections service
-
-```python
-# Lists all connections with optional filtering.
-sdk.connections.list(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Asynchronously lists all connections with optional filtering.
-sdk.connections.list_async(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Synchronously retrieve connection API metadata.
-sdk.connections.metadata(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Asynchronously retrieve connection API metadata.
-sdk.connections.metadata_async(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Retrieve connection details by its key.
-sdk.connections.retrieve(key: str) -> uipath.models.connections.Connection
-
-# Asynchronously retrieve connection details by its key.
-sdk.connections.retrieve_async(key: str) -> uipath.models.connections.Connection
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload_async(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve an authentication token for a connection.
-sdk.connections.retrieve_token(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-# Asynchronously retrieve an authentication token for a connection.
-sdk.connections.retrieve_token_async(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-```
-
 ### Context Grounding
 
 Context Grounding service
@@ -274,16 +187,6 @@ sdk.entities.update_records_async(entity_key: str, records: List[Any], schema: O
 
 ```
 
-### Folders
-
-Folders service
-
-```python
-# Retrieve the folder key by folder path with pagination support.
-sdk.folders.retrieve_key(folder_path: str) -> typing.Optional[str]
-
-```
-
 ### Jobs
 
 Jobs service

uipath/_uipath.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 from typing import Optional
 
 from pydantic import ValidationError
@@ -51,10 +52,6 @@ class UiPath:
                     raise BaseUrlMissingError() from e
                 elif error["loc"][0] == "secret":
                     raise SecretMissingError() from e
-        self._folders_service: Optional[FolderService] = None
-        self._buckets_service: Optional[BucketsService] = None
-        self._attachments_service: Optional[AttachmentsService] = None
-        self._connections_service: Optional[ConnectionsService] = None
         setup_logging(should_debug=debug)
         self._execution_context = ExecutionContext()
 
@@ -66,13 +63,9 @@ class UiPath:
     def assets(self) -> AssetsService:
         return AssetsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def attachments(self) -> AttachmentsService:
-        if not self._attachments_service:
-            self._attachments_service = AttachmentsService(
-                self._config, self._execution_context
-            )
-        return self._attachments_service
+        return AttachmentsService(self._config, self._execution_context)
 
     @property
     def processes(self) -> ProcessesService:
@@ -82,39 +75,21 @@ class UiPath:
     def actions(self) -> ActionsService:
         return ActionsService(self._config, self._execution_context)
 
-    @property
+    @cached_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
+    @cached_property
     def connections(self) -> ConnectionsService:
-        if not self._connections_service:
-            if not self._folders_service:
-                self._folders_service = FolderService(
-                    self._config, self._execution_context
-                )
-            self._connections_service = ConnectionsService(
-                self._config, self._execution_context, self._folders_service
-            )
-        return self._connections_service
+        return ConnectionsService(self._config, self._execution_context, self.folders)
 
     @property
     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._buckets_service,
+            self.folders,
+            self.buckets,
         )
 
     @property
@@ -129,11 +104,9 @@ class UiPath:
     def jobs(self) -> JobsService:
         return JobsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def folders(self) -> FolderService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        return self._folders_service
+        return FolderService(self._config, self._execution_context)
 
     @property
     def llm_openai(self) -> UiPathOpenAIService:

uipath/_utils/constants.py

@@ -1,6 +1,7 @@
 # Environment variables
 DOTENV_FILE = ".env"
 ENV_BASE_URL = "UIPATH_URL"
+ENV_EVAL_BACKEND_URL = "UIPATH_EVAL_BACKEND_URL"
 ENV_UNATTENDED_USER_ACCESS_TOKEN = "UNATTENDED_USER_ACCESS_TOKEN"
 ENV_UIPATH_ACCESS_TOKEN = "UIPATH_ACCESS_TOKEN"
 ENV_FOLDER_KEY = "UIPATH_FOLDER_KEY"
@@ -46,3 +47,6 @@ COMMUNITY_agents_SUFFIX = "-community-agents"
 
 # File names
 UIPATH_CONFIG_FILE = "uipath.json"
+
+# Evaluators
+CUSTOM_EVALUATOR_PREFIX = "file://"