uipath 2.1.23__tar.gz → 2.1.25__tar.gz

{uipath-2.1.23 → uipath-2.1.25}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.23"
+version = "2.1.25"
 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.23 → uipath-2.1.25}/src/uipath/_cli/__init__.py

@@ -3,7 +3,7 @@ import sys
 
 import click
 
-from .cli_auth import auth as auth  # type: ignore
+from .cli_auth import auth as auth
 from .cli_deploy import deploy as deploy  # type: ignore
 from .cli_eval import eval as eval  # type: ignore
 from .cli_init import init as init  # type: ignore

{uipath-2.1.23 → uipath-2.1.25}/src/uipath/_cli/_auth/_client_credentials.py

@@ -70,7 +70,7 @@ class ClientCredentialsService:
             return "cloud"
 
     def authenticate(
-        self, client_id: str, client_secret: str, scope: str = "OR.Execution"
+        self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
     ) -> Optional[TokenData]:
         """Authenticate using client credentials flow.
 

{uipath-2.1.23 → uipath-2.1.25}/src/uipath/_cli/_auth/_oidc_utils.py

@@ -5,6 +5,7 @@ import os
 from urllib.parse import urlencode
 
 from ._models import AuthConfig
+from ._url_utils import build_service_url
 
 
 def generate_code_verifier_and_challenge():
@@ -65,5 +66,5 @@ def get_auth_url(domain: str) -> tuple[str, str, str]:
     }
 
     query_string = urlencode(query_params)
-    url = f"https://{domain}.uipath.com/identity_/connect/authorize?{query_string}"
+    url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
     return url, code_verifier, state

{uipath-2.1.23 → uipath-2.1.25}/src/uipath/_cli/_auth/_portal_service.py

@@ -9,6 +9,7 @@ from ..._utils._ssl_context import get_httpx_client_kwargs
 from .._utils._console import ConsoleLogger
 from ._models import TenantsAndOrganizationInfoResponse, TokenData
 from ._oidc_utils import get_auth_config
+from ._url_utils import build_service_url, get_base_url
 from ._utils import (
     get_auth_data,
     get_parsed_token_data,
@@ -24,7 +25,7 @@ class PortalService:
 
     access_token: Optional[str] = None
     prt_id: Optional[str] = None
-    domain: Optional[str] = None
+    domain: str
     selected_tenant: Optional[str] = None
 
     _client: Optional[httpx.Client] = None
@@ -65,7 +66,10 @@ class PortalService:
         if self._client is None:
             raise RuntimeError("HTTP client is not initialized")
 
-        url = f"https://{self.domain}.uipath.com/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo"
+        url = build_service_url(
+            self.domain,
+            f"/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo",
+        )
         response = self._client.get(
             url, headers={"Authorization": f"Bearer {self.access_token}"}
         )
@@ -90,13 +94,14 @@ class PortalService:
             console.error("Organization not found.")
             return ""
         account_name = organization.get("name")
-        return f"https://{self.domain}.uipath.com/{account_name}/{self.selected_tenant}/orchestrator_"
+        base_url = get_base_url(self.domain)
+        return f"{base_url}/{account_name}/{self.selected_tenant}/orchestrator_"
 
     def post_refresh_token_request(self, refresh_token: str) -> TokenData:
         if self._client is None:
             raise RuntimeError("HTTP client is not initialized")
 
-        url = f"https://{self.domain}.uipath.com/identity_/connect/token"
+        url = build_service_url(self.domain, "/identity_/connect/token")
         client_id = get_auth_config().get("client_id")
 
         data = {
@@ -213,12 +218,15 @@ def select_tenant(
     account_name = tenants_and_organizations["organization"]["name"]
     console.info(f"Selected tenant: {click.style(tenant_name, fg='cyan')}")
 
+    base_url = get_base_url(domain)
+    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
+
     update_env_file(
         {
-            "UIPATH_URL": f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}",
+            "UIPATH_URL": uipath_url,
             "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
             "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
         }
     )
 
-    return f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}"
+    return uipath_url

uipath-2.1.25/src/uipath/_cli/_auth/_url_utils.py

@@ -0,0 +1,41 @@
+import os
+from urllib.parse import urlparse
+
+
+def get_base_url(domain: str) -> str:
+    """Get the base URL for UiPath services.
+
+    Args:
+        domain: Either a domain name (e.g., 'cloud', 'alpha') or a full URL from UIPATH_URL
+
+    Returns:
+        The base URL to use for UiPath services
+    """
+    # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
+    uipath_url = os.getenv("UIPATH_URL")
+    if uipath_url and domain == "cloud":
+        parsed_url = urlparse(uipath_url)
+        return f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+    # If domain is already a full URL, use it directly
+    if domain.startswith("http"):
+        return domain
+
+    # Otherwise, construct the URL using the domain
+    return f"https://{domain if domain else 'cloud'}.uipath.com"
+
+
+def build_service_url(domain: str, path: str) -> str:
+    """Build a service URL by combining the base URL with a path.
+
+    Args:
+        domain: Either a domain name or full URL
+        path: The path to append (should start with /)
+
+    Returns:
+        The complete service URL
+    """
+    base_url = get_base_url(domain)
+    # Remove trailing slash from base_url to avoid double slashes
+    base_url = base_url.rstrip("/")
+    return f"{base_url}{path}"

{uipath-2.1.23 → uipath-2.1.25}/src/uipath/_cli/_auth/index.html

@@ -477,7 +477,15 @@
                 formData.append('client_id', '__PY_REPLACE_CLIENT_ID__');
                 formData.append('code_verifier', codeVerifier);
 
-                const response = await fetch('https://__PY_REPLACE_DOMAIN__.uipath.com/identity_/connect/token', {
+                const domainOrUrl = '__PY_REPLACE_DOMAIN__';
+                let tokenUrl;
+                if (domainOrUrl.startsWith('http')) {
+                    tokenUrl = `${domainOrUrl}/identity_/connect/token`;
+                } else {
+                    tokenUrl = `https://${domainOrUrl}.uipath.com/identity_/connect/token`;
+                }
+
+                const response = await fetch(tokenUrl, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/x-www-form-urlencoded'

{uipath-2.1.23 → uipath-2.1.25}/src/uipath/_cli/cli_auth.py

@@ -1,9 +1,10 @@
-# type: ignore
 import asyncio
 import json
 import os
 import socket
 import webbrowser
+from typing import Optional
+from urllib.parse import urlparse
 
 import click
 from dotenv import load_dotenv
@@ -33,10 +34,10 @@ def is_port_in_use(port: int) -> bool:
 
 def set_port():
     auth_config = get_auth_config()
-    port = auth_config.get("port", 8104)
-    port_option_one = auth_config.get("portOptionOne", 8104)
-    port_option_two = auth_config.get("portOptionTwo", 8055)
-    port_option_three = auth_config.get("portOptionThree", 42042)
+    port = int(auth_config.get("port", 8104))
+    port_option_one = int(auth_config.get("portOptionOne", 8104))  # type: ignore
+    port_option_two = int(auth_config.get("portOptionTwo", 8055))  # type: ignore
+    port_option_three = int(auth_config.get("portOptionThree", 42042))  # type: ignore
     if is_port_in_use(port):
         if is_port_in_use(port_option_one):
             if is_port_in_use(port_option_two):
@@ -81,24 +82,45 @@ def set_port():
     required=False,
     help="Base URL for the UiPath tenant instance (required for client credentials)",
 )
+@click.option(
+    "--scope",
+    required=False,
+    default="OR.Execution",
+    help="Space-separated list of OAuth scopes to request (e.g., 'OR.Execution OR.Queues'). Defaults to 'OR.Execution'",
+)
 @track
 def auth(
     domain,
-    force: None | bool = False,
-    client_id: str = None,
-    client_secret: str = None,
-    base_url: str = None,
+    force: Optional[bool] = False,
+    client_id: Optional[str] = None,
+    client_secret: Optional[str] = None,
+    base_url: Optional[str] = None,
+    scope: Optional[str] = None,
 ):
     """Authenticate with UiPath Cloud Platform.
 
+    The domain for authentication is determined by the UIPATH_URL environment variable if set.
+    Otherwise, it can be specified with --cloud (default), --staging, or --alpha flags.
+
     Interactive mode (default): Opens browser for OAuth authentication.
-    Unattended mode: Use --client-id, --client-secret and --base-url for client credentials flow.
+    Unattended mode: Use --client-id, --client-secret, --base-url and --scope for client credentials flow.
 
     Network options:
     - Set HTTP_PROXY/HTTPS_PROXY/NO_PROXY environment variables for proxy configuration
     - Set REQUESTS_CA_BUNDLE to specify a custom CA bundle for SSL verification
     - Set UIPATH_DISABLE_SSL_VERIFY to disable SSL verification (not recommended)
     """
+    uipath_url = os.getenv("UIPATH_URL")
+    if uipath_url and domain == "cloud":  # "cloud" is the default
+        parsed_url = urlparse(uipath_url)
+        if parsed_url.scheme and parsed_url.netloc:
+            domain = f"{parsed_url.scheme}://{parsed_url.netloc}"
+        else:
+            console.error(
+                f"Malformed UIPATH_URL: '{uipath_url}'. Please ensure it includes both scheme and netloc (e.g., 'https://cloud.uipath.com')."
+            )
+            return
+
     # Check if client credentials are provided for unattended authentication
     if client_id and client_secret:
         if not base_url:
@@ -117,7 +139,9 @@ def auth(
                 )
                 credentials_service.domain = extracted_domain
 
-            token_data = credentials_service.authenticate(client_id, client_secret)
+            token_data = credentials_service.authenticate(
+                client_id, client_secret, scope
+            )
 
             if token_data:
                 credentials_service.setup_environment(token_data, base_url)

uipath-2.1.25/tests/cli/test_auth.py

@@ -0,0 +1,141 @@
+import os
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli.cli_auth import auth
+
+"""
+Unit tests for the 'uipath auth' command.
+
+This test suite covers the following scenarios for the authentication logic:
+
+1.  **UIPATH_URL Environment Variable**: 
+    Ensures the `auth` command correctly uses the domain from the `UIPATH_URL` 
+    environment variable when no specific environment flag is used.
+
+2.  **--alpha Flag**: 
+    Verifies that the `--alpha` flag correctly uses the 'alpha' environment and 
+    overrides the `UIPATH_URL` environment variable if it is set.
+
+3.  **--staging Flag**: 
+    Verifies that the `--staging` flag correctly uses the 'staging' environment and 
+    overrides the `UIPATH_URL` environment variable if it is set.
+
+4.  **--cloud Flag**: 
+    Checks that the `--cloud` flag works as expected, using the 'cloud' environment,
+    when no `UIPATH_URL` environment variable is set.
+
+5.  **Default Behavior**: 
+    Confirms that the command defaults to the 'cloud' environment when no flags 
+    or environment variables are provided.
+"""
+
+
+@pytest.mark.parametrize(
+    "scenario_name, cli_args, env_vars, expected_url_part, expected_select_tenant_return",
+    [
+        (
+            "auth_with_uipath_url_env_variable",
+            ["--force"],
+            {"UIPATH_URL": "https://custom.automationsuite.org/org/tenant"},
+            "https://custom.automationsuite.org/identity_/connect/authorize",
+            "https://custom.automationsuite.org/DefaultOrg/DefaultTenant",
+        ),
+        (
+            "auth_with_uipath_url_env_variable_with_trailing_slash",
+            ["--force"],
+            {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"},
+            "https://custom.uipath.com/identity_/connect/authorize",
+            "https://custom.uipath.com/DefaultOrg/DefaultTenant",
+        ),
+        (
+            "auth_with_alpha_flag",
+            ["--alpha", "--force"],
+            {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+            "https://alpha.uipath.com/identity_/connect/authorize",
+            "https://alpha.uipath.com/DefaultOrg/DefaultTenant",
+        ),
+        (
+            "auth_with_staging_flag",
+            ["--staging", "--force"],
+            {"UIPATH_URL": "https://custom.uipath.com/org/tenant"},
+            "https://staging.uipath.com/identity_/connect/authorize",
+            "https://staging.uipath.com/DefaultOrg/DefaultTenant",
+        ),
+        (
+            "auth_with_cloud_flag",
+            ["--cloud", "--force"],
+            {},
+            "https://cloud.uipath.com/identity_/connect/authorize",
+            "https://cloud.uipath.com/DefaultOrg/DefaultTenant",
+        ),
+        (
+            "auth_default_to_cloud",
+            ["--force"],
+            {},
+            "https://cloud.uipath.com/identity_/connect/authorize",
+            "https://cloud.uipath.com/DefaultOrg/DefaultTenant",
+        ),
+    ],
+    ids=[
+        "uipath_url_env",
+        "alpha_flag_overrides_env",
+        "staging_flag_overrides_env",
+        "cloud_flag",
+        "default_to_cloud",
+        "uipath_url_env_with_trailing_slash",
+    ],
+)
+def test_auth_scenarios(
+    scenario_name, cli_args, env_vars, expected_url_part, expected_select_tenant_return
+):
+    """
+    Test 'uipath auth' with different configurations.
+    """
+    runner = CliRunner()
+    with (
+        patch("uipath._cli.cli_auth.webbrowser.open") as mock_open,
+        patch("uipath._cli.cli_auth.HTTPServer") as mock_server,
+        patch("uipath._cli.cli_auth.PortalService") as mock_portal_service,
+    ):
+        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": "DefaultTenant", "id": "tenant-id"}],
+            "organization": {"name": "DefaultOrg", "id": "org-id"},
+        }
+        mock_portal_service.return_value.__enter__.return_value.select_tenant.return_value = expected_select_tenant_return
+
+        with runner.isolated_filesystem():
+            for key, value in env_vars.items():
+                os.environ[key] = value
+
+            result = runner.invoke(auth, cli_args)
+
+            for key in env_vars:
+                del os.environ[key]
+
+            assert result.exit_code == 0, (
+                f"Scenario '{scenario_name}' failed with exit code {result.exit_code}: {result.output}"
+            )
+            mock_open.assert_called_once()
+            call_args = mock_open.call_args[0][0]
+            assert expected_url_part in call_args
+
+
+def test_auth_with_malformed_url():
+    """
+    Test that 'uipath auth' handles a malformed UIPATH_URL gracefully.
+    """
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        os.environ["UIPATH_URL"] = "custom.uipath.com"
+        result = runner.invoke(auth, ["--force"])
+        del os.environ["UIPATH_URL"]
+
+        assert result.exit_code == 1
+        assert "Malformed UIPATH_URL" in result.output
+        assert "custom.uipath.com" in result.output