uipath 2.1.20__tar.gz → 2.1.22__tar.gz

{uipath-2.1.20 → uipath-2.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.20
+Version: 2.1.22
 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.20 → uipath-2.1.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.20"
+version = "2.1.22"
 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.10"

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/_evals/_evaluators/_evaluator_factory.py

@@ -107,6 +107,10 @@ class EvaluatorFactory:
         model = data.get("model", "")
         if not model:
             raise ValueError("LLM evaluator must include 'model' field")
+        if model == "same-as-agent":
+            raise ValueError(
+                "'same-as-agent' model option is not supported by coded agents evaluations. Please select a specific model for the evaluator."
+            )
 
         return LlmAsAJudgeEvaluator.from_params(
             base_params,

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/_evals/_models/_evaluation_set.py

@@ -36,6 +36,16 @@ class EvaluationSet(BaseModel):
     createdAt: str
     updatedAt: str
 
+    def extract_selected_evals(self, eval_ids) -> None:
+        selected_evals: list[EvaluationItem] = []
+        for evaluation in self.evaluations:
+            if evaluation.id in eval_ids:
+                selected_evals.append(evaluation)
+                eval_ids.remove(evaluation.id)
+        if len(eval_ids) > 0:
+            raise ValueError("Unknown evaluation ids: {}".format(eval_ids))
+        self.evaluations = selected_evals
+
 
 class EvaluationStatus(IntEnum):
     PENDING = 0

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/_evals/evaluation_service.py

@@ -33,6 +33,7 @@ class EvaluationService:
         self,
         entrypoint: Optional[str] = None,
         eval_set_path: Optional[str | Path] = None,
+        eval_ids: Optional[List[str]] = None,
         workers: int = 8,
         report_progress: bool = True,
     ):
@@ -47,10 +48,10 @@ class EvaluationService:
         self.entrypoint, self.eval_set_path = self._resolve_paths(
             entrypoint, eval_set_path
         )
-        self.eval_set = self._load_eval_set()
+        self._eval_set = self._load_eval_set(eval_ids)
         self._evaluators = self._load_evaluators()
-        self.num_workers = workers
-        self.results_lock = asyncio.Lock()
+        self._num_workers = workers
+        self._results_lock = asyncio.Lock()
         self._progress_manager: Optional[EvaluationProgressManager] = None
         self._report_progress = report_progress
         self._progress_reporter: Optional[ProgressReporter] = None
@@ -169,9 +170,9 @@ class EvaluationService:
         if self._report_progress:
             agent_snapshot = self._extract_agent_snapshot()
             self._progress_reporter = ProgressReporter(
-                eval_set_id=self.eval_set.id,
+                eval_set_id=self._eval_set.id,
                 agent_snapshot=agent_snapshot,
-                no_of_evals=len(self.eval_set.evaluations),
+                no_of_evals=len(self._eval_set.evaluations),
                 evaluators=self._evaluators,
             )
 
@@ -215,12 +216,12 @@ class EvaluationService:
 
         # Create results file
         timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
-        eval_set_name = self.eval_set.name
+        eval_set_name = self._eval_set.name
         self.result_file = results_dir / f"eval-{eval_set_name}-{timestamp}.json"
 
         initial_results = EvaluationSetResult(
-            eval_set_id=self.eval_set.id,
-            eval_set_name=self.eval_set.name,
+            eval_set_id=self._eval_set.id,
+            eval_set_name=self._eval_set.name,
             results=[],
             average_score=0.0,
         )
@@ -228,7 +229,7 @@ class EvaluationService:
         with open(self.result_file, "w", encoding="utf-8") as f:
             f.write(initial_results.model_dump_json(indent=2))
 
-    def _load_eval_set(self) -> EvaluationSet:
+    def _load_eval_set(self, eval_ids: Optional[List[str]] = None) -> EvaluationSet:
         """Load the evaluation set from file.
 
         Returns:
@@ -236,13 +237,16 @@ class EvaluationService:
         """
         with open(self.eval_set_path, "r", encoding="utf-8") as f:
             data = json.load(f)
-            return EvaluationSet(**data)
+        eval_set = EvaluationSet(**data)
+        if eval_ids:
+            eval_set.extract_selected_evals(eval_ids)
+        return eval_set
 
     def _load_evaluators(self) -> List[EvaluatorBase]:
         """Load evaluators referenced by the evaluation set."""
         evaluators = []
         evaluators_dir = self.eval_set_path.parent.parent / "evaluators"
-        evaluator_refs = set(self.eval_set.evaluatorRefs)
+        evaluator_refs = set(self._eval_set.evaluatorRefs)
         found_evaluator_ids = set()
 
         # Load evaluators from JSON files
@@ -252,14 +256,9 @@ class EvaluationService:
                 evaluator_id = data.get("id")
 
                 if evaluator_id in evaluator_refs:
-                    try:
-                        evaluator = EvaluatorFactory.create_evaluator(data)
-                        evaluators.append(evaluator)
-                        found_evaluator_ids.add(evaluator_id)
-                    except Exception as e:
-                        console.warning(
-                            f"Failed to create evaluator {evaluator_id}: {str(e)}"
-                        )
+                    evaluator = EvaluatorFactory.create_evaluator(data)
+                    evaluators.append(evaluator)
+                    found_evaluator_ids.add(evaluator_id)
 
         # Check if all referenced evaluators were found
         missing_evaluators = evaluator_refs - found_evaluator_ids
@@ -276,7 +275,7 @@ class EvaluationService:
         Args:
             results: List of evaluation results to write
         """
-        async with self.results_lock:
+        async with self._results_lock:
             # Read current results
             with open(self.result_file, "r", encoding="utf-8") as f:
                 current_results = EvaluationSetResult.model_validate_json(f.read())
@@ -473,11 +472,11 @@ class EvaluationService:
         Args:
             task_queue: The asyncio queue to add tasks to
         """
-        for eval_item in self.eval_set.evaluations:
+        for eval_item in self._eval_set.evaluations:
             await task_queue.put(eval_item.model_dump())
 
         # Add sentinel values to signal workers to stop
-        for _ in range(self.num_workers):
+        for _ in range(self._num_workers):
             await task_queue.put(None)
 
     async def _consumer_task(
@@ -517,7 +516,7 @@ class EvaluationService:
     async def run_evaluation(self) -> None:
         """Run the evaluation set using multiple worker tasks."""
         console.info(
-            f"Starting evaluating {click.style(self.eval_set.name, fg='cyan')} evaluation set..."
+            f"Starting evaluating {click.style(self._eval_set.name, fg='cyan')} evaluation set..."
         )
 
         if self._report_progress and self._progress_reporter:
@@ -526,7 +525,7 @@ class EvaluationService:
         # Prepare items for progress tracker
         progress_items = [
             {"id": eval_item.id, "name": eval_item.name}
-            for eval_item in self.eval_set.evaluations
+            for eval_item in self._eval_set.evaluations
         ]
 
         with console.evaluation_progress(progress_items) as progress_manager:
@@ -539,7 +538,7 @@ class EvaluationService:
             producer = asyncio.create_task(self._producer_task(task_queue))
 
             consumers = []
-            for worker_id in range(self.num_workers):
+            for worker_id in range(self._num_workers):
                 consumer = asyncio.create_task(
                     self._consumer_task(
                         task_queue, worker_id, results_queue, sw_progress_reporter_queue

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/_push/sw_file_handler.py

@@ -133,12 +133,14 @@ class SwFileHandler:
         self,
         local_files: list[FileInfo],
         source_code_files: Dict[str, ProjectFile],
+        root_files: Dict[str, ProjectFile],
     ) -> None:
         """Process all file uploads to the source_code folder.
 
         Args:
             local_files: List of files to upload
             source_code_files: Dictionary of existing remote files
+            root_files: Dictionary of existing root-level files
 
         Returns:
             Set of processed file names
@@ -186,13 +188,25 @@ class SwFileHandler:
                     )
                 )
                 self.console.info(
-                    f"Uploading {click.style(local_file.file_name, fg='cyan')}"
+                    f"Uploading {click.style(local_file.relative_path, fg='cyan')}"
                 )
 
         # identify and add deleted files
         structural_migration.deleted_resources.extend(
             self._collect_deleted_files(source_code_files, processed_source_files)
         )
+
+        with open(os.path.join(self.directory, "uipath.json"), "r") as f:
+            uipath_config = json.load(f)
+
+        await self._prepare_agent_json_migration(
+            structural_migration, root_files, uipath_config
+        )
+
+        await self._prepare_entrypoints_json_migration(
+            structural_migration, root_files, uipath_config
+        )
+
         await self._studio_client.perform_structural_migration_async(
             structural_migration
         )
@@ -303,40 +317,65 @@ class SwFileHandler:
 
         return True
 
-    async def _update_agent_json(
+    async def _prepare_entrypoints_json_migration(
         self,
-        agent_json_file: Optional[ProjectFile] = None,
+        structural_migration: StructuralMigration,
+        root_files: Dict[str, ProjectFile],
+        uipath_config: Dict[str, Any],
     ) -> None:
-        """Update agent.json file with metadata from uipath.json.
+        """Prepare entry-points.json to be included in the same structural migration."""
+        existing = root_files.get("entry-points.json")
+        if existing:
+            try:
+                entry_points_json = (
+                    await self._studio_client.download_file_async(existing.id)
+                ).json()
+                entry_points_json["entryPoints"] = uipath_config["entryPoints"]
 
-        This function:
-        1. Downloads existing agent.json if it exists
-        2. Updates metadata based on uipath.json content
-        3. Increments code version
-        4. Updates author from JWT or pyproject.toml
-        5. Uploads updated agent.json
+            except Exception:
+                self.console.warning(
+                    "Could not parse existing entry-points.json file, using default version"
+                )
+            structural_migration.modified_resources.append(
+                ModifiedResource(
+                    id=existing.id,
+                    content_string=json.dumps(entry_points_json),
+                )
+            )
+            self.console.info(
+                f"Updating {click.style('entry-points.json', fg='yellow')}"
+            )
 
-        Args:
-            agent_json_file: Optional existing agent.json file
+        else:
+            self.console.warning(
+                "'entry-points.json' file does not exist in Studio Web project, initializing using default version"
+            )
+            entry_points_json = {
+                "$schema": "https://cloud.uipath.com/draft/2024-12/entry-point",
+                "$id": "entry-points.json",
+                "entryPoints": uipath_config["entryPoints"],
+            }
+            structural_migration.added_resources.append(
+                AddedResource(
+                    file_name="entry-points.json",
+                    content_string=json.dumps(entry_points_json),
+                )
+            )
+            self.console.info(
+                f"Uploading {click.style('entry-points.json', fg='cyan')}"
+            )
 
-        Raises:
-            httpx.HTTPError: If API requests fail
-            FileNotFoundError: If required files are missing
-            json.JSONDecodeError: If JSON parsing fails
-        """
+    async def _prepare_agent_json_migration(
+        self,
+        structural_migration: StructuralMigration,
+        root_files: Dict[str, ProjectFile],
+        uipath_config: Dict[str, Any],
+    ) -> None:
+        """Prepare agent.json to be included in the same structural migration."""
 
         def get_author_from_token_or_toml() -> str:
             import jwt
 
-            """Extract preferred_username from JWT token or fall back to pyproject.toml author.
-
-            Args:
-                directory: Project directory containing pyproject.toml
-
-            Returns:
-                str: Author name from JWT preferred_username or pyproject.toml authors field
-            """
-            # Try to get author from JWT token first
             token = os.getenv("UIPATH_ACCESS_TOKEN")
             if token:
                 try:
@@ -350,19 +389,15 @@ class SwFileHandler:
                     # If JWT decoding fails, fall back to toml
                     pass
 
-            toml_data = read_toml_project(os.path.join(directory, "pyproject.toml"))
-
+            toml_data = read_toml_project(
+                os.path.join(self.directory, "pyproject.toml")
+            )
             return toml_data.get("authors", "").strip()
 
-        # Read uipath.json
-        directory = os.getcwd()
-        with open(os.path.join(directory, "uipath.json"), "r") as f:
-            uipath_config = json.load(f)
-
         try:
             entrypoints = [
-                {"input": entry_point["input"], "output": entry_point["output"]}
-                for entry_point in uipath_config["entryPoints"]
+                {"input": entrypoint["input"], "output": entrypoint["output"]}
+                for entrypoint in uipath_config["entryPoints"]
             ]
         except (FileNotFoundError, KeyError) as e:
             self.console.error(
@@ -388,14 +423,12 @@ class SwFileHandler:
             ),
         }
 
-        if agent_json_file:
-            # Download existing agent.json
-            existing_agent_json = (
-                await self._studio_client.download_file_async(agent_json_file.id)
-            ).json()
-
+        existing = root_files.get("agent.json")
+        if existing:
             try:
-                # Get current version and increment patch version
+                existing_agent_json = (
+                    await self._studio_client.download_file_async(existing.id)
+                ).json()
                 version_parts = existing_agent_json["metadata"]["codeVersion"].split(
                     "."
                 )
@@ -403,20 +436,32 @@ class SwFileHandler:
                     version_parts[-1] = str(int(version_parts[-1]) + 1)
                     agent_json["metadata"]["codeVersion"] = ".".join(version_parts)
                 else:
-                    # If version format is invalid, start from initial version + 1
                     agent_json["metadata"]["codeVersion"] = (
                         AGENT_INITIAL_CODE_VERSION[:-1] + "1"
                     )
-            except (json.JSONDecodeError, KeyError, ValueError):
+            except Exception:
                 self.console.warning(
-                    "Could not parse existing agent.json, using default version"
+                    "Could not parse existing agent.json file, using default version"
                 )
-        file, action = await self._studio_client.upload_file_async(
-            file_content=json.dumps(agent_json),
-            file_name="agent.json",
-            remote_file=agent_json_file,
-        )
-        self.console.success(f"{action} {click.style('agent.json', fg='cyan')}")
+
+            structural_migration.modified_resources.append(
+                ModifiedResource(
+                    id=existing.id,
+                    content_string=json.dumps(agent_json),
+                )
+            )
+            self.console.info(f"Updating {click.style('agent.json', fg='yellow')}")
+        else:
+            self.console.warning(
+                "'agent.json' file does not exist in Studio Web project, initializing using default version"
+            )
+            structural_migration.added_resources.append(
+                AddedResource(
+                    file_name="agent.json",
+                    content_string=json.dumps(agent_json),
+                )
+            )
+            self.console.info(f"Uploading {click.style('agent.json', fg='cyan')}")
 
     async def upload_source_files(self, config_data: dict[str, Any]) -> None:
         """Main method to upload source files to the UiPath project.
@@ -457,8 +502,4 @@ class SwFileHandler:
             self.include_uv_lock,
             directories_to_ignore=["evals"],
         )
-        await self._process_file_uploads(files, source_code_files)
-
-        await self._update_agent_json(
-            root_files.get("agent.json", None),
-        )
+        await self._process_file_uploads(files, source_code_files, root_files)

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/_utils/_studio_project.py

@@ -175,13 +175,20 @@ def get_folder_by_name(
 
 
 class AddedResource(BaseModel):
-    content_file_path: str
+    """Represents a new file to be added during a structural migration."""
+
+    content_file_path: Optional[str] = None
     parent_path: Optional[str] = None
+    file_name: Optional[str] = None
+    content_string: Optional[str] = None
 
 
 class ModifiedResource(BaseModel):
+    """Represents a file update during a structural migration."""
+
     id: str
-    content_file_path: str
+    content_file_path: Optional[str] = None
+    content_string: Optional[str] = None
 
 
 class StructuralMigration(BaseModel):
@@ -336,6 +343,53 @@ class StudioClient:
             headers=headers or {},
         )
 
+    def _resolve_content_and_filename(
+        self,
+        *,
+        content_string: Optional[str],
+        content_file_path: Optional[str],
+        file_name: Optional[str] = None,
+        modified: bool = False,
+    ) -> tuple[bytes, Optional[str]]:
+        """Resolve multipart content bytes and filename for a resource.
+
+        Args:
+            content_string: Inline content as a string.
+            content_file_path: Path to a local file to read if inline content is not provided.
+            file_name: Explicit filename to use when adding a new resource.
+
+        Returns:
+            A tuple of (content_bytes, filename).
+
+        Raises:
+            FileNotFoundError: If a provided file path does not exist.
+            ValueError: If a filename cannot be determined.
+        """
+        content_bytes: bytes = b""
+        resolved_name: Optional[str] = None
+        if content_string is not None:
+            content_bytes = content_string.encode("utf-8")
+        elif content_file_path:
+            if os.path.exists(content_file_path):
+                with open(content_file_path, "rb") as f:
+                    content_bytes = f.read()
+            else:
+                raise FileNotFoundError(f"File not found: {content_file_path}")
+
+        if file_name:
+            resolved_name = file_name
+        elif content_file_path:
+            resolved_name = os.path.basename(content_file_path)
+        elif not modified:
+            raise ValueError(
+                "Unable to determine filename for multipart upload. "
+                "When providing inline content (content_string), you must also provide file_name. "
+                "Alternatively, set content_file_path so the filename can be inferred. "
+                f"Received file_name={file_name!r}, content_file_path={content_file_path!r}."
+            )
+
+        return content_bytes, resolved_name
+
     @with_lock_retry
     async def perform_structural_migration_async(
         self,
@@ -360,44 +414,37 @@ class StudioClient:
                 (None, deleted_resources_json),
             )
         )
-
         for i, added_resource in enumerate(structural_migration.added_resources):
-            if os.path.exists(added_resource.content_file_path):
-                with open(added_resource.content_file_path, "rb") as f:
-                    content = f.read()
-
-                filename = os.path.basename(added_resource.content_file_path)
-                files.append((f"AddedResources[{i}].Content", (filename, content)))
-
-                if added_resource.parent_path:
-                    files.append(
-                        (
-                            f"AddedResources[{i}].ParentPath",
-                            (None, added_resource.parent_path),
-                        )
-                    )
-            else:
-                raise FileNotFoundError(
-                    f"File not found: {added_resource.content_file_path}"
-                )
+            content_bytes, filename = self._resolve_content_and_filename(
+                content_string=added_resource.content_string,
+                content_file_path=added_resource.content_file_path,
+                file_name=added_resource.file_name,
+            )
 
-        for i, modified_resource in enumerate(structural_migration.modified_resources):
-            if os.path.exists(modified_resource.content_file_path):
-                with open(modified_resource.content_file_path, "rb") as f:
-                    content = f.read()
+            files.append((f"AddedResources[{i}].Content", (filename, content_bytes)))
 
-                filename = os.path.basename(modified_resource.content_file_path)
-                files.append((f"ModifiedResources[{i}].Content", (filename, content)))
+            if added_resource.parent_path:
                 files.append(
                     (
-                        f"ModifiedResources[{i}].Id",
-                        (None, modified_resource.id),
+                        f"AddedResources[{i}].ParentPath",
+                        (None, added_resource.parent_path),
                     )
                 )
-            else:
-                raise FileNotFoundError(
-                    f"File not found: {modified_resource.content_file_path}"
+
+        for i, modified_resource in enumerate(structural_migration.modified_resources):
+            content_bytes, _ = self._resolve_content_and_filename(
+                content_string=modified_resource.content_string,
+                content_file_path=modified_resource.content_file_path,
+                modified=True,
+            )
+
+            files.append((f"ModifiedResources[{i}].Content", content_bytes))
+            files.append(
+                (
+                    f"ModifiedResources[{i}].Id",
+                    (None, modified_resource.id),
                 )
+            )
 
         response = await self.uipath.api_client.request_async(
             "POST",

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/cli_eval.py

@@ -1,7 +1,8 @@
 # type: ignore
+import ast
 import asyncio
 import os
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
 import click
 from dotenv import load_dotenv
@@ -15,9 +16,18 @@ console = ConsoleLogger()
 load_dotenv(override=True)
 
 
+class LiteralOption(click.Option):
+    def type_cast_value(self, ctx, value):
+        try:
+            return ast.literal_eval(value)
+        except Exception as e:
+            raise click.BadParameter(value) from e
+
+
 def eval_agent(
     entrypoint: Optional[str] = None,
     eval_set: Optional[str] = None,
+    eval_ids: Optional[List[str]] = None,
     workers: int = 8,
     no_report: bool = False,
     **kwargs,
@@ -27,6 +37,7 @@ def eval_agent(
     Args:
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not provided)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not provided)
+        eval_ids: Optional list of evaluation IDs
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
         **kwargs: Additional arguments for future extensibility
@@ -41,8 +52,13 @@ def eval_agent(
         if workers < 1:
             return False, "Number of workers must be at least 1", None
 
+        print("EVAL SET")
+        print(eval_set)
+        if eval_set is not None and len(eval_set) == 0:
+            return False, "Evaluation set must not be empty", None
+
         service = EvaluationService(
-            entrypoint, eval_set, workers, report_progress=not no_report
+            entrypoint, eval_set, eval_ids, workers, report_progress=not no_report
         )
         asyncio.run(service.run_evaluation())
 
@@ -55,6 +71,7 @@ def eval_agent(
 @click.command()
 @click.argument("entrypoint", required=False)
 @click.argument("eval_set", required=False)
+@click.option("--eval-ids", cls=LiteralOption, default="[]")
 @click.option(
     "--no-report",
     is_flag=True,
@@ -69,20 +86,28 @@ def eval_agent(
 )
 @track(when=lambda *_a, **_kw: os.getenv(ENV_JOB_ID) is None)
 def eval(
-    entrypoint: Optional[str], eval_set: Optional[str], no_report: bool, workers: int
+    entrypoint: Optional[str],
+    eval_set: Optional[str],
+    eval_ids: List[str],
+    no_report: bool,
+    workers: int,
 ) -> None:
     """Run an evaluation set against the agent.
 
     Args:
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
+        eval_ids: Optional list of evaluation IDs
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
     success, error_message, info_message = eval_agent(
-        entrypoint=entrypoint, eval_set=eval_set, workers=workers, no_report=no_report
+        entrypoint=entrypoint,
+        eval_set=eval_set,
+        eval_ids=eval_ids,
+        workers=workers,
+        no_report=no_report,
     )
-
     if error_message:
         console.error(error_message)
         click.get_current_context().exit(1)

{uipath-2.1.20 → uipath-2.1.22}/src/uipath/_cli/cli_invoke.py

@@ -70,7 +70,6 @@ def invoke(
         url = f"{base_url}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
         _, personal_workspace_folder_id = get_personal_workspace_info(base_url, token)
         project_name, project_version = _read_project_details()
-
         if not personal_workspace_folder_id:
             console.error(
                 "No personal workspace found for user. Please try reauthenticating."