uipath 2.0.0.dev3__py3-none-any.whl → 2.0.1.dev1__py3-none-any.whl

uipath/_cli/cli_init.py

@@ -0,0 +1,113 @@
+# type: ignore
+import json
+import os
+import traceback
+import uuid
+from typing import Optional
+
+import click
+
+from ._utils._input_args import generate_args
+from ._utils._parse_ast import generate_bindings_json
+from .middlewares import Middlewares
+
+
+def generate_env_file(target_directory):
+    env_path = os.path.join(target_directory, ".env")
+
+    if not os.path.exists(env_path):
+        relative_path = os.path.relpath(env_path, target_directory)
+        click.echo(f"Created {relative_path} file.")
+        with open(env_path, "w") as f:
+            f.write("UIPATH_ACCESS_TOKEN=YOUR_TOKEN_HERE\n")
+            f.write("UIPATH_URL=https://alpha.uipath.com/ACCOUNT_NAME/TENANT_NAME\n")
+
+
+def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:
+    """Find the Python script to process."""
+    if entrypoint:
+        script_path = os.path.join(directory, entrypoint)
+        if not os.path.isfile(script_path):
+            click.echo(f"The {entrypoint} file does not exist in the current directory")
+            return None
+        return script_path
+
+    python_files = [f for f in os.listdir(directory) if f.endswith(".py")]
+
+    if not python_files:
+        click.echo("No Python files found in the directory")
+        return None
+    elif len(python_files) == 1:
+        return os.path.join(directory, python_files[0])
+    else:
+        click.echo(
+            "Multiple Python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
+        )
+        return None
+
+
+@click.command()
+@click.argument("entrypoint", required=False, default=None)
+def init(entrypoint: str) -> None:
+    """Initialize a uipath.json configuration file for the script."""
+    current_directory = os.getcwd()
+    generate_env_file(current_directory)
+
+    result = Middlewares.next("init", entrypoint)
+
+    if result.error_message:
+        click.echo(result.error_message)
+        if result.should_include_stacktrace:
+            click.echo(traceback.format_exc())
+        click.get_current_context().exit(1)
+
+    if result.info_message:
+        click.echo(result.info_message)
+
+    if not result.should_continue:
+        return
+
+    script_path = get_user_script(current_directory, entrypoint=entrypoint)
+
+    if not script_path:
+        click.get_current_context().exit(1)
+
+    try:
+        args = generate_args(script_path)
+
+        relative_path = os.path.relpath(script_path, current_directory)
+
+        config_data = {
+            "entryPoints": [
+                {
+                    "filePath": relative_path,
+                    "uniqueId": str(uuid.uuid4()),
+                    # "type": "process", OR BE doesn't offer json schema support for type: Process
+                    "type": "agent",
+                    "input": args["input"],
+                    "output": args["output"],
+                }
+            ]
+        }
+
+        # Generate bindings JSON based on the script path
+        try:
+            bindings_data = generate_bindings_json(script_path)
+
+            # Add bindings to the config data
+            config_data["bindings"] = bindings_data
+
+            click.echo("Bindings generated successfully.")
+        except Exception as e:
+            click.echo(f"Warning: Could not generate bindings: {str(e)}")
+
+        config_path = "uipath.json"
+        with open(config_path, "w") as config_file:
+            json.dump(config_data, config_file, indent=4)
+
+        click.echo(f"Configuration file {config_path} created successfully.")
+
+    except Exception as e:
+        click.echo(f"Error generating configuration: {str(e)}")
+        click.echo(traceback.format_exc())
+        click.get_current_context().exit(1)

uipath/_cli/cli_new.py

@@ -0,0 +1,76 @@
+# type: ignore
+import os
+import shutil
+import traceback
+
+import click
+
+from .middlewares import Middlewares
+
+
+def generate_script(target_directory):
+    template_path = os.path.join(
+        os.path.dirname(__file__), "_templates/main.py.template"
+    )
+    target_path = os.path.join(target_directory, "main.py")
+
+    shutil.copyfile(template_path, target_path)
+
+
+def generate_pyproject(target_directory, project_name):
+    project_toml_path = os.path.join(target_directory, "pyproject.toml")
+    toml_content = f"""[project]
+name = "{project_name}"
+version = "0.0.1"
+description = "{project_name}"
+authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
+dependencies = [
+    "uipath>=2.0.0"
+]
+requires-python = ">=3.9"
+"""
+
+    with open(project_toml_path, "w") as f:
+        f.write(toml_content)
+
+
+@click.command()
+@click.argument("name", type=str, default="")
+def new(name: str):
+    directory = os.getcwd()
+
+    if not name:
+        raise click.UsageError(
+            "Please specify a name for your project\n`uipath new hello-world`"
+        )
+
+    click.echo(f"Initializing project {name} in current directory..")
+
+    result = Middlewares.next("new", name)
+
+    if result.error_message:
+        click.echo(result.error_message)
+        if result.should_include_stacktrace:
+            click.echo(traceback.format_exc())
+        click.get_current_context().exit(1)
+
+    if result.info_message:
+        click.echo(result.info_message)
+
+    if not result.should_continue:
+        return
+
+    generate_script(directory)
+    click.echo("Created main.py file.")
+    generate_pyproject(directory, name)
+    click.echo("Created pyproject.toml file.")
+
+    ctx = click.get_current_context()
+    init_cmd = ctx.parent.command.get_command(ctx, "init")
+    ctx.invoke(init_cmd)
+
+    click.echo("""` uipath run main.py '{"message": "Hello World!"}' `""")
+
+
+if __name__ == "__main__":
+    new()

uipath/_cli/cli_pack.py

@@ -0,0 +1,337 @@
+# type: ignore
+import json
+import os
+import uuid
+import zipfile
+from string import Template
+
+import click
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+from ._utils._parse_ast import generate_bindings_json
+
+schema = "https://cloud.uipath.com/draft/2024-12/entry-point"
+
+
+def validate_config_structure(config_data):
+    required_fields = ["entryPoints"]
+    for field in required_fields:
+        if field not in config_data:
+            raise Exception(f"uipath.json is missing the required field: {field}")
+
+
+def check_config(directory):
+    config_path = os.path.join(directory, "uipath.json")
+    toml_path = os.path.join(directory, "pyproject.toml")
+
+    if not os.path.isfile(config_path):
+        raise Exception("uipath.json not found, please run `uipath init`")
+    if not os.path.isfile(toml_path):
+        raise Exception("pyproject.toml not found")
+
+    with open(config_path, "r") as config_file:
+        config_data = json.load(config_file)
+
+    validate_config_structure(config_data)
+
+    toml_data = read_toml_project(toml_path)
+
+    return {
+        "project_name": toml_data["name"],
+        "description": toml_data["description"],
+        "entryPoints": config_data["entryPoints"],
+        "version": toml_data["version"],
+        "authors": toml_data["authors"],
+    }
+
+
+def generate_operate_file(entryPoints):
+    project_id = str(uuid.uuid4())
+
+    first_entry = entryPoints[0]
+    file_path = first_entry["filePath"]
+    type = first_entry["type"]
+
+    operate_json_data = {
+        "$schema": schema,
+        "projectId": project_id,
+        "main": file_path,
+        "contentType": type,
+        "targetFramework": "Portable",
+        "targetRuntime": "python",
+        "runtimeOptions": {"requiresUserInteraction": False, "isAttended": False},
+    }
+
+    return operate_json_data
+
+
+def generate_entrypoints_file(entryPoints):
+    entrypoint_json_data = {
+        "$schema": schema,
+        "$id": "entry-points.json",
+        "entryPoints": entryPoints,
+    }
+
+    return entrypoint_json_data
+
+
+def generate_bindings_content():
+    bindings_content = {"version": "2.0", "resources": []}
+
+    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"
+    )
+    with open(templates_path, "r") as file:
+        content_types_content = file.read()
+    return content_types_content
+
+
+def generate_nuspec_content(projectName, packageVersion, description, authors):
+    variables = {
+        "packageName": projectName,
+        "packageVersion": packageVersion,
+        "description": description,
+        "authors": authors,
+    }
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", "package.nuspec.template"
+    )
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+    return Template(content).substitute(variables)
+
+
+def generate_rels_content(nuspecPath, psmdcpPath):
+    # /package/services/metadata/core-properties/254324ccede240e093a925f0231429a0.psmdcp
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", ".rels.template"
+    )
+    nuspecId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
+    psmdcpId = "R" + str(uuid.uuid4()).replace("-", "")[:16]
+    variables = {
+        "nuspecPath": nuspecPath,
+        "nuspecId": nuspecId,
+        "psmdcpPath": psmdcpPath,
+        "psmdcpId": psmdcpId,
+    }
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+    return Template(content).substitute(variables)
+
+
+def generate_psmdcp_content(projectName, version, description, authors):
+    templates_path = os.path.join(
+        os.path.dirname(__file__), "_templates", ".psmdcp.template"
+    )
+
+    token = str(uuid.uuid4()).replace("-", "")[:32]
+    random_file_name = f"{uuid.uuid4().hex[:16]}.psmdcp"
+    variables = {
+        "creator": authors,
+        "description": description,
+        "packageVersion": version,
+        "projectName": projectName,
+        "publicKeyToken": token,
+    }
+    with open(templates_path, "r", encoding="utf-8-sig") as f:
+        content = f.read()
+
+    return [random_file_name, Template(content).substitute(variables)]
+
+
+def generate_package_descriptor_content(entryPoints):
+    files = {
+        "operate.json": "content/operate.json",
+        "entry-points.json": "content/entry-points.json",
+        "bindings.json": "content/bindings_v2.json",
+    }
+
+    for entry in entryPoints:
+        files[entry["filePath"]] = entry["filePath"]
+
+    package_descriptor_content = {
+        "$schema": "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+        "files": files,
+    }
+
+    return package_descriptor_content
+
+
+def pack_fn(projectName, description, entryPoints, version, authors, directory):
+    operate_file = generate_operate_file(entryPoints)
+    entrypoints_file = generate_entrypoints_file(entryPoints)
+
+    # Get bindings from uipath.json if available
+    config_path = os.path.join(directory, "uipath.json")
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            config_data = json.load(f)
+            if "bindings" in config_data:
+                bindings_content = config_data["bindings"]
+            else:
+                # Fall back to generating bindings from the first entry point
+                bindings_content = generate_bindings_json(entryPoints[0]["filePath"])
+    else:
+        # Fall back to generating bindings from the first entry point
+        bindings_content = generate_bindings_json(entryPoints[0]["filePath"])
+
+    content_types_content = generate_content_types_content()
+    [psmdcp_file_name, psmdcp_content] = generate_psmdcp_content(
+        projectName, version, description, authors
+    )
+    nuspec_content = generate_nuspec_content(projectName, version, description, authors)
+    rels_content = generate_rels_content(
+        f"/{projectName}.nuspec",
+        f"/package/services/metadata/core-properties/{psmdcp_file_name}",
+    )
+    package_descriptor_content = generate_package_descriptor_content(entryPoints)
+
+    # Create .uipath directory if it doesn't exist
+    os.makedirs(".uipath", exist_ok=True)
+
+    # Define the allowlist of file extensions to include
+    file_extensions_allowlist = [".py", ".mermaid", ".json"]
+
+    with zipfile.ZipFile(
+        f".uipath/{projectName}.{version}.nupkg", "w", zipfile.ZIP_DEFLATED
+    ) as z:
+        # Add metadata files
+        z.writestr(
+            f"./package/services/metadata/core-properties/{psmdcp_file_name}",
+            psmdcp_content,
+        )
+        z.writestr("[Content_Types].xml", content_types_content)
+        z.writestr(
+            "content/package-descriptor.json",
+            json.dumps(package_descriptor_content, indent=4),
+        )
+        z.writestr("content/operate.json", json.dumps(operate_file, indent=4))
+        z.writestr("content/entry-points.json", json.dumps(entrypoints_file, indent=4))
+        z.writestr("content/bindings_v2.json", json.dumps(bindings_content, indent=4))
+        z.writestr(f"{projectName}.nuspec", nuspec_content)
+        z.writestr("_rels/.rels", rels_content)
+
+        # Walk through directory and add all files with extensions in the allowlist
+        for root, dirs, files in os.walk(directory):
+            # Skip all directories that start with .
+            dirs[:] = [d for d in dirs if not d.startswith(".")]
+
+            for file in files:
+                file_extension = os.path.splitext(file)[1].lower()
+                if file_extension in file_extensions_allowlist:
+                    file_path = os.path.join(root, file)
+                    rel_path = os.path.relpath(file_path, directory)
+                    try:
+                        # Try UTF-8 first
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            z.writestr(f"content/{rel_path}", f.read())
+                    except UnicodeDecodeError:
+                        # If UTF-8 fails, try with utf-8-sig (for files with BOM)
+                        try:
+                            with open(file_path, "r", encoding="utf-8-sig") as f:
+                                z.writestr(f"content/{rel_path}", f.read())
+                        except UnicodeDecodeError:
+                            # If that also fails, try with latin-1 as a fallback
+                            with open(file_path, "r", encoding="latin-1") as f:
+                                z.writestr(f"content/{rel_path}", f.read())
+
+        optional_files = ["pyproject.toml", "README.md"]
+        for file in optional_files:
+            file_path = os.path.join(directory, file)
+            if os.path.exists(file_path):
+                try:
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        z.writestr(f"content/{file}", f.read())
+                except UnicodeDecodeError:
+                    with open(file_path, "r", encoding="latin-1") as f:
+                        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)
+        return {
+            "name": content["project"]["name"],
+            "description": content["project"]["description"],
+            "version": content["project"]["version"],
+            "authors": content["project"].get("authors", [{"name": ""}])[0]["name"],
+        }
+
+
+def get_project_version(directory):
+    toml_path = os.path.join(directory, "pyproject.toml")
+    if not os.path.exists(toml_path):
+        click.echo("Warning: No pyproject.toml found. Using default version 0.0.1")
+        return "0.0.1"
+    toml_data = read_toml_project(toml_path)
+    return toml_data["version"]
+
+
+@click.command()
+@click.argument("root", type=str, default="./")
+def pack(root):
+    version = get_project_version(root)
+
+    while not os.path.isfile(os.path.join(root, "uipath.json")):
+        click.echo(
+            "uipath.json not found. Please run `uipath init` in the project directory."
+        )
+        return
+    config = check_config(root)
+    click.echo(
+        f"Packaging project {config['project_name']}:{version or config['version']} description {config['description']} authored by {config['authors']}"
+    )
+    pack_fn(
+        config["project_name"],
+        config["description"],
+        config["entryPoints"],
+        version or config["version"],
+        config["authors"],
+        root,
+    )
+
+
+if __name__ == "__main__":
+    pack()

uipath/_cli/cli_publish.py

@@ -0,0 +1,113 @@
+# type: ignore
+import os
+
+import click
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def get_most_recent_package():
+    nupkg_files = [f for f in os.listdir(".uipath") if f.endswith(".nupkg")]
+    if not nupkg_files:
+        click.echo("No .nupkg file found in .uipath directory")
+        return
+
+    # Get full path and modification time for each file
+    nupkg_files_with_time = [
+        (f, os.path.getmtime(os.path.join(".uipath", f))) for f in nupkg_files
+    ]
+
+    # Sort by modification time (most recent first)
+    nupkg_files_with_time.sort(key=lambda x: x[1], reverse=True)
+
+    # Get most recent file
+    return nupkg_files_with_time[0][0]
+
+
+def get_env_vars():
+    base_url = os.environ.get("UIPATH_URL")
+    token = os.environ.get("UIPATH_ACCESS_TOKEN")
+
+    if not all([base_url, token]):
+        click.echo(
+            "Missing required environment variables. Please check your .env file contains:"
+        )
+        click.echo("UIPATH_URL, UIPATH_ACCESS_TOKEN")
+        raise click.Abort("Missing environment variables")
+
+    return [base_url, token]
+
+
+@click.command()
+@click.option(
+    "--tenant",
+    "-t",
+    "feed",
+    flag_value="tenant",
+    help="Whether to publish to the tenant package feed",
+)
+@click.option(
+    "--personal-workspace",
+    "-p",
+    "feed",
+    flag_value="personal",
+    help="Whether to publish to the personal workspace",
+)
+def publish(feed):
+    if feed is None:
+        click.echo("Select feed type:")
+        click.echo("  0: Tenant package feed")
+        click.echo("  1: Personal workspace")
+        feed_idx = click.prompt("Select feed", type=int)
+        feed = "tenant" if feed_idx == 0 else "personal"
+        click.echo(f"Selected feed: {feed}")
+    os.makedirs(".uipath", exist_ok=True)
+
+    # Find most recent .nupkg file in .uipath directory
+    most_recent = get_most_recent_package()
+
+    if not most_recent:
+        click.echo("Error: No package files found in .uipath directory")
+        raise click.Abort()
+    click.echo(f"Publishing most recent package: {most_recent}")
+
+    package_to_publish_path = os.path.join(".uipath", most_recent)
+
+    [base_url, token] = get_env_vars()
+
+    url = f"{base_url}/orchestrator_/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage()"
+
+    if feed == "personal":
+        # Get current user extended info to get personal workspace ID
+        user_url = f"{base_url}/orchestrator_/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended"
+        user_response = requests.get(
+            user_url, headers={"Authorization": f"Bearer {token}"}
+        )
+
+        if user_response.status_code != 200:
+            click.echo("Failed to get user info")
+            click.echo(f"Response: {user_response.text}")
+            raise click.Abort()
+
+        user_data = user_response.json()
+        personal_workspace_id = user_data.get("PersonalWorskpaceFeedId")
+
+        if not personal_workspace_id:
+            click.echo("No personal workspace found for user")
+            raise click.Abort()
+
+        url = url + "?feedId=" + personal_workspace_id
+
+    headers = {"Authorization": f"Bearer {token}"}
+
+    with open(package_to_publish_path, "rb") as f:
+        files = {"file": (package_to_publish_path, f, "application/octet-stream")}
+        response = requests.post(url, headers=headers, files=files)
+
+    if response.status_code == 200:
+        click.echo("Package published successfully!")
+    else:
+        click.echo(f"Failed to publish package. Status code: {response.status_code}")
+        click.echo(f"Response: {response.text}")