uipath 2.0.72__py3-none-any.whl → 2.0.74__py3-none-any.whl

uipath/_cli/_auth/_client_credentials.py

@@ -0,0 +1,146 @@
+from typing import Optional
+from urllib.parse import urlparse
+
+import httpx
+
+from ..._utils._ssl_context import get_httpx_client_kwargs
+from .._utils._console import ConsoleLogger
+from ._models import TokenData
+from ._utils import parse_access_token, update_env_file
+
+console = ConsoleLogger()
+
+
+class ClientCredentialsService:
+    """Service for client credentials authentication flow."""
+
+    def __init__(self, domain: str):
+        self.domain = domain
+
+    def get_token_url(self) -> str:
+        """Get the token URL for the specified domain."""
+        match self.domain:
+            case "alpha":
+                return "https://alpha.uipath.com/identity_/connect/token"
+            case "staging":
+                return "https://staging.uipath.com/identity_/connect/token"
+            case _:  # cloud (default)
+                return "https://cloud.uipath.com/identity_/connect/token"
+
+    def _is_valid_domain_or_subdomain(self, hostname: str, domain: str) -> bool:
+        """Check if hostname is either an exact match or a valid subdomain of the domain.
+
+        Args:
+            hostname: The hostname to check
+            domain: The domain to validate against
+
+        Returns:
+            True if hostname is valid domain or subdomain, False otherwise
+        """
+        return hostname == domain or hostname.endswith(f".{domain}")
+
+    def extract_domain_from_base_url(self, base_url: str) -> str:
+        """Extract domain from base URL.
+
+        Args:
+            base_url: The base URL to extract domain from
+
+        Returns:
+            The domain (alpha, staging, or cloud)
+        """
+        try:
+            parsed = urlparse(base_url)
+            hostname = parsed.hostname
+
+            if hostname:
+                match hostname:
+                    case h if self._is_valid_domain_or_subdomain(h, "alpha.uipath.com"):
+                        return "alpha"
+                    case h if self._is_valid_domain_or_subdomain(
+                        h, "staging.uipath.com"
+                    ):
+                        return "staging"
+                    case h if self._is_valid_domain_or_subdomain(h, "cloud.uipath.com"):
+                        return "cloud"
+
+            # Default to cloud if we can't determine
+            return "cloud"
+        except Exception:
+            # Default to cloud if parsing fails
+            return "cloud"
+
+    def authenticate(
+        self, client_id: str, client_secret: str, scope: str = "OR.Execution"
+    ) -> Optional[TokenData]:
+        """Authenticate using client credentials flow.
+
+        Args:
+            client_id: The client ID for authentication
+            client_secret: The client secret for authentication
+            scope: The scope for the token (default: OR.Execution)
+
+        Returns:
+            Token data if successful, None otherwise
+        """
+        token_url = self.get_token_url()
+
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "scope": scope,
+        }
+
+        try:
+            with httpx.Client(**get_httpx_client_kwargs()) as client:
+                response = client.post(token_url, data=data)
+                match response.status_code:
+                    case 200:
+                        token_data = response.json()
+                        return {
+                            "access_token": token_data["access_token"],
+                            "token_type": token_data.get("token_type", "Bearer"),
+                            "expires_in": token_data.get("expires_in", 3600),
+                            "scope": token_data.get("scope", scope),
+                            # Client credentials flow doesn't provide these, but we need them for compatibility
+                            "refresh_token": "",
+                            "id_token": "",
+                        }
+                    case 400:
+                        console.error(
+                            "Invalid client credentials or request parameters."
+                        )
+                        return None
+                    case 401:
+                        console.error("Unauthorized: Invalid client credentials.")
+                        return None
+                    case _:
+                        console.error(
+                            f"Authentication failed: {response.status_code} - {response.text}"
+                        )
+                        return None
+
+        except httpx.RequestError as e:
+            console.error(f"Network error during authentication: {e}")
+            return None
+        except Exception as e:
+            console.error(f"Unexpected error during authentication: {e}")
+            return None
+
+    def setup_environment(self, token_data: TokenData, base_url: str):
+        """Setup environment variables for client credentials authentication.
+
+        Args:
+            token_data: The token data from authentication
+            base_url: The base URL for the UiPath instance
+        """
+        parsed_access_token = parse_access_token(token_data["access_token"])
+
+        env_vars = {
+            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
+            "UIPATH_URL": base_url,
+            "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
+            "UIPATH_TENANT_ID": "",
+        }
+
+        update_env_file(env_vars)

uipath/_cli/_auth/_portal_service.py

@@ -5,6 +5,7 @@ from typing import Optional
 import click
 import httpx
 
+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
@@ -16,7 +17,6 @@ from ._utils import (
 )
 
 console = ConsoleLogger()
-client = httpx.Client(follow_redirects=True, timeout=30.0)
 
 
 class PortalService:
@@ -27,6 +27,8 @@ class PortalService:
     domain: Optional[str] = None
     selected_tenant: Optional[str] = None
 
+    _client: Optional[httpx.Client] = None
+
     _tenants_and_organizations: Optional[TenantsAndOrganizationInfoResponse] = None
 
     def __init__(
@@ -39,13 +41,32 @@ class PortalService:
         self.access_token = access_token
         self.prt_id = prt_id
 
+        self._client = httpx.Client(**get_httpx_client_kwargs())
+
+    def close(self):
+        """Explicitly close the HTTP client."""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+    def __enter__(self):
+        """Enter the runtime context related to this object."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Exit the runtime context and close the HTTP client."""
+        self.close()
+
     def update_token_data(self, token_data: TokenData):
         self.access_token = token_data["access_token"]
         self.prt_id = get_parsed_token_data(token_data).get("prt_id")
 
     def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
+        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"
-        response = client.get(
+        response = self._client.get(
             url, headers={"Authorization": f"Bearer {self.access_token}"}
         )
         if response.status_code < 400:
@@ -72,6 +93,9 @@ class PortalService:
         return f"https://{self.domain}.uipath.com/{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"
         client_id = get_auth_config().get("client_id")
 
@@ -83,7 +107,7 @@ class PortalService:
 
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
 
-        response = client.post(url, data=data, headers=headers)
+        response = self._client.post(url, data=data, headers=headers)
         if response.status_code < 400:
             return response.json()
         elif response.status_code == 401:
@@ -137,6 +161,9 @@ class PortalService:
         update_env_file(updated_env_contents)
 
     def post_auth(self, base_url: str) -> None:
+        if self._client is None:
+            raise RuntimeError("HTTP client is not initialized")
+
         or_base_url = (
             f"{base_url}/orchestrator_"
             if base_url
@@ -148,7 +175,7 @@ class PortalService:
 
         try:
             [try_enable_first_run_response, acquire_license_response] = [
-                client.post(
+                self._client.post(
                     url,
                     headers={"Authorization": f"Bearer {self.access_token}"},
                 )

uipath/_cli/_auth/auth_config.json

@@ -1,6 +1,6 @@
 {
   "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
   "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
-  "scope": "offline_access OrchestratorApiUserAccess ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization",
+  "scope": "offline_access OrchestratorApiUserAccess IdentityServerApi ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization",
   "port": 8104
-}
+}

uipath/_cli/_utils/_folders.py

@@ -2,27 +2,34 @@ from typing import Optional, Tuple
 
 import httpx
 
+from ..._utils._ssl_context import get_httpx_client_kwargs
 from ._console import ConsoleLogger
 
 console = ConsoleLogger()
-client = httpx.Client(follow_redirects=True, timeout=30.0)
 
 
 def get_personal_workspace_info(
     base_url: str, token: str
 ) -> Tuple[Optional[str], Optional[str]]:
     user_url = f"{base_url}/orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended?$expand=PersonalWorkspace"
-    user_response = client.get(user_url, headers={"Authorization": f"Bearer {token}"})
 
-    if user_response.status_code != 200:
-        console.error("Error: Failed to fetch user info. Please try reauthenticating.")
+    with httpx.Client(**get_httpx_client_kwargs()) as client:
+        user_response = client.get(
+            user_url, headers={"Authorization": f"Bearer {token}"}
+        )
 
-    user_data = user_response.json()
-    feed_id = user_data.get("PersonalWorskpaceFeedId")
-    personal_workspace = user_data.get("PersonalWorkspace")
+        if user_response.status_code != 200:
+            console.error(
+                "Error: Failed to fetch user info. Please try reauthenticating."
+            )
+            return None, None
 
-    if not personal_workspace or not feed_id or "Id" not in personal_workspace:
-        return None, None
+        user_data = user_response.json()
+        feed_id = user_data.get("PersonalWorskpaceFeedId")
+        personal_workspace = user_data.get("PersonalWorkspace")
 
-    folder_id = personal_workspace.get("Id")
-    return feed_id, folder_id
+        if not personal_workspace or not feed_id or "Id" not in personal_workspace:
+            return None, None
+
+        folder_id = personal_workspace.get("Id")
+        return feed_id, folder_id

uipath/_cli/_utils/_processes.py

@@ -4,10 +4,10 @@ from typing import Any
 
 import httpx
 
+from ..._utils._ssl_context import get_httpx_client_kwargs
 from ._console import ConsoleLogger
 
 console = ConsoleLogger()
-client = httpx.Client(follow_redirects=True, timeout=30.0)
 odata_top_filter = 25
 
 
@@ -24,26 +24,31 @@ def get_release_info(
     }
 
     release_url = f"{base_url}/orchestrator_/odata/Releases/UiPath.Server.Configuration.OData.ListReleases?$select=Id,Key,ProcessVersion&$top={odata_top_filter}&$filter=ProcessKey%20eq%20%27{urllib.parse.quote(package_name)}%27"
-    response = client.get(release_url, headers=headers)
-    if response.status_code == 200:
-        try:
-            data = json.loads(response.text)
-            process = next(
-                process
-                for process in data["value"]
-                if process["ProcessVersion"] == package_version
-            )
-            release_id = process["Id"]
-            release_key = process["Key"]
-            return release_id, release_key
-        except KeyError:
-            console.warning("Warning: Failed to deserialize release data")
-            return None, None
-        except StopIteration:
-            console.error(
-                f"Error: No process with name '{package_name}' found in your workspace. Please publish the process first."
+
+    with httpx.Client(**get_httpx_client_kwargs()) as client:
+        response = client.get(release_url, headers=headers)
+
+        if response.status_code == 200:
+            try:
+                data = json.loads(response.text)
+                process = next(
+                    process
+                    for process in data["value"]
+                    if process["ProcessVersion"] == package_version
+                )
+                release_id = process["Id"]
+                release_key = process["Key"]
+                return release_id, release_key
+            except KeyError:
+                console.warning("Warning: Failed to deserialize release data")
+                return None, None
+            except StopIteration:
+                console.error(
+                    f"Error: No process with name '{package_name}' found in your workspace. Please publish the process first."
+                )
+                return None, None
+        else:
+            console.warning(
+                f"Warning: Failed to fetch release info {response.status_code}"
             )
             return None, None
-    else:
-        console.warning(f"Warning: Failed to fetch release info {response.status_code}")
-        return None, None

uipath/_cli/cli_auth.py

@@ -9,6 +9,7 @@ from dotenv import load_dotenv
 
 from ..telemetry import track
 from ._auth._auth_server import HTTPServer
+from ._auth._client_credentials import ClientCredentialsService
 from ._auth._oidc_utils import get_auth_config, get_auth_url
 from ._auth._portal_service import PortalService, select_tenant
 from ._auth._utils import update_auth_file, update_env_file
@@ -64,60 +65,123 @@ def set_port():
     required=False,
     help="Force new token",
 )
+@click.option(
+    "--client-id",
+    required=False,
+    help="Client ID for client credentials authentication (unattended mode)",
+)
+@click.option(
+    "--client-secret",
+    required=False,
+    help="Client secret for client credentials authentication (unattended mode)",
+)
+@click.option(
+    "--base-url",
+    required=False,
+    help="Base URL for the UiPath tenant instance (required for client credentials)",
+)
 @track
-def auth(domain, force: None | bool = False):
-    """Authenticate with UiPath Cloud Platform."""
-    with console.spinner("Authenticating with UiPath ..."):
-        portal_service = PortalService(domain)
-
-        if not force:
-            if (
-                os.getenv("UIPATH_URL")
-                and os.getenv("UIPATH_TENANT_ID")
-                and os.getenv("UIPATH_ORGANIZATION_ID")
-            ):
-                try:
-                    portal_service.ensure_valid_token()
-                    console.success(
-                        "Authentication successful.",
-                    )
-                    return
-                except Exception:
-                    console.info(
-                        "Authentication token is invalid. Please reauthenticate.",
-                    )
-
-        auth_url, code_verifier, state = get_auth_url(domain)
-
-        webbrowser.open(auth_url, 1)
-        auth_config = get_auth_config()
+def auth(
+    domain,
+    force: None | bool = False,
+    client_id: str = None,
+    client_secret: str = None,
+    base_url: str = None,
+):
+    """Authenticate with UiPath Cloud Platform.
+
+    Interactive mode (default): Opens browser for OAuth authentication.
+    Unattended mode: Use --client-id, --client-secret and --base-url 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)
+    """
+    # Check if client credentials are provided for unattended authentication
+    if client_id and client_secret:
+        if not base_url:
+            console.error(
+                "--base-url is required when using client credentials authentication."
+            )
+            return
 
-        console.link(
-            "If a browser window did not open, please open the following URL in your browser:",
-            auth_url,
-        )
+        with console.spinner("Authenticating with client credentials ..."):
+            credentials_service = ClientCredentialsService(domain)
 
-        server = HTTPServer(port=auth_config["port"])
-        token_data = server.start(state, code_verifier, domain)
+            # If base_url is provided, extract domain from it to override the CLI domain parameter
+            if base_url:
+                extracted_domain = credentials_service.extract_domain_from_base_url(
+                    base_url
+                )
+                credentials_service.domain = extracted_domain
 
-        if token_data:
-            portal_service.update_token_data(token_data)
-            update_auth_file(token_data)
-            access_token = token_data["access_token"]
-            update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
+            token_data = credentials_service.authenticate(client_id, client_secret)
 
-            tenants_and_organizations = portal_service.get_tenants_and_organizations()
-            base_url = select_tenant(domain, tenants_and_organizations)
-            try:
-                portal_service.post_auth(base_url)
+            if token_data:
+                credentials_service.setup_environment(token_data, base_url)
                 console.success(
-                    "Authentication successful.",
+                    "Client credentials authentication successful.",
                 )
-            except Exception:
+            else:
                 console.error(
-                    "Could not prepare the environment. Please try again.",
+                    "Client credentials authentication failed. Please check your credentials.",
                 )
-        else:
-            console.error(
-                "Authentication failed. Please try again.",
+        return
+
+    # Interactive authentication flow (existing logic)
+    with console.spinner("Authenticating with UiPath ..."):
+        with PortalService(domain) as portal_service:
+            if not force:
+                if (
+                    os.getenv("UIPATH_URL")
+                    and os.getenv("UIPATH_TENANT_ID")
+                    and os.getenv("UIPATH_ORGANIZATION_ID")
+                ):
+                    try:
+                        portal_service.ensure_valid_token()
+                        console.success(
+                            "Authentication successful.",
+                        )
+                        return
+                    except Exception:
+                        console.info(
+                            "Authentication token is invalid. Please reauthenticate.",
+                        )
+
+            auth_url, code_verifier, state = get_auth_url(domain)
+
+            webbrowser.open(auth_url, 1)
+            auth_config = get_auth_config()
+
+            console.link(
+                "If a browser window did not open, please open the following URL in your browser:",
+                auth_url,
             )
+
+            server = HTTPServer(port=auth_config["port"])
+            token_data = server.start(state, code_verifier, domain)
+
+            if token_data:
+                portal_service.update_token_data(token_data)
+                update_auth_file(token_data)
+                access_token = token_data["access_token"]
+                update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
+
+                tenants_and_organizations = (
+                    portal_service.get_tenants_and_organizations()
+                )
+                base_url = select_tenant(domain, tenants_and_organizations)
+                try:
+                    portal_service.post_auth(base_url)
+                    console.success(
+                        "Authentication successful.",
+                    )
+                except Exception:
+                    console.error(
+                        "Could not prepare the environment. Please try again.",
+                    )
+            else:
+                console.error(
+                    "Authentication failed. Please try again.",
+                )

uipath/_cli/cli_invoke.py

@@ -14,6 +14,7 @@ try:
 except ImportError:
     import tomli as tomllib
 
+from .._utils._ssl_context import get_httpx_client_kwargs
 from ..telemetry import track
 from ._utils._common import get_env_vars
 from ._utils._folders import get_personal_workspace_info
@@ -22,7 +23,6 @@ from ._utils._processes import get_release_info
 logger = logging.getLogger(__name__)
 load_dotenv(override=True)
 console = ConsoleLogger()
-client = httpx.Client(follow_redirects=True, timeout=30.0)
 
 
 def _read_project_details() -> [str, str]:
@@ -92,23 +92,24 @@ def invoke(
             "x-uipath-organizationunitid": str(personal_workspace_folder_id),
         }
 
-        response = client.post(url, json=payload, headers=headers)
-
-    if response.status_code == 201:
-        job_key = None
-        try:
-            job_key = response.json()["value"][0]["Key"]
-        except KeyError:
-            console.error("Error: Failed to get job key from response")
-        if job_key:
-            with console.spinner("Starting job ..."):
-                job_url = f"{base_url}/orchestrator_/jobs(sidepanel:sidepanel/jobs/{job_key}/details)?fid={personal_workspace_folder_id}"
-                console.magic("Job started successfully!")
-                console.link("Monitor your job here: ", job_url)
-    else:
-        console.error(
-            f"Error: Failed to start job. Status code: {response.status_code} {response.text}"
-        )
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
+            response = client.post(url, json=payload, headers=headers)
+
+            if response.status_code == 201:
+                job_key = None
+                try:
+                    job_key = response.json()["value"][0]["Key"]
+                except KeyError:
+                    console.error("Error: Failed to get job key from response")
+                if job_key:
+                    with console.spinner("Starting job ..."):
+                        job_url = f"{base_url}/orchestrator_/jobs(sidepanel:sidepanel/jobs/{job_key}/details)?fid={personal_workspace_folder_id}"
+                        console.magic("Job started successfully!")
+                        console.link("Monitor your job here: ", job_url)
+            else:
+                console.error(
+                    f"Error: Failed to start job. Status code: {response.status_code} {response.text}"
+                )
 
 
 if __name__ == "__main__":

uipath/_cli/cli_pack.py

@@ -1,6 +1,7 @@
 # type: ignore
 import json
 import os
+import subprocess
 import uuid
 import zipfile
 from string import Template
@@ -52,6 +53,66 @@ def check_config(directory):
     }
 
 
+def is_uv_available():
+    """Check if uv command is available in the system."""
+    try:
+        subprocess.run(["uv", "--version"], capture_output=True, check=True, timeout=20)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+    except Exception as e:
+        console.warning(
+            f"An unexpected error occurred while checking uv availability: {str(e)}"
+        )
+        return False
+
+
+def is_uv_project(directory):
+    """Check if this is a uv project by looking for the uv.lock file."""
+    uv_lock_path = os.path.join(directory, "uv.lock")
+
+    # If uv.lock exists, it's definitely a uv project
+    if os.path.exists(uv_lock_path):
+        return True
+
+    return False
+
+
+def run_uv_lock(directory):
+    """Run uv lock to update the lock file."""
+    try:
+        subprocess.run(
+            ["uv", "lock"],
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        console.warning(f"uv lock failed: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        console.warning("uv command not found. Skipping lock file update.")
+        return False
+    except Exception as e:
+        console.warning(f"An unexpected error occurred while running uv lock: {str(e)}")
+        return False
+
+
+def handle_uv_operations(directory):
+    """Handle uv operations if uv is detected and available."""
+    if not is_uv_available():
+        return
+
+    if not is_uv_project(directory):
+        return
+
+    # Always run uv lock to ensure lock file is up to date
+    run_uv_lock(directory)
+
+
 def generate_operate_file(entryPoints):
     project_id = str(uuid.uuid4())
 
@@ -210,7 +271,15 @@ def is_venv_dir(d):
     )
 
 
-def pack_fn(projectName, description, entryPoints, version, authors, directory):
+def pack_fn(
+    projectName,
+    description,
+    entryPoints,
+    version,
+    authors,
+    directory,
+    include_uv_lock=True,
+):
     operate_file = generate_operate_file(entryPoints)
     entrypoints_file = generate_entrypoints_file(entryPoints)
 
@@ -304,7 +373,11 @@ def pack_fn(projectName, description, entryPoints, version, authors, directory):
                                 with open(file_path, "r", encoding="latin-1") as f:
                                     z.writestr(f"content/{rel_path}", f.read())
 
-        optional_files = ["pyproject.toml", "README.md", "uv.lock"]
+        # Handle optional files, conditionally including uv.lock
+        optional_files = ["pyproject.toml", "README.md"]
+        if include_uv_lock:
+            optional_files.append("uv.lock")
+
         for file in optional_files:
             file_path = os.path.join(directory, file)
             if os.path.exists(file_path):
@@ -367,8 +440,13 @@ def display_project_info(config):
 
 @click.command()
 @click.argument("root", type=str, default="./")
+@click.option(
+    "--nolock",
+    is_flag=True,
+    help="Skip running uv lock and exclude uv.lock from the package",
+)
 @track
-def pack(root):
+def pack(root, nolock):
     """Pack the project."""
     version = get_project_version(root)
 
@@ -403,6 +481,10 @@ def pack(root):
 
     with console.spinner("Packaging project ..."):
         try:
+            # Handle uv operations before packaging, unless nolock is specified
+            if not nolock:
+                handle_uv_operations(root)
+
             pack_fn(
                 config["project_name"],
                 config["description"],
@@ -410,6 +492,7 @@ def pack(root):
                 version or config["version"],
                 config["authors"],
                 root,
+                include_uv_lock=not nolock,
             )
             display_project_info(config)
             console.success("Project successfully packaged.")

uipath/_cli/cli_publish.py

@@ -6,6 +6,7 @@ import click
 import httpx
 from dotenv import load_dotenv
 
+from .._utils._ssl_context import get_httpx_client_kwargs
 from ..telemetry import track
 from ._utils._common import get_env_vars
 from ._utils._console import ConsoleLogger
@@ -13,7 +14,6 @@ from ._utils._folders import get_personal_workspace_info
 from ._utils._processes import get_release_info
 
 console = ConsoleLogger()
-client = httpx.Client(follow_redirects=True, timeout=30.0)
 
 
 def get_most_recent_package():
@@ -35,7 +35,10 @@ def get_available_feeds(
     base_url: str, headers: dict[str, str]
 ) -> list[tuple[str, str]]:
     url = f"{base_url}/orchestrator_/api/PackageFeeds/GetFeeds"
-    response = httpx.get(url, headers=headers)
+
+    with httpx.Client(**get_httpx_client_kwargs()) as client:
+        response = client.get(url, headers=headers)
+
     if response.status_code != 200:
         console.error(
             f"Failed to fetch available feeds. Please check your connection. Status code: {response.status_code} {response.text}"
@@ -123,40 +126,43 @@ def publish(feed):
             else:
                 url = url + "?feedId=" + feed
 
-        with open(package_to_publish_path, "rb") as f:
-            files = {"file": (package_to_publish_path, f, "application/octet-stream")}
-            response = client.post(url, headers=headers, files=files)
-
-    if response.status_code == 200:
-        console.success("Package published successfully!")
-
-        if is_personal_workspace:
-            package_name = None
-            package_version = None
-            try:
-                data = json.loads(response.text)["value"][0]["Body"]
-                package_name = json.loads(data)["Id"]
-                package_version = json.loads(data)["Version"]
-            except json.decoder.JSONDecodeError:
-                console.warning("Failed to deserialize package name")
-            if package_name is not None:
-                with console.spinner("Getting process information ..."):
-                    release_id, _ = get_release_info(
-                        base_url,
-                        token,
-                        package_name,
-                        package_version,
-                        personal_workspace_feed_id,
-                    )
-                if release_id:
-                    process_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={personal_workspace_folder_id}"
-                    console.link("Process configuration link:", process_url)
-                    console.hint(
-                        "Use the link above to configure any environment variables"
-                    )
+        with httpx.Client(**get_httpx_client_kwargs()) as client:
+            with open(package_to_publish_path, "rb") as f:
+                files = {
+                    "file": (package_to_publish_path, f, "application/octet-stream")
+                }
+                response = client.post(url, headers=headers, files=files)
+
+                if response.status_code == 200:
+                    console.success("Package published successfully!")
+
+                    if is_personal_workspace:
+                        package_name = None
+                        package_version = None
+                        try:
+                            data = json.loads(response.text)["value"][0]["Body"]
+                            package_name = json.loads(data)["Id"]
+                            package_version = json.loads(data)["Version"]
+                        except json.decoder.JSONDecodeError:
+                            console.warning("Failed to deserialize package name")
+                        if package_name is not None:
+                            with console.spinner("Getting process information ..."):
+                                release_id, _ = get_release_info(
+                                    base_url,
+                                    token,
+                                    package_name,
+                                    package_version,
+                                    personal_workspace_feed_id,
+                                )
+                            if release_id:
+                                process_url = f"{base_url}/orchestrator_/processes/{release_id}/edit?fid={personal_workspace_folder_id}"
+                                console.link("Process configuration link:", process_url)
+                                console.hint(
+                                    "Use the link above to configure any environment variables"
+                                )
+                            else:
+                                console.warning("Failed to compose process url")
                 else:
-                    console.warning("Failed to compose process url")
-    else:
-        console.error(
-            f"Failed to publish package. Status code: {response.status_code} {response.text}"
-        )
+                    console.error(
+                        f"Failed to publish package. Status code: {response.status_code} {response.text}"
+                    )

uipath/_services/_base_service.py

@@ -23,6 +23,7 @@ from uipath._utils._read_overwrites import OverwritesManager
 from .._config import Config
 from .._execution_context import ExecutionContext
 from .._utils import UiPathUrl, user_agent_value
+from .._utils._ssl_context import get_httpx_client_kwargs
 from .._utils.constants import HEADER_USER_AGENT
 
 
@@ -42,17 +43,16 @@ class BaseService:
 
         self._url = UiPathUrl(self._config.base_url)
 
-        self._client = Client(
-            base_url=self._url.base_url,
-            headers=Headers(self.default_headers),
-            timeout=30.0,
-        )
+        default_client_kwargs = get_httpx_client_kwargs()
 
-        self._client_async = AsyncClient(
-            base_url=self._url.base_url,
-            headers=Headers(self.default_headers),
-            timeout=30.0,
-        )
+        client_kwargs = {
+            **default_client_kwargs,  # SSL, proxy, timeout, redirects
+            "base_url": self._url.base_url,
+            "headers": Headers(self.default_headers),
+        }
+
+        self._client = Client(**client_kwargs)
+        self._client_async = AsyncClient(**client_kwargs)
 
         self._overwrites_manager = OverwritesManager()
         self._logger.debug(f"HEADERS: {self.default_headers}")

uipath/_services/attachments_service.py

@@ -11,6 +11,7 @@ from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder
+from .._utils._ssl_context import get_httpx_client_kwargs
 from .._utils.constants import TEMP_ATTACHMENTS_FOLDER
 from ..tracing._traced import traced
 from ._base_service import BaseService
@@ -121,7 +122,7 @@ class AttachmentsService(FolderContext, BaseService):
                     for chunk in response.iter_bytes(chunk_size=8192):
                         file.write(chunk)
                 else:
-                    with httpx.Client() as client:
+                    with httpx.Client(**get_httpx_client_kwargs()) as client:
                         with client.stream(
                             "GET", download_uri, headers=headers
                         ) as response:
@@ -390,7 +391,7 @@ class AttachmentsService(FolderContext, BaseService):
                         "PUT", upload_uri, headers=headers, content=file_content
                     )
                 else:
-                    with httpx.Client() as client:
+                    with httpx.Client(**get_httpx_client_kwargs()) as client:
                         client.put(upload_uri, headers=headers, content=file_content)
         else:
             # Upload from memory
@@ -401,7 +402,7 @@ class AttachmentsService(FolderContext, BaseService):
             if result["BlobFileAccess"]["RequiresAuth"]:
                 self.request("PUT", upload_uri, headers=headers, content=content)
             else:
-                with httpx.Client() as client:
+                with httpx.Client(**get_httpx_client_kwargs()) as client:
                     client.put(upload_uri, headers=headers, content=content)
 
         return attachment_key
@@ -526,7 +527,7 @@ class AttachmentsService(FolderContext, BaseService):
                         "PUT", upload_uri, headers=headers, content=file_content
                     )
                 else:
-                    with httpx.Client() as client:
+                    with httpx.Client(**get_httpx_client_kwargs()) as client:
                         client.put(upload_uri, headers=headers, content=file_content)
         else:
             # Upload from memory
@@ -539,7 +540,7 @@ class AttachmentsService(FolderContext, BaseService):
                     "PUT", upload_uri, headers=headers, content=content
                 )
             else:
-                with httpx.Client() as client:
+                with httpx.Client(**get_httpx_client_kwargs()) as client:
                     client.put(upload_uri, headers=headers, content=content)
 
         return attachment_key

uipath/_services/buckets_service.py

@@ -1,5 +1,5 @@
 import mimetypes
-from typing import Any, Dict, Optional, Union
+from typing import Dict, Optional, Union
 
 import httpx
 
@@ -7,16 +7,12 @@ from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
+from .._utils._ssl_context import get_httpx_client_kwargs
 from ..models import Bucket
 from ..tracing._traced import traced
 from ._base_service import BaseService
 
 
-def _upload_from_memory_input_processor(inputs: Dict[str, Any]) -> Dict[str, Any]:
-    inputs["content"] = "<Redacted>"
-    return inputs
-
-
 class BucketsService(FolderContext, BaseService):
     """Service for managing UiPath storage buckets.
 
@@ -26,8 +22,8 @@ class BucketsService(FolderContext, BaseService):
 
     def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
         super().__init__(config=config, execution_context=execution_context)
-        self.custom_client = httpx.Client()
-        self.custom_client_async = httpx.AsyncClient()
+        self.custom_client = httpx.Client(**get_httpx_client_kwargs())
+        self.custom_client_async = httpx.AsyncClient(**get_httpx_client_kwargs())
 
     @traced(name="buckets_download", run_type="uipath")
     @infer_bindings(resource_type="bucket")

uipath/_utils/_ssl_context.py

@@ -0,0 +1,54 @@
+import os
+import ssl
+from typing import Any, Dict
+
+
+def expand_path(path):
+    """Expand environment variables and user home directory in path."""
+    if not path:
+        return path
+    # Expand environment variables like $HOME
+    path = os.path.expandvars(path)
+    # Expand user home directory ~
+    path = os.path.expanduser(path)
+    return path
+
+
+def create_ssl_context():
+    # Try truststore first (system certificates)
+    try:
+        import truststore
+
+        return truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    except ImportError:
+        # Fallback to manual certificate configuration
+        import certifi
+
+        ssl_cert_file = expand_path(os.environ.get("SSL_CERT_FILE"))
+        requests_ca_bundle = expand_path(os.environ.get("REQUESTS_CA_BUNDLE"))
+        ssl_cert_dir = expand_path(os.environ.get("SSL_CERT_DIR"))
+
+        return ssl.create_default_context(
+            cafile=ssl_cert_file or requests_ca_bundle or certifi.where(),
+            capath=ssl_cert_dir,
+        )
+
+
+def get_httpx_client_kwargs() -> Dict[str, Any]:
+    """Get standardized httpx client configuration."""
+    client_kwargs: Dict[str, Any] = {"follow_redirects": True, "timeout": 30.0}
+
+    # Check environment variable to disable SSL verification
+    disable_ssl_env = os.environ.get("UIPATH_DISABLE_SSL_VERIFY", "").lower()
+    disable_ssl_from_env = disable_ssl_env in ("1", "true", "yes", "on")
+
+    if disable_ssl_from_env:
+        client_kwargs["verify"] = False
+    else:
+        # Use system certificates with truststore fallback
+        client_kwargs["verify"] = create_ssl_context()
+
+    # Auto-detect proxy from environment variables (httpx handles this automatically)
+    # HTTP_PROXY, HTTPS_PROXY, NO_PROXY are read by httpx by default
+
+    return client_kwargs

{uipath-2.0.72.dist-info → uipath-2.0.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.72
+Version: 2.0.74
 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
@@ -24,6 +24,7 @@ Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tenacity>=9.0.0
 Requires-Dist: tomli>=2.2.1
+Requires-Dist: truststore>=0.10.1
 Provides-Extra: langchain
 Requires-Dist: uipath-langchain<0.1.0,>=0.0.88; extra == 'langchain'
 Description-Content-Type: text/markdown
@@ -38,6 +39,8 @@ A Python SDK that enables programmatic interaction with UiPath Cloud Platform se
 
 Use the [UiPath LangChain SDK](https://github.com/UiPath/uipath-langchain-python) to pack and publish LangGraph Agents.
 
+Use the [UiPath LlamaIndex SDK](https://github.com/UiPath/uipath-llamaindex-python) to pack and publish LlamaIndex Agents.
+
 This [quickstart guide](https://uipath.github.io/uipath-python/) walks you through deploying your first agent to UiPath Cloud Platform.
 
 ## Table of Contents

{uipath-2.0.72.dist-info → uipath-2.0.74.dist-info}/RECORD

@@ -6,22 +6,23 @@ uipath/_uipath.py,sha256=54u-aPF29DE3fOn8yM1pjVTqSZxSSaIsifiZG9Mt_YM,3824
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=vGz3vJHkUvgK9_lKdzqiwwHkge1TCALRiOzGGwyr-8E,1885
-uipath/_cli/cli_auth.py,sha256=aIecyySuGXJEQHnS6b-M6sxM7ki5trjqq_J7s-sCdQE,3966
+uipath/_cli/cli_auth.py,sha256=kWk0tznOxmU6xwhJgUAMipTevH2iTIotcNiIwmPlpYI,6507
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_init.py,sha256=SmB7VplpXRSa5sgqgzojNsZDw0zfsEi2TfkMx3eQpTo,5132
-uipath/_cli/cli_invoke.py,sha256=IjndcDWBpvAqGCRanQU1vfmxaBF8FhyZ7gWuZqwjHrU,3812
+uipath/_cli/cli_invoke.py,sha256=FurosrZNGlmANIrplKWhw3EQ1b46ph5Z2rPwVaYJgmc,4001
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
-uipath/_cli/cli_pack.py,sha256=6W7AqVMjeXOe8cQ3GUoD32VMJNfhtvHut_7moJ6kJkI,15046
-uipath/_cli/cli_publish.py,sha256=Ba0TJ1TSfuQbLU2AIgtM8QWkLHgr4tsAP1CaX12113U,6010
+uipath/_cli/cli_pack.py,sha256=qqmh7v0j4_vA4Xko5PgKFEbJIOXlmJBGd9IRnDi-wtA,17285
+uipath/_cli/cli_publish.py,sha256=QT17JTClAyLve6ZjB-WvQaJ-j4DdmNneV_eDRyXjeeQ,6578
 uipath/_cli/cli_run.py,sha256=zYg-9U6mkofdGsE0IGjYi1dOMlG8CdBxiVGxfFiLq5Y,5882
 uipath/_cli/middlewares.py,sha256=f7bVODO9tgdtWNepG5L58-B-VgBSU6Ek2tIU6wLz0xA,4905
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=p93_EvJpdoLLkiVmLygHRKo9ru1-PZOEAaEhNFN3j6c,6424
+uipath/_cli/_auth/_client_credentials.py,sha256=eENVb54-uzEqi7bC5VNjsiULW4fSfs-sK0kgUjRKorA,5412
 uipath/_cli/_auth/_models.py,sha256=sYMCfvmprIqnZxStlD_Dxx2bcxgn0Ri4D7uwemwkcNg,948
 uipath/_cli/_auth/_oidc_utils.py,sha256=WaX9jDlXrlX6yD8i8gsocV8ngjaT72Xd1tvsZMmSbco,2127
-uipath/_cli/_auth/_portal_service.py,sha256=80W0cn3rx6NEi_b15aSQ0ZQWFv7Om7SaOlkUUk2k7pA,7240
+uipath/_cli/_auth/_portal_service.py,sha256=iAxEDEY7OcEbIUSKNZnURAuNsimNmU90NLHkkTLqREY,8079
 uipath/_cli/_auth/_utils.py,sha256=9nb76xe5XmDZ0TAncp-_1SKqL6FdwRi9eS3C2noN1lY,1591
-uipath/_cli/_auth/auth_config.json,sha256=OCNp3tTF2WL83pyJlZw-Wt8Slao9IpmmZJonl2OvaRw,340
+uipath/_cli/_auth/auth_config.json,sha256=ib1qYxU6Totvl2pxFkqqmjVe3tOYR98mFFsUska9lOA,359
 uipath/_cli/_auth/index.html,sha256=ML_xDOcKs0ETYucufJskiYfWSvdrD_E26C0Qd3qpGj8,6280
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
@@ -39,18 +40,18 @@ uipath/_cli/_utils/_common.py,sha256=wQ0a_lGj0bsuNvwxUfnLwg6T3IdatdfkrPcZMoufJNU
 uipath/_cli/_utils/_console.py,sha256=rj4V3yeR1wnJzFTHnaE6wcY9OoJV-PiIQnLg_p62ClQ,6664
 uipath/_cli/_utils/_constants.py,sha256=mCeSWLURgw_dOMXjzyYBAvxKN3Vcd1vf7XKHgbdrOds,25
 uipath/_cli/_utils/_debug.py,sha256=XlMkjtXT6hqyn7huioLDaVSYqo9fyWCvTkqEJh_ZEGw,1598
-uipath/_cli/_utils/_folders.py,sha256=usjLNOMdhvelEv0wsJ-v6q-qiUR1tbwXJL4Sd_SOocI,970
+uipath/_cli/_utils/_folders.py,sha256=UVJcKPfPAVR5HF4AP6EXdlNVcfEF1v5pwGCpoAgBY34,1155
 uipath/_cli/_utils/_input_args.py,sha256=pyQhEcQXHdFHYTVNzvfWp439aii5StojoptnmCv5lfs,4094
 uipath/_cli/_utils/_parse_ast.py,sha256=A-QToBIf-oP7yP2DQTHO6blkk6ik5z_IeaIwtEWO4e0,19516
-uipath/_cli/_utils/_processes.py,sha256=iCGNf1y_K_r3bdmX9VWA70UP20bdUzKlMRrAxkdkdm4,1669
+uipath/_cli/_utils/_processes.py,sha256=q7DfEKHISDWf3pngci5za_z0Pbnf_shWiYEcTOTCiyk,1855
 uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4oo,1541
 uipath/_services/__init__.py,sha256=10xtw3ENC30yR9CCq_b94RMZ3YrUeyfHV33yWYUd8tU,896
-uipath/_services/_base_service.py,sha256=y-QATIRF9JnUFKIwmjOWMHlE2BrJYgD8y4sGAve2kEM,5338
+uipath/_services/_base_service.py,sha256=7ZZDMC1TQkVk7pp-1T4a4sJOBI6O98_y9QrHN5yc8gA,5436
 uipath/_services/actions_service.py,sha256=LYKvG4VxNGQgZ46AzGK9kI1Txb-YmVvZj5ScPOue8Ls,15989
 uipath/_services/api_client.py,sha256=hcof0EMa4-phEHD1WlO7Tdfzq6aL18Sbi2aBE7lJm1w,1821
 uipath/_services/assets_service.py,sha256=acqWogfhZiSO1eeVYqFxmqWGSTmrW46QxI1J0bJe3jo,11918
-uipath/_services/attachments_service.py,sha256=FwnagLtgpn_IpQMvo9uj5mmA_rlyTTiRd4IduB6FpaQ,26458
-uipath/_services/buckets_service.py,sha256=bZHa5jMUIYBR92-sRCQ7kzaZO6VWFh4CxRFvEZ4U_5U,18529
+uipath/_services/attachments_service.py,sha256=Y0xJlK6UOtbG6oPLT9bW8XbfuGQPK9MEaZdMRdGA3zs,26651
+uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
 uipath/_services/connections_service.py,sha256=qh-HNL_GJsyPUD0wSJZRF8ZdrTE9l4HrIilmXGK6dDk,4581
 uipath/_services/context_grounding_service.py,sha256=EBf7lIIYz_s1ubf_07OAZXQHjS8kpZ2vqxo4mI3VL-A,25009
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
@@ -65,6 +66,7 @@ uipath/_utils/_logs.py,sha256=adfX_0UAn3YBeKJ8DQDeZs94rJyHGQO00uDfkaTpNWQ,510
 uipath/_utils/_read_overwrites.py,sha256=OQgG9ycPpFnLub5ELQdX9V2Fyh6F9_zDR3xoYagJaMI,5287
 uipath/_utils/_request_override.py,sha256=fIVHzgHVXITUlWcp8osNBwIafM1qm4_ejx0ng5UzfJ4,573
 uipath/_utils/_request_spec.py,sha256=iCtBLqtbWUpFG5g1wtIZBzSupKsfaRLiQFoFc_4B70Q,747
+uipath/_utils/_ssl_context.py,sha256=xSYitos0eJc9cPHzNtHISX9PBvL6D2vas5G_GiBdLp8,1783
 uipath/_utils/_url.py,sha256=-4eluSrIZCUlnQ3qU17WPJkgaC2KwF9W5NeqGnTNGGo,2512
 uipath/_utils/_user_agent.py,sha256=pVJkFYacGwaQBomfwWVAvBQgdBUo62e4n3-fLIajWUU,563
 uipath/_utils/constants.py,sha256=yf4Xd0gmdisrIrsdy3zuiOgboK-XYAcrd4ekb3ZjZeE,878
@@ -91,8 +93,8 @@ uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,22
 uipath/tracing/_otel_exporters.py,sha256=x0PDPmDKJcxashsuehVsSsqBCzRr6WsNFaq_3_HS5F0,3014
 uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,18528
 uipath/tracing/_utils.py,sha256=ZeensQexnw69jVcsVrGyED7mPlAU-L1agDGm6_1A3oc,10388
-uipath-2.0.72.dist-info/METADATA,sha256=8GLcdGovov-loJNQ-VP7rDOyPvQfiPh2BkU5-Tb8l9s,6304
-uipath-2.0.72.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.72.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.72.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.72.dist-info/RECORD,,
+uipath-2.0.74.dist-info/METADATA,sha256=7nWW75xzek2vV6C_UQZiJKFUMFkwdxDP58_y3FYn-n0,6462
+uipath-2.0.74.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.74.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.74.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.74.dist-info/RECORD,,