uipath 2.0.75__tar.gz → 2.0.76__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.75
+Version: 2.0.76
 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/docs/index.md

@@ -0,0 +1,34 @@
+---
+title: Getting Started
+---
+
+<div class="grid cards" markdown>
+-   __UiPath SDK__
+
+    ---
+
+    Code with full UiPath context to build custom automations and agents from the ground up.
+
+    [Start Building](./core/getting_started.md)
+
+</div>
+
+<h2> Extensions </h2>
+<div class="grid cards" markdown>
+-   __UiPath Langchain SDK__
+
+    ---
+
+    Build enterprise-grade UiPath agents using the LangChain framework, with seamless integration from build to run.
+
+    [Get Started](./langchain/quick_start.md)
+
+-   __UiPath LLamaIndex SDK__
+
+    ---
+
+    Build enterprise-grade UiPath agents using the LLamaIndex framework, with seamless integration from build to run.
+
+    [Get Started](./llamaindex/quick_start.md)
+
+</div>

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.75"
+version = "2.0.76"
 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.75 → uipath-2.0.76}/src/uipath/_cli/cli_pack.py

@@ -1,10 +1,12 @@
 # type: ignore
 import json
 import os
+import re
 import subprocess
 import uuid
 import zipfile
 from string import Template
+from typing import Dict, Tuple
 
 import click
 
@@ -50,6 +52,7 @@ def check_config(directory):
         "entryPoints": config_data["entryPoints"],
         "version": toml_data["version"],
         "authors": toml_data["authors"],
+        "dependencies": toml_data.get("dependencies", {}),
     }
 
 
@@ -113,7 +116,7 @@ def handle_uv_operations(directory):
     run_uv_lock(directory)
 
 
-def generate_operate_file(entryPoints):
+def generate_operate_file(entryPoints, dependencies=None):
     project_id = str(uuid.uuid4())
 
     first_entry = entryPoints[0]
@@ -130,6 +133,10 @@ def generate_operate_file(entryPoints):
         "runtimeOptions": {"requiresUserInteraction": False, "isAttended": False},
     }
 
+    # Add dependencies if provided
+    if dependencies:
+        operate_json_data["dependencies"] = dependencies
+
     return operate_json_data
 
 
@@ -149,40 +156,6 @@ def generate_bindings_content():
     return bindings_content
 
 
-def get_proposed_version(directory):
-    output_dir = os.path.join(directory, ".uipath")
-    if not os.path.exists(output_dir):
-        return None
-
-    # Get all .nupkg files
-    nupkg_files = [f for f in os.listdir(output_dir) if f.endswith(".nupkg")]
-    if not nupkg_files:
-        return None
-
-    # Sort by modification time to get most recent
-    latest_file = max(
-        nupkg_files, key=lambda f: os.path.getmtime(os.path.join(output_dir, f))
-    )
-
-    # Extract version from filename
-    # Remove .nupkg extension first
-    name_version = latest_file[:-6]
-    # Find 3rd last occurrence of . by splitting and joining parts
-    parts = name_version.split(".")
-    if len(parts) >= 3:
-        version = ".".join(parts[-3:])
-    else:
-        version = name_version
-
-    # Increment patch version by 1
-    try:
-        major, minor, patch = version.split(".")
-        new_version = f"{major}.{minor}.{int(patch) + 1}"
-        return new_version
-    except Exception:
-        return "0.0.1"
-
-
 def generate_content_types_content():
     templates_path = os.path.join(
         os.path.dirname(__file__), "_templates", "[Content_Types].xml.template"
@@ -278,9 +251,10 @@ def pack_fn(
     version,
     authors,
     directory,
+    dependencies=None,
     include_uv_lock=True,
 ):
-    operate_file = generate_operate_file(entryPoints)
+    operate_file = generate_operate_file(entryPoints, dependencies)
     entrypoints_file = generate_entrypoints_file(entryPoints)
 
     # Get bindings from uipath.json if available
@@ -389,28 +363,166 @@ def pack_fn(
                         z.writestr(f"content/{file}", f.read())
 
 
-def read_toml_project(file_path: str) -> dict[str, any]:
-    with open(file_path, "rb") as f:
-        content = tomllib.load(f)
-        if "project" not in content:
-            console.error("pyproject.toml is missing the required field: project.")
-        if "name" not in content["project"]:
-            console.error("pyproject.toml is missing the required field: project.name.")
-        if "description" not in content["project"]:
+def parse_dependency_string(dependency: str) -> Tuple[str, str]:
+    """Parse a dependency string into package name and version specifier.
+
+    Handles PEP 508 dependency specifications including:
+    - Simple names: "requests"
+    - Version specifiers: "requests>=2.28.0"
+    - Complex specifiers: "requests>=2.28.0,<3.0.0"
+    - Extras: "requests[security]>=2.28.0"
+    - Environment markers: "requests>=2.28.0; python_version>='3.8'"
+
+    Args:
+        dependency: Raw dependency string from pyproject.toml
+
+    Returns:
+        Tuple of (package_name, version_specifier)
+
+    Examples:
+        "requests" -> ("requests", "*")
+        "requests>=2.28.0" -> ("requests", ">=2.28.0")
+        "requests>=2.28.0,<3.0.0" -> ("requests", ">=2.28.0,<3.0.0")
+        "requests[security]>=2.28.0" -> ("requests", ">=2.28.0")
+    """
+    # Remove whitespace
+    dependency = dependency.strip()
+
+    # Handle environment markers (everything after semicolon)
+    if ";" in dependency:
+        dependency = dependency.split(";")[0].strip()
+
+    # Pattern to match package name with optional extras and version specifiers
+    # Matches: package_name[extras] version_specs
+    pattern = r"^([a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?)(\[[^\]]+\])?(.*)"
+    match = re.match(pattern, dependency)
+
+    if not match:
+        # Fallback for edge cases
+        return dependency, "*"
+
+    package_name = match.group(1)
+    version_part = match.group(4).strip() if match.group(4) else ""
+
+    # If no version specifier, return wildcard
+    if not version_part:
+        return package_name, "*"
+
+    # Clean up version specifier
+    version_spec = version_part.strip()
+
+    # Validate that version specifier starts with a valid operator
+    valid_operators = [">=", "<=", "==", "!=", "~=", ">", "<"]
+    if not any(version_spec.startswith(op) for op in valid_operators):
+        # If it doesn't start with an operator, treat as exact version
+        if version_spec:
+            version_spec = f"=={version_spec}"
+        else:
+            version_spec = "*"
+
+    return package_name, version_spec
+
+
+def extract_dependencies_from_toml(project_data: Dict) -> Dict[str, str]:
+    """Extract and parse dependencies from pyproject.toml project data.
+
+    Args:
+        project_data: The "project" section from pyproject.toml
+
+    Returns:
+        Dictionary mapping package names to version specifiers
+    """
+    dependencies = {}
+
+    if "dependencies" not in project_data:
+        return dependencies
+
+    deps_list = project_data["dependencies"]
+    if not isinstance(deps_list, list):
+        console.warning("dependencies should be a list in pyproject.toml")
+        return dependencies
+
+    for dep in deps_list:
+        if not isinstance(dep, str):
+            console.warning(f"Skipping non-string dependency: {dep}")
+            continue
+
+        try:
+            name, version_spec = parse_dependency_string(dep)
+            if name:  # Only add if we got a valid name
+                dependencies[name] = version_spec
+        except Exception as e:
+            console.warning(f"Failed to parse dependency '{dep}': {e}")
+            continue
+
+    return dependencies
+
+
+def read_toml_project(file_path: str) -> dict:
+    """Read and parse pyproject.toml file with improved error handling and validation.
+
+    Args:
+        file_path: Path to pyproject.toml file
+
+    Returns:
+        Dictionary containing project metadata and dependencies
+    """
+    try:
+        with open(file_path, "rb") as f:
+            content = tomllib.load(f)
+    except Exception as e:
+        console.error(f"Failed to read or parse pyproject.toml: {e}")
+
+    # Validate required sections
+    if "project" not in content:
+        console.error("pyproject.toml is missing the required field: project.")
+
+    project = content["project"]
+
+    # Validate required fields with better error messages
+    required_fields = {
+        "name": "Project name is required in pyproject.toml",
+        "description": "Project description is required in pyproject.toml",
+        "version": "Project version is required in pyproject.toml",
+    }
+
+    for field, error_msg in required_fields.items():
+        if field not in project:
             console.error(
-                "pyproject.toml is missing the required field: project.description."
+                f"pyproject.toml is missing the required field: project.{field}. {error_msg}"
             )
-        if "version" not in content["project"]:
+
+        # Check for empty values only if field exists
+        if field in project and (
+            not project[field]
+            or (isinstance(project[field], str) and not project[field].strip())
+        ):
             console.error(
-                "pyproject.toml is missing the required field: project.version."
+                f"Project {field} cannot be empty. Please specify a {field} in pyproject.toml."
             )
 
-        return {
-            "name": content["project"]["name"],
-            "description": content["project"]["description"],
-            "version": content["project"]["version"],
-            "authors": content["project"].get("authors", [{"name": ""}])[0]["name"],
-        }
+    # Extract author information safely
+    authors = project.get("authors", [])
+    author_name = ""
+
+    if authors and isinstance(authors, list) and len(authors) > 0:
+        first_author = authors[0]
+        if isinstance(first_author, dict):
+            author_name = first_author.get("name", "")
+        elif isinstance(first_author, str):
+            # Handle case where authors is a list of strings
+            author_name = first_author
+
+    # Extract dependencies with improved parsing
+    dependencies = extract_dependencies_from_toml(project)
+
+    return {
+        "name": project["name"].strip(),
+        "description": project["description"].strip(),
+        "version": project["version"].strip(),
+        "authors": author_name.strip(),
+        "dependencies": dependencies,
+    }
 
 
 def get_project_version(directory):
@@ -492,6 +604,7 @@ def pack(root, nolock):
                 version or config["version"],
                 config["authors"],
                 root,
+                config.get("dependencies"),
                 include_uv_lock=not nolock,
             )
             display_project_info(config)

{uipath-2.0.75 → uipath-2.0.76}/tests/cli/test_pack.py

@@ -324,3 +324,150 @@ class TestPack:
                 }
                 assert f"Authors    : {', '.join(authors_dict.keys())}" in result.output
                 assert "Project successfully packaged." in result.output
+
+    def test_dependencies_version_formats(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        project_details: ProjectDetails,
+        uipath_json: UiPathJson,
+    ) -> None:
+        """Test that all dependency version formats are parsed correctly and included in operate.json."""
+
+        # Update project details with comprehensive dependency examples
+        project_details.dependencies = [
+            # Simple package name
+            "click",
+            # Single version constraints
+            "django>=4.0",
+            "flask==2.3.0",
+            "numpy>1.20.0",
+            "pandas<=2.0.0",
+            "scipy<1.11.0",
+            "matplotlib~=3.5.0",
+            "pytest!=7.1.0",
+            # Complex version constraints
+            "tensorflow>=2.10.0,<2.13.0",
+            "torch>=1.12.0,<=1.13.1",
+            # Package with extras
+            "requests[security]>=2.28.0",
+            "sqlalchemy[postgresql,mysql]>=1.4.0",
+            # Environment markers (should be stripped)
+            "pywin32>=227; sys_platform=='win32'",
+            "uvloop>=0.17.0; python_version>='3.8' and sys_platform!='win32'",
+            # Complex combination
+            "cryptography[ssh]>=3.4.8,<4.0.0; python_version>='3.7'",
+            # Edge cases
+            "some-package_with.dots_and-dashes>=1.0.0",
+            "CamelCasePackage==2.1.0",
+        ]
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create necessary files
+            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 entry point files
+            for entry in uipath_json.entry_points:
+                with open(f"{entry.file_path}.py", "w") as f:
+                    f.write("# agent content")
+
+            # Run pack command
+            result = runner.invoke(pack, ["./"])
+
+            # Assert pack was successful
+            assert result.exit_code == 0, f"Pack failed with output: {result.output}"
+            assert "Project successfully packaged." in result.output
+
+            # Verify package was created
+            package_path = (
+                f".uipath/{project_details.name}.{project_details.version}.nupkg"
+            )
+            assert os.path.exists(package_path)
+
+            # Extract and verify operate.json content
+            with zipfile.ZipFile(package_path, "r") as z:
+                # Read operate.json
+                operate_content = z.read("content/operate.json").decode("utf-8")
+                operate_data = json.loads(operate_content)
+
+                # Verify dependencies exist in operate.json
+                assert "dependencies" in operate_data, (
+                    "Dependencies should be present in operate.json"
+                )
+
+                dependencies = operate_data["dependencies"]
+
+                # Expected parsed dependencies (name -> version_spec)
+                expected_dependencies = {
+                    # Simple package name
+                    "click": "*",
+                    # Single version constraints
+                    "django": ">=4.0",
+                    "flask": "==2.3.0",
+                    "numpy": ">1.20.0",
+                    "pandas": "<=2.0.0",
+                    "scipy": "<1.11.0",
+                    "matplotlib": "~=3.5.0",
+                    "pytest": "!=7.1.0",
+                    # Complex version constraints
+                    "tensorflow": ">=2.10.0,<2.13.0",
+                    "torch": ">=1.12.0,<=1.13.1",
+                    # Package with extras (extras should be stripped)
+                    "requests": ">=2.28.0",
+                    "sqlalchemy": ">=1.4.0",
+                    # Environment markers (markers should be stripped)
+                    "pywin32": ">=227",
+                    "uvloop": ">=0.17.0",
+                    # Complex combination (extras and markers stripped)
+                    "cryptography": ">=3.4.8,<4.0.0",
+                    # Edge cases
+                    "some-package_with.dots_and-dashes": ">=1.0.0",
+                    "CamelCasePackage": "==2.1.0",
+                }
+
+                # Verify all expected dependencies are present
+                for package_name, expected_version in expected_dependencies.items():
+                    assert package_name in dependencies, (
+                        f"Package '{package_name}' should be in dependencies"
+                    )
+                    actual_version = dependencies[package_name]
+                    assert actual_version == expected_version, (
+                        f"Package '{package_name}' should have version '{expected_version}', "
+                        f"but got '{actual_version}'"
+                    )
+
+                # Verify no unexpected dependencies
+                for package_name in dependencies:
+                    assert package_name in expected_dependencies, (
+                        f"Unexpected package '{package_name}' found in dependencies"
+                    )
+
+                # Verify specific edge cases
+                assert len(dependencies) == len(expected_dependencies), (
+                    f"Expected {len(expected_dependencies)} dependencies, "
+                    f"but got {len(dependencies)}"
+                )
+
+                # Test that environment markers were properly stripped
+                assert "pywin32" in dependencies
+                assert dependencies["pywin32"] == ">=227"
+
+                # Test that extras were properly stripped but version preserved
+                assert "sqlalchemy" in dependencies
+                assert dependencies["sqlalchemy"] == ">=1.4.0"
+
+                # Test complex version constraints are preserved
+                assert "tensorflow" in dependencies
+                assert dependencies["tensorflow"] == ">=2.10.0,<2.13.0"
+
+                # Verify operate.json structure is still correct
+                assert (
+                    operate_data["$schema"]
+                    == "https://cloud.uipath.com/draft/2024-12/entry-point"
+                )
+                assert "projectId" in operate_data
+                assert operate_data["targetRuntime"] == "python"
+                assert operate_data["targetFramework"] == "Portable"