uipath 2.1.62__tar.gz → 2.1.64__tar.gz

{uipath-2.1.62 → uipath-2.1.64}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.62"
+version = "2.1.64"
 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.62 → uipath-2.1.64}/src/uipath/_cli/_auth/_auth_service.py

@@ -9,7 +9,11 @@ from urllib.parse import urlparse
 from uipath._cli._auth._auth_server import HTTPServer
 from uipath._cli._auth._client_credentials import ClientCredentialsService
 from uipath._cli._auth._oidc_utils import OidcUtils
-from uipath._cli._auth._portal_service import PortalService, select_tenant
+from uipath._cli._auth._portal_service import (
+    PortalService,
+    get_tenant_id,
+    select_tenant,
+)
 from uipath._cli._auth._url_utils import set_force_flag
 from uipath._cli._auth._utils import update_auth_file, update_env_file
 from uipath._cli._utils._console import ConsoleLogger
@@ -24,6 +28,7 @@ class AuthService:
         client_id: Optional[str],
         client_secret: Optional[str],
         base_url: Optional[str],
+        tenant: Optional[str],
         scope: Optional[str],
     ):
         self._force = force
@@ -32,6 +37,7 @@ class AuthService:
         self._client_id = client_id
         self._client_secret = client_secret
         self._base_url = base_url
+        self._tenant = tenant
         self._scope = scope
         set_force_flag(self._force)
 
@@ -108,7 +114,14 @@ class AuthService:
             update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
 
             tenants_and_organizations = portal_service.get_tenants_and_organizations()
-            base_url = select_tenant(self._domain, tenants_and_organizations)
+
+            if self._tenant:
+                base_url = get_tenant_id(
+                    self._domain, self._tenant, tenants_and_organizations
+                )
+            else:
+                base_url = select_tenant(self._domain, tenants_and_organizations)
+
             try:
                 portal_service.post_auth(base_url)
             except Exception:

{uipath-2.1.62 → uipath-2.1.64}/src/uipath/_cli/_auth/_portal_service.py

@@ -231,3 +231,32 @@ def select_tenant(
     )
 
     return uipath_url
+
+
+def get_tenant_id(
+    domain: str,
+    tenant_name: str,
+    tenants_and_organizations: TenantsAndOrganizationInfoResponse,
+) -> str:
+    tenants = tenants_and_organizations["tenants"]
+
+    matched_tenant = next((t for t in tenants if t["name"] == tenant_name), None)
+    if not matched_tenant:
+        console.error(f"Tenant '{tenant_name}' not found.")
+        raise ValueError(f"Tenant '{tenant_name}' not found.")
+
+    domain = get_base_url(domain)
+    account_name = tenants_and_organizations["organization"]["name"]
+
+    base_url = get_base_url(domain)
+    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
+
+    update_env_file(
+        {
+            "UIPATH_URL": uipath_url,
+            "UIPATH_TENANT_ID": matched_tenant["id"],
+            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
+        }
+    )
+
+    return uipath_url

{uipath-2.1.62 → uipath-2.1.64}/src/uipath/_cli/_evals/_progress_reporter.py

@@ -59,7 +59,9 @@ def gracefully_handle_errors(func):
 class StudioWebProgressReporter:
     """Handles reporting evaluation progress to StudioWeb."""
 
-    def __init__(self):
+    def __init__(self, spans_exporter: LlmOpsHttpExporter):
+        self.spans_exporter = spans_exporter
+
         logging.getLogger("uipath._cli.middlewares").setLevel(logging.CRITICAL)
         console_logger = ConsoleLogger.get_instance()
         uipath = UiPath()
@@ -199,11 +201,11 @@ class StudioWebProgressReporter:
 
     async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
         try:
-            spans_exporter = LlmOpsHttpExporter(
-                trace_id=self.eval_set_run_ids.get(payload.execution_id),
+            self.spans_exporter.trace_id = self.eval_set_run_ids.get(
+                payload.execution_id
             )
 
-            spans_exporter.export(payload.spans)
+            self.spans_exporter.export(payload.spans)
 
             for eval_result in payload.eval_results:
                 evaluator_id = eval_result.evaluator_id

{uipath-2.1.62 → uipath-2.1.64}/src/uipath/_cli/_utils/_project_files.py

@@ -330,6 +330,10 @@ def files_to_include(
     """
     file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]
     files_included = ["pyproject.toml"]
+    files_excluded = []
+
+    if directories_to_ignore is None:
+        directories_to_ignore = []
     if include_uv_lock:
         files_included += ["uv.lock"]
     if "settings" in config_data:
@@ -338,8 +342,10 @@ def files_to_include(
             file_extensions_included.extend(settings["fileExtensionsIncluded"])
         if "filesIncluded" in settings:
             files_included.extend(settings["filesIncluded"])
-    if directories_to_ignore is None:
-        directories_to_ignore = []
+        if "filesExcluded" in settings:
+            files_excluded.extend(settings["filesExcluded"])
+        if "directoriesExcluded" in settings:
+            directories_to_ignore.extend(settings["directoriesExcluded"])
 
     def is_venv_dir(d: str) -> bool:
         """Check if a directory is a Python virtual environment.
@@ -359,20 +365,63 @@ def files_to_include(
     extra_files: list[FileInfo] = []
     # Walk through directory and return all files in the allowlist
     for root, dirs, files in os.walk(directory):
-        # Skip all directories that start with . or are a venv
-        dirs[:] = [
-            d
-            for d in dirs
-            if not d.startswith(".")
-            and not is_venv_dir(os.path.join(root, d))
-            and (directories_to_ignore is not None and d not in directories_to_ignore)
-        ]
+        # Skip all directories that start with . or are a venv or are excluded
+        included_dirs = []
+        for d in dirs:
+            if d.startswith(".") or is_venv_dir(os.path.join(root, d)):
+                continue
+
+            # Check if directory should be excluded
+            dir_path = os.path.join(root, d)
+            dir_rel_path = os.path.relpath(dir_path, directory)
+            normalized_dir_rel_path = dir_rel_path.replace(os.sep, "/")
+
+            # Check exclusion: by dirname (for root level) or by relative path
+            should_exclude_dir = (
+                (
+                    (
+                        d in directories_to_ignore and normalized_dir_rel_path == d
+                    )  # name match for root level only
+                    or normalized_dir_rel_path
+                    in directories_to_ignore  # path match for nested directories
+                )
+                if directories_to_ignore is not None
+                else False
+            )
+
+            if not should_exclude_dir:
+                included_dirs.append(d)
+
+        dirs[:] = included_dirs
         for file in files:
             file_extension = os.path.splitext(file)[1].lower()
-            if file_extension in file_extensions_included or file in files_included:
-                file_path = os.path.join(root, file)
-                file_name = os.path.basename(file_path)
-                rel_path = os.path.relpath(file_path, directory)
+            file_path = os.path.join(root, file)
+            file_name = os.path.basename(file_path)
+            rel_path = os.path.relpath(file_path, directory)
+
+            # Normalize the path
+            normalized_rel_path = rel_path.replace(os.sep, "/")
+
+            # Check inclusion: by extension, by filename (for base directory), or by relative path
+            should_include = (
+                file_extension in file_extensions_included
+                or (
+                    file in files_included and normalized_rel_path == file
+                )  # filename match for base directory only
+                or normalized_rel_path
+                in files_included  # path match for subdirectories
+            )
+
+            # Check exclusion: by filename (for base directory only) or by relative path
+            should_exclude = (
+                (
+                    file in files_excluded and normalized_rel_path == file
+                )  # filename match for base directory only
+                or normalized_rel_path
+                in files_excluded  # path match for subdirectories
+            )
+
+            if should_include and not should_exclude:
                 extra_files.append(
                     FileInfo(
                         file_name=file_name,

{uipath-2.1.62 → uipath-2.1.64}/src/uipath/_cli/cli_auth.py

@@ -35,6 +35,11 @@ console = ConsoleLogger()
     required=False,
     help="Base URL for the UiPath tenant instance (required for client credentials)",
 )
+@click.option(
+    "--tenant",
+    required=False,
+    help="Tenant name within UiPath Automation Cloud",
+)
 @click.option(
     "--scope",
     required=False,
@@ -48,6 +53,7 @@ def auth(
     client_id: Optional[str] = None,
     client_secret: Optional[str] = None,
     base_url: Optional[str] = None,
+    tenant: Optional[str] = None,
     scope: Optional[str] = None,
 ):
     """Authenticate with UiPath Cloud Platform.
@@ -69,6 +75,7 @@ def auth(
         client_id=client_id,
         client_secret=client_secret,
         base_url=base_url,
+        tenant=tenant,
         scope=scope,
     )
     with console.spinner("Authenticating with UiPath ..."):

{uipath-2.1.62 → uipath-2.1.64}/src/uipath/_cli/cli_eval.py

@@ -101,7 +101,7 @@ def eval(
         event_bus = EventBus()
 
         if not no_report:
-            progress_reporter = StudioWebProgressReporter()
+            progress_reporter = StudioWebProgressReporter(LlmOpsHttpExporter())
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
 
         def generate_runtime_context(**context_kwargs) -> UiPathRuntimeContext:

{uipath-2.1.62 → uipath-2.1.64}/tests/cli/test_auth.py

@@ -146,3 +146,47 @@ class TestAuth:
             assert result.exit_code == 1
             assert "Malformed UIPATH_URL" in result.output
             assert "custom.uipath.com" in result.output
+
+    def test_auth_with_tenant_flag(self):
+        """
+        Test that providing --tenant bypasses interactive tenant selection
+        and uses the specified tenant name.
+        """
+        runner = CliRunner()
+        with (
+            patch("uipath._cli._auth._auth_service.webbrowser.open") as mock_open,
+            patch("uipath._cli._auth._auth_service.HTTPServer") as mock_server,
+            patch(
+                "uipath._cli._auth._auth_service.PortalService"
+            ) as mock_portal_service,
+            patch(
+                "uipath._cli._auth._auth_service.select_tenant"
+            ) as mock_select_tenant,
+            patch(
+                "uipath._cli._auth._url_utils.get_base_url",
+                return_value="https://alpha.uipath.com",
+            ),
+        ):
+            mock_server.return_value.start = AsyncMock(
+                return_value={"access_token": "test_token"}
+            )
+
+            mock_portal_service.return_value.__enter__.return_value.get_tenants_and_organizations.return_value = {
+                "tenants": [
+                    {"name": "MyTenantName", "id": "tenant-id"},
+                    {"name": "OtherTenant", "id": "other-id"},
+                ],
+                "organization": {"name": "MyOrg", "id": "org-id"},
+            }
+
+            result = runner.invoke(
+                cli, ["auth", "--alpha", "--tenant", "MyTenantName", "--force"]
+            )
+
+            assert result.exit_code == 0, result.output
+            mock_open.assert_called_once()
+
+            assert not mock_select_tenant.called
+
+            portal = mock_portal_service.return_value.__enter__.return_value
+            assert portal.get_tenants_and_organizations.called

{uipath-2.1.62 → uipath-2.1.64}/tests/cli/test_pack.py

@@ -614,3 +614,256 @@ class TestPack:
                 assert "content/uv.lock" not in actual_files, (
                     "uv.lock should not be in nupkg when --nolock is used"
                 )
+
+    def test_files_excluded(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that files mentioned in filesExcluded are excluded from the package."""
+        json_file_to_exclude = "config.json"
+        json_file_to_include = "other.json"
+
+        # Set up exclusions
+        uipath_json.settings.files_excluded = [json_file_to_exclude]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                f.write(uipath_json.to_json())
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create files - .json files are included by default
+            with open(json_file_to_exclude, "w") as f:
+                f.write('{"should": "be excluded"}')
+            with open(json_file_to_include, "w") as f:
+                f.write('{"should": "be included"}')
+
+            result = runner.invoke(cli, ["pack", "./"])
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Excluded file should not be present
+                assert f"content/{json_file_to_exclude}" not in z.namelist()
+                # Other JSON file should still be present
+                assert f"content/{json_file_to_include}" in z.namelist()
+
+    def test_files_excluded_takes_precedence_over_included(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that filesExcluded takes precedence over filesIncluded."""
+        conflicting_file = "conflicting.txt"
+
+        # Set up both inclusion and exclusion for the same file
+        uipath_json.settings.files_included = [conflicting_file]
+        uipath_json.settings.files_excluded = [conflicting_file]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                f.write(uipath_json.to_json())
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create the conflicting file
+            with open(conflicting_file, "w") as f:
+                f.write("This file should be excluded despite being in filesIncluded")
+
+            result = runner.invoke(cli, ["pack", "./"])
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # File should be excluded (exclusion takes precedence)
+                assert f"content/{conflicting_file}" not in z.namelist()
+
+    def test_filename_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that filename exclusion only affects root directory, path exclusion affects specific paths."""
+        # Exclude root config.json and specific path subdir2/settings.json
+        uipath_json.settings.files_excluded = ["config.json", "subdir2/settings.json"]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                f.write(uipath_json.to_json())
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create directories
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            # Create files with same names in different locations
+            with open("config.json", "w") as f:  # Root - should be excluded
+                f.write('{"root": "config"}')
+            with open("subdir1/config.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir1": "config"}')
+            with open("subdir2/config.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir2": "config"}')
+
+            with open("settings.json", "w") as f:  # Root - should be included
+                f.write('{"root": "settings"}')
+            with open("subdir1/settings.json", "w") as f:  # Subdir - should be included
+                f.write('{"subdir1": "settings"}')
+            with open(
+                "subdir2/settings.json", "w"
+            ) as f:  # Specific path - should be excluded
+                f.write('{"subdir2": "settings"}')
+
+            result = runner.invoke(cli, ["pack", "./"])
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Filename exclusion: only affects root directory
+                assert "content/config.json" not in z.namelist()  # Root excluded
+                assert "content/subdir1/config.json" in z.namelist()  # Subdir included
+                assert "content/subdir2/config.json" in z.namelist()  # Subdir included
+
+                # Path exclusion: only affects specific path
+                assert "content/settings.json" in z.namelist()  # Root included
+                assert (
+                    "content/subdir1/settings.json" in z.namelist()
+                )  # Different path included
+                assert (
+                    "content/subdir2/settings.json" not in z.namelist()
+                )  # Specific path excluded
+
+    def test_filename_vs_path_inclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that filename inclusion only affects root directory, path inclusion affects specific paths."""
+        # Include root data.txt and specific path subdir2/config.txt
+        uipath_json.settings.files_included = ["data.txt", "subdir1/config.txt"]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                f.write(uipath_json.to_json())
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create directories
+            os.mkdir("subdir1")
+            os.mkdir("subdir2")
+
+            # Create .txt files (not included by default extension)
+            with open("data.txt", "w") as f:  # Root - should be included by filename
+                f.write("root data")
+            with open("subdir1/data.txt", "w") as f:  # Subdir - should NOT be included
+                f.write("subdir1 data")
+            with open(
+                "subdir2/data.txt", "w"
+            ) as f:  # Different subdir - should NOT be included
+                f.write("subdir2 data")
+
+            with open("config.txt", "w") as f:  # Root - should NOT be included
+                f.write("root config")
+            with open(
+                "subdir1/config.txt", "w"
+            ) as f:  # Specific path - should be included
+                f.write("subdir1 config")
+            with open(
+                "subdir2/config.txt", "w"
+            ) as f:  # Different path - should NOT be included
+                f.write("subdir2 config")
+
+            result = runner.invoke(cli, ["pack", "./"])
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Filename inclusion: only affects root directory
+                assert "content/data.txt" in z.namelist()  # Root included
+                assert (
+                    "content/subdir1/data.txt" not in z.namelist()
+                )  # Subdir not included
+                assert (
+                    "content/subdir2/data.txt" not in z.namelist()
+                )  # Subdir not included
+
+                # Path inclusion: only affects specific path
+                assert "content/config.txt" not in z.namelist()  # Root not included
+                assert (
+                    "content/subdir1/config.txt" in z.namelist()
+                )  # Specific path included
+                assert (
+                    "content/subdir2/config.txt" not in z.namelist()
+                )  # Different path not included
+
+    def test_directory_name_vs_path_exclusion(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that directory exclusion by name only affects root level, by path affects specific paths."""
+        # Exclude root-level "temp" directory and specific path "tests/old"
+        uipath_json.settings.directories_excluded = ["temp", "tests/old"]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            with open("uipath.json", "w") as f:
+                f.write(uipath_json.to_json())
+            with open("pyproject.toml", "w") as f:
+                f.write(project_details.to_toml())
+
+            # Create directory structure
+            os.makedirs("temp")  # Root level - should be excluded
+            os.makedirs("src/temp")  # Nested - should be included
+            os.makedirs("tests/old")  # Specific path - should be excluded
+            os.makedirs("tests/new")  # Different path - should be included
+            os.makedirs("old")  # Root level - should be included
+
+            # Create JSON files in each directory (included by default)
+            with open("temp/config.json", "w") as f:
+                f.write('{"location": "root temp"}')
+            with open("src/temp/config.json", "w") as f:
+                f.write('{"location": "src temp"}')
+            with open("tests/old/config.json", "w") as f:
+                f.write('{"location": "tests old"}')
+            with open("tests/new/config.json", "w") as f:
+                f.write('{"location": "tests new"}')
+            with open("old/config.json", "w") as f:
+                f.write('{"location": "root old"}')
+
+            result = runner.invoke(cli, ["pack", "./"])
+            assert result.exit_code == 0
+
+            with zipfile.ZipFile(
+                f".uipath/{project_details.name}.{project_details.version}.nupkg", "r"
+            ) as z:
+                # Directory name exclusion: only affects root level
+                assert (
+                    "content/temp/config.json" not in z.namelist()
+                )  # Root temp excluded
+                assert (
+                    "content/src/temp/config.json" in z.namelist()
+                )  # Nested temp included
+
+                # Directory path exclusion: only affects specific path
+                assert (
+                    "content/tests/old/config.json" not in z.namelist()
+                )  # Specific path excluded
+                assert (
+                    "content/tests/new/config.json" in z.namelist()
+                )  # Different path included
+                assert "content/old/config.json" in z.namelist()  # Root old included