uipath 2.0.76__tar.gz → 2.0.78__tar.gz

{uipath-2.0.76 → uipath-2.0.78}/.github/workflows/lint.yml

@@ -35,4 +35,7 @@ jobs:
 
       - name: Check formatting
         run: uv run ruff format --check .
+      
+      - name: Check httpx.Client() usage
+        run: uv run python scripts/lint_httpx_client.py
 

{uipath-2.0.76 → uipath-2.0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.76
+Version: 2.0.78
 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.0.76 → uipath-2.0.78}/justfile

@@ -4,6 +4,7 @@ default: lint format
 
 lint:
     ruff check .
+    python scripts/lint_httpx_client.py
 
 format:
     ruff format --check .
@@ -13,3 +14,7 @@ build:
 
 install:
     uv sync --all-extras
+
+# Test the custom linter
+test-lint-httpx:
+    python scripts/test_httpx_linter.py

{uipath-2.0.76 → uipath-2.0.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.76"
+version = "2.0.78"
 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.0.78/scripts/debug_test.py

@@ -0,0 +1,28 @@
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+# Simple test
+test_code = """
+import httpx
+
+def test():
+    client = httpx.Client()
+    return client
+"""
+
+linter_path = Path(__file__).parent / "lint_httpx_client.py"
+
+with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+    f.write(test_code)
+    f.flush()
+
+    print(f"Testing file: {f.name}")
+    result = subprocess.run(
+        [sys.executable, str(linter_path), f.name], capture_output=True, text=True
+    )
+
+    print(f"Return code: {result.returncode}")
+    print(f"Stdout: {result.stdout}")
+    print(f"Stderr: {result.stderr}")

uipath-2.0.78/scripts/lint_httpx_client.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""Custom linter to check for httpx.Client() usage.
+
+This script checks for direct usage of httpx.Client() without using the
+get_httpx_client_kwargs() function, which is required for proper SSL
+and proxy configuration in the UiPath Python SDK.
+"""
+
+import ast
+import sys
+from pathlib import Path
+from typing import List, NamedTuple
+
+
+class LintViolation(NamedTuple):
+    """Represents a linting violation."""
+
+    filename: str
+    line: int
+    column: int
+    message: str
+    rule_code: str
+
+
+class HttpxClientChecker(ast.NodeVisitor):
+    """AST visitor to check for httpx.Client() usage violations."""
+
+    def __init__(self, filename: str):
+        """Initialize the checker with a filename.
+
+        Args:
+            filename: The path to the file being checked.
+        """
+        self.filename = filename
+        self.violations: List[LintViolation] = []
+        self.has_httpx_import = False
+        self.has_get_httpx_client_kwargs_import = False
+        # Track variables that contain get_httpx_client_kwargs
+        self.variables_with_httpx_kwargs: set[str] = set()
+
+    def visit_Import(self, node: ast.Import) -> None:
+        """Check for httpx imports."""
+        for alias in node.names:
+            if alias.name == "httpx":
+                self.has_httpx_import = True
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        """Check for imports from httpx or get_httpx_client_kwargs."""
+        if node.module == "httpx":
+            self.has_httpx_import = True
+        elif node.module and "get_httpx_client_kwargs" in [
+            alias.name for alias in (node.names or [])
+        ]:
+            self.has_get_httpx_client_kwargs_import = True
+        self.generic_visit(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """Track variable assignments that use get_httpx_client_kwargs."""
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            var_name = node.targets[0].id
+            if self._assignment_uses_get_httpx_client_kwargs(node.value):
+                self.variables_with_httpx_kwargs.add(var_name)
+        self.generic_visit(node)
+
+    def _assignment_uses_get_httpx_client_kwargs(self, value_node: ast.AST) -> bool:
+        """Check if an assignment value uses get_httpx_client_kwargs."""
+        if isinstance(value_node, ast.Call):
+            # Direct call: var = get_httpx_client_kwargs()
+            if isinstance(value_node.func, ast.Name):
+                if value_node.func.id == "get_httpx_client_kwargs":
+                    return True
+            elif isinstance(value_node.func, ast.Attribute):
+                if value_node.func.attr == "get_httpx_client_kwargs":
+                    return True
+        elif isinstance(value_node, ast.Dict):
+            # Dictionary that spreads get_httpx_client_kwargs: {..., **get_httpx_client_kwargs()}
+            for key in value_node.keys:
+                if key is None:  # This is a **kwargs expansion
+                    # Find corresponding value
+                    idx = value_node.keys.index(key)
+                    if idx < len(value_node.values):
+                        spread_value = value_node.values[idx]
+                        if isinstance(spread_value, ast.Call):
+                            if isinstance(spread_value.func, ast.Name):
+                                if spread_value.func.id == "get_httpx_client_kwargs":
+                                    return True
+                            elif isinstance(spread_value.func, ast.Attribute):
+                                if spread_value.func.attr == "get_httpx_client_kwargs":
+                                    return True
+                        elif isinstance(spread_value, ast.Name):
+                            # Spreading another variable that might contain httpx kwargs
+                            if spread_value.id in self.variables_with_httpx_kwargs:
+                                return True
+        return False
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Check for httpx.Client() and httpx.AsyncClient() calls."""
+        if self._is_httpx_client_call(node):
+            # Check if this is a proper usage with get_httpx_client_kwargs
+            if not self._is_using_get_httpx_client_kwargs(node):
+                client_type = self._get_client_type(node)
+                violation = LintViolation(
+                    filename=self.filename,
+                    line=node.lineno,
+                    column=node.col_offset,
+                    message=f"Use **get_httpx_client_kwargs() with {client_type}() - should be: {client_type}(**get_httpx_client_kwargs())",
+                    rule_code="UIPATH001",
+                )
+                self.violations.append(violation)
+
+        self.generic_visit(node)
+
+    def _is_httpx_client_call(self, node: ast.Call) -> bool:
+        """Check if the call is httpx.Client() or httpx.AsyncClient()."""
+        if isinstance(node.func, ast.Attribute):
+            if (
+                isinstance(node.func.value, ast.Name)
+                and node.func.value.id == "httpx"
+                and node.func.attr in ("Client", "AsyncClient")
+            ):
+                return True
+        elif isinstance(node.func, ast.Name) and node.func.id in (
+            "Client",
+            "AsyncClient",
+        ):
+            # This could be a direct Client/AsyncClient import, check if httpx is imported
+            return self.has_httpx_import
+        return False
+
+    def _get_client_type(self, node: ast.Call) -> str:
+        """Get the client type name (Client or AsyncClient)."""
+        if isinstance(node.func, ast.Attribute):
+            return f"httpx.{node.func.attr}"
+        elif isinstance(node.func, ast.Name):
+            return node.func.id
+        return "httpx.Client"
+
+    def _is_using_get_httpx_client_kwargs(self, node: ast.Call) -> bool:
+        """Check if the httpx.Client() call is using **get_httpx_client_kwargs()."""
+        # Check if there are any **kwargs that use get_httpx_client_kwargs directly
+        for keyword in node.keywords:
+            if keyword.arg is None:  # This is a **kwargs expansion
+                if isinstance(keyword.value, ast.Call):
+                    if isinstance(keyword.value.func, ast.Name):
+                        if keyword.value.func.id == "get_httpx_client_kwargs":
+                            return True
+                    elif isinstance(keyword.value.func, ast.Attribute):
+                        if keyword.value.func.attr == "get_httpx_client_kwargs":
+                            return True
+                elif isinstance(keyword.value, ast.Name):
+                    # Check if this variable might contain get_httpx_client_kwargs
+                    # This handles cases like: **client_kwargs where client_kwargs was built from get_httpx_client_kwargs
+                    var_name = keyword.value.id
+                    if self._variable_contains_get_httpx_client_kwargs(var_name):
+                        return True
+
+        # Also check if it's the ONLY argument and it's **get_httpx_client_kwargs()
+        # This handles cases like: httpx.Client(**get_httpx_client_kwargs())
+        if len(node.args) == 0 and len(node.keywords) == 1:
+            keyword = node.keywords[0]
+            if keyword.arg is None and isinstance(keyword.value, ast.Call):
+                if isinstance(keyword.value.func, ast.Name):
+                    if keyword.value.func.id == "get_httpx_client_kwargs":
+                        return True
+                elif isinstance(keyword.value.func, ast.Attribute):
+                    if keyword.value.func.attr == "get_httpx_client_kwargs":
+                        return True
+
+        return False
+
+    def _variable_contains_get_httpx_client_kwargs(self, var_name: str) -> bool:
+        """Check if a variable was built using get_httpx_client_kwargs()."""
+        # Check if we've tracked this variable as containing httpx kwargs
+        if var_name in self.variables_with_httpx_kwargs:
+            return True
+
+        # Fallback: Simple heuristic based on naming patterns
+        # This handles cases where the variable assignment might be complex
+        if "client_kwargs" in var_name.lower() or "httpx_kwargs" in var_name.lower():
+            return True
+
+        return False
+
+
+def check_file(filepath: Path) -> List[LintViolation]:
+    """Check a single Python file for httpx.Client() violations."""
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        tree = ast.parse(content, filename=str(filepath))
+        checker = HttpxClientChecker(str(filepath))
+        checker.visit(tree)
+        return checker.violations
+
+    except SyntaxError:
+        # Skip files with syntax errors
+        return []
+    except Exception as e:
+        print(f"Error checking {filepath}: {e}", file=sys.stderr)
+        return []
+
+
+def main():
+    """Main function to run the linter."""
+    if len(sys.argv) > 1:
+        paths = [Path(p) for p in sys.argv[1:]]
+    else:
+        # Default to checking src and tests directories
+        paths = [Path("src"), Path("tests")]
+
+    all_violations = []
+
+    for path in paths:
+        if path.is_file() and path.suffix == ".py":
+            violations = check_file(path)
+            all_violations.extend(violations)
+        elif path.is_dir():
+            for py_file in path.rglob("*.py"):
+                violations = check_file(py_file)
+                all_violations.extend(violations)
+
+    # Report violations
+    if all_violations:
+        for violation in all_violations:
+            print(
+                f"{violation.filename}:{violation.line}:{violation.column}: {violation.rule_code} {violation.message}"
+            )
+        sys.exit(1)
+    else:
+        print("No httpx.Client() violations found.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

uipath-2.0.78/src/uipath/_cli/_utils/_constants.py

@@ -0,0 +1,58 @@
+BINDINGS_VERSION = "2.2"
+
+# Binary file extension categories
+IMAGE_EXTENSIONS = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".ico",
+    ".tiff",
+    ".webp",
+    ".svg",
+}
+
+DOCUMENT_EXTENSIONS = {".pdf", ".docx", ".pptx", ".xlsx", ".xls"}
+
+ARCHIVE_EXTENSIONS = {".zip", ".tar", ".gz", ".rar", ".7z", ".bz2", ".xz"}
+
+MEDIA_EXTENSIONS = {
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".aac",
+    ".mp4",
+    ".avi",
+    ".mov",
+    ".mkv",
+    ".wmv",
+}
+
+FONT_EXTENSIONS = {".woff", ".woff2", ".ttf", ".otf", ".eot"}
+
+EXECUTABLE_EXTENSIONS = {".exe", ".dll", ".so", ".dylib", ".bin"}
+
+DATABASE_EXTENSIONS = {".db", ".sqlite", ".sqlite3"}
+
+PYTHON_BINARY_EXTENSIONS = {".pickle", ".pkl"}
+
+SPECIAL_EXTENSIONS = {""}  # Extensionless binary files
+
+# Pre-compute the union for optimal performance
+BINARY_EXTENSIONS = (
+    IMAGE_EXTENSIONS
+    | DOCUMENT_EXTENSIONS
+    | ARCHIVE_EXTENSIONS
+    | MEDIA_EXTENSIONS
+    | FONT_EXTENSIONS
+    | EXECUTABLE_EXTENSIONS
+    | DATABASE_EXTENSIONS
+    | PYTHON_BINARY_EXTENSIONS
+    | SPECIAL_EXTENSIONS
+)
+
+
+def is_binary_file(file_extension: str) -> bool:
+    """Determine if a file should be treated as binary."""
+    return file_extension.lower() in BINARY_EXTENSIONS

{uipath-2.0.76 → uipath-2.0.78}/src/uipath/_cli/cli_pack.py

@@ -17,6 +17,7 @@ except ImportError:
 
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
+from ._utils._constants import is_binary_file
 
 console = ConsoleLogger()
 
@@ -265,8 +266,6 @@ def pack_fn(
     # Define the allowlist of file extensions to include
     file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml"]
     files_included = []
-    # Binary files that should be read in binary mode
-    binary_extensions = [".exe", "", ".xlsx", ".xls"]
 
     with open(config_path, "r") as f:
         config_data = json.load(f)
@@ -328,7 +327,7 @@ def pack_fn(
                 if file_extension in file_extensions_included or file in files_included:
                     file_path = os.path.join(root, file)
                     rel_path = os.path.relpath(file_path, directory)
-                    if file_extension in binary_extensions:
+                    if is_binary_file(file_extension):
                         # Read binary files in binary mode
                         with open(file_path, "rb") as f:
                             z.writestr(f"content/{rel_path}", f.read())

{uipath-2.0.76 → uipath-2.0.78}/src/uipath/_services/attachments_service.py

@@ -240,7 +240,7 @@ class AttachmentsService(FolderContext, BaseService):
                     async for chunk in response.aiter_bytes(chunk_size=8192):
                         file.write(chunk)
                 else:
-                    async with httpx.AsyncClient() as client:
+                    async with httpx.AsyncClient(**get_httpx_client_kwargs()) as client:
                         async with client.stream(
                             "GET", download_uri, headers=headers
                         ) as response:

{uipath-2.0.76 → uipath-2.0.78}/src/uipath/tracing/_otel_exporters.py

@@ -4,13 +4,15 @@ import os
 import time
 from typing import Any, Dict, Sequence
 
-from httpx import Client
+import httpx
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import (
     SpanExporter,
     SpanExportResult,
 )
 
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+
 from ._utils import _SpanUtils
 
 logger = logging.getLogger(__name__)
@@ -19,9 +21,9 @@ logger = logging.getLogger(__name__)
 class LlmOpsHttpExporter(SpanExporter):
     """An OpenTelemetry span exporter that sends spans to UiPath LLM Ops."""
 
-    def __init__(self, **kwargs):
+    def __init__(self, **client_kwargs):
         """Initialize the exporter with the base URL and authentication token."""
-        super().__init__(**kwargs)
+        super().__init__(**client_kwargs)
         self.base_url = self._get_base_url()
         self.auth_token = os.environ.get("UIPATH_ACCESS_TOKEN")
         self.headers = {
@@ -29,7 +31,9 @@ class LlmOpsHttpExporter(SpanExporter):
             "Authorization": f"Bearer {self.auth_token}",
         }
 
-        self.http_client = Client(headers=self.headers)
+        client_kwargs = get_httpx_client_kwargs()
+
+        self.http_client = httpx.Client(**client_kwargs, headers=self.headers)
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         """Export spans to UiPath LLM Ops."""

{uipath-2.0.76 → uipath-2.0.78}/src/uipath/utils/_endpoints_manager.py

@@ -5,6 +5,8 @@ from typing import Optional
 
 import httpx
 
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+
 loggger = logging.getLogger(__name__)
 
 
@@ -56,7 +58,7 @@ class EndpointManager:
     def _check_agenthub(cls) -> bool:
         """Perform the actual check for AgentHub capabilities."""
         try:
-            with httpx.Client() as http_client:
+            with httpx.Client(**get_httpx_client_kwargs()) as http_client:
                 base_url = os.getenv("UIPATH_URL", "")
                 capabilities_url = f"{base_url.rstrip('/')}/{UiPathEndpoints.AH_CAPABILITIES_ENDPOINT.value}"
                 loggger.debug(f"Checking AgentHub capabilities at {capabilities_url}")

{uipath-2.0.76 → uipath-2.0.78}/tests/tracing/test_otel_exporters.py

@@ -42,7 +42,7 @@ def mock_span():
 @pytest.fixture
 def exporter(mock_env_vars):
     """Create an exporter instance for testing."""
-    with patch("uipath.tracing._otel_exporters.Client"):
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
         exporter = LlmOpsHttpExporter()
         # Mock _build_url to include query parameters as in the actual implementation
         exporter._build_url = MagicMock(  # type: ignore
@@ -53,7 +53,7 @@ def exporter(mock_env_vars):
 
 def test_init_with_env_vars(mock_env_vars):
     """Test initialization with environment variables."""
-    with patch("uipath.tracing._otel_exporters.Client"):
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
         exporter = LlmOpsHttpExporter()
 
         assert exporter.base_url == "https://test.uipath.com/org/tenant"
@@ -67,7 +67,7 @@ def test_init_with_env_vars(mock_env_vars):
 def test_init_with_default_url():
     """Test initialization with default URL when environment variable is not set."""
     with (
-        patch("uipath.tracing._otel_exporters.Client"),
+        patch("uipath.tracing._otel_exporters.httpx.Client"),
         patch.dict(os.environ, {"UIPATH_ACCESS_TOKEN": "test-token"}, clear=True),
     ):
         exporter = LlmOpsHttpExporter()
@@ -154,7 +154,7 @@ def test_get_base_url():
     with patch.dict(
         os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant/"}, clear=True
     ):
-        with patch("uipath.tracing._otel_exporters.Client"):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
             exporter = LlmOpsHttpExporter()
             assert exporter.base_url == "https://custom.uipath.com/org/tenant"
 
@@ -162,20 +162,20 @@ def test_get_base_url():
     with patch.dict(
         os.environ, {"UIPATH_URL": "https://custom.uipath.com/org/tenant"}, clear=True
     ):
-        with patch("uipath.tracing._otel_exporters.Client"):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
             exporter = LlmOpsHttpExporter()
             assert exporter.base_url == "https://custom.uipath.com/org/tenant"
 
     # Test with no environment variable
     with patch.dict(os.environ, {}, clear=True):
-        with patch("uipath.tracing._otel_exporters.Client"):
+        with patch("uipath.tracing._otel_exporters.httpx.Client"):
             exporter = LlmOpsHttpExporter()
             assert exporter.base_url == "https://cloud.uipath.com/dummyOrg/dummyTennant"
 
 
 def test_send_with_retries_success():
     """Test _send_with_retries method with successful response."""
-    with patch("uipath.tracing._otel_exporters.Client"):
+    with patch("uipath.tracing._otel_exporters.httpx.Client"):
         exporter = LlmOpsHttpExporter()
 
         mock_response = MagicMock()

{uipath-2.0.76 → uipath-2.0.78}/uv.lock

@@ -1,4 +1,5 @@
 version = 1
+revision = 1
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.12.4'",
@@ -3120,7 +3121,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.0.76"
+version = "2.0.78"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },

uipath-2.0.76/src/uipath/_cli/_utils/_constants.py

@@ -1 +0,0 @@
-BINDINGS_VERSION = "2.2"