uipath 2.0.26__py3-none-any.whl → 2.0.27__py3-none-any.whl

uipath/_cli/cli_init.py

@@ -1,17 +1,18 @@
 # type: ignore
 import json
 import os
-import traceback
 import uuid
 from pathlib import Path
 from typing import Optional
 
 import click
 
+from ._utils._console import ConsoleLogger
 from ._utils._input_args import generate_args
 from ._utils._parse_ast import generate_bindings_json
 from .middlewares import Middlewares
-from .spinner import Spinner
+
+console = ConsoleLogger()
 
 
 def generate_env_file(target_directory):
@@ -19,7 +20,7 @@ def generate_env_file(target_directory):
 
     if not os.path.exists(env_path):
         relative_path = os.path.relpath(env_path, target_directory)
-        click.echo(f"Created {relative_path} file.")
+        console.info(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://cloud.uipath.com/ACCOUNT_NAME/TENANT_NAME\n")
@@ -30,20 +31,22 @@ def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optiona
     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")
+            console.error(
+                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")
+        console.error("No python files found in the current 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>`"
+        console.error(
+            "Multiple python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
         )
         return None
 
@@ -51,67 +54,59 @@ def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optiona
 @click.command()
 @click.argument("entrypoint", required=False, default=None)
 def init(entrypoint: str) -> None:
-    """Initialize a uipath.json configuration file for the script."""
-    spinner = Spinner("Initializing UiPath project...")
-    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)
-    spinner.start()
-    try:
-        args = generate_args(script_path)
-
-        relative_path = Path(script_path).relative_to(current_directory).as_posix()
-
-        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
-        except Exception as e:
-            click.echo(f"⚠️ Warning: Could not generate bindings: {str(e)}")
+    """Create uipath.json with input/output schemas and bindings."""
+    with console.spinner("Initializing UiPath project ..."):
+        current_directory = os.getcwd()
+        generate_env_file(current_directory)
 
-        config_path = "uipath.json"
-        with open(config_path, "w") as config_file:
-            json.dump(config_data, config_file, indent=4)
+        result = Middlewares.next("init", entrypoint)
 
-        spinner.stop()
-        click.echo(
-            click.style("✓ ", fg="green", bold=True)
-            + f"Configuration file {config_path} created successfully."
-        )
+        if result.error_message:
+            console.error(
+                result.error_message, include_traceback=result.should_include_stacktrace
+            )
+
+        if result.info_message:
+            console.info(result.info_message)
 
-    except Exception as e:
-        spinner.stop()
-        click.echo(f"❌ Error generating configuration: {str(e)}")
-        click.echo(traceback.format_exc())
-        click.get_current_context().exit(1)
+        if not result.should_continue:
+            return
+
+        script_path = get_user_script(current_directory, entrypoint=entrypoint)
+
+        if not script_path:
+            return
+
+        try:
+            args = generate_args(script_path)
+
+            relative_path = Path(script_path).relative_to(current_directory).as_posix()
+
+            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
+            except Exception as e:
+                console.warning(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)
+
+            console.success(f"Created '{config_path}' file.")
+        except Exception as e:
+            console.error(f"Error creating configuration file: {str(e)}")

uipath/_cli/cli_invoke.py

@@ -7,7 +7,7 @@ import click
 import requests
 from dotenv import load_dotenv
 
-from .spinner import Spinner
+from ._utils._console import ConsoleLogger
 
 try:
     import tomllib
@@ -20,22 +20,21 @@ from ._utils._processes import get_release_info
 
 logger = logging.getLogger(__name__)
 load_dotenv()
+console = ConsoleLogger()
 
 
 def _read_project_name() -> str:
     current_path = os.getcwd()
     toml_path = os.path.join(current_path, "pyproject.toml")
     if not os.path.isfile(toml_path):
-        raise Exception("pyproject.toml not found")
+        console.error("pyproject.toml not found.")
 
     with open(toml_path, "rb") as f:
         content = tomllib.load(f)
         if "project" not in content:
-            raise Exception("pyproject.toml is missing the required field: project")
+            console.error("pyproject.toml is missing the required field: project.")
         if "name" not in content["project"]:
-            raise Exception(
-                "pyproject.toml is missing the required field: project.name"
-            )
+            console.error("pyproject.toml is missing the required field: project.name.")
 
         return content["project"]["name"]
 
@@ -44,60 +43,54 @@ def _read_project_name() -> str:
 @click.argument("entrypoint", required=False)
 @click.argument("input", required=False, default="{}")
 def invoke(entrypoint: Optional[str], input: Optional[str]) -> None:
-    """Invoke a remote agent with JSON input."""
-    spinner = Spinner("Starting job...")
-    spinner.start()
+    """Invoke a published agent."""
+    with console.spinner("Loading configuration ..."):
+        current_path = os.getcwd()
+        load_dotenv(os.path.join(current_path, ".env"), override=True)
+        [base_url, token] = get_env_vars()
+
+        url = f"{base_url}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
+        _, personal_workspace_folder_id = get_personal_workspace_info(base_url, token)
+        project_name = _read_project_name()
+
+        if not personal_workspace_folder_id:
+            console.error(
+                "No personal workspace found for user. Please try reauthenticating."
+            )
 
-    current_path = os.getcwd()
-    load_dotenv(os.path.join(current_path, ".env"), override=True)
-    [base_url, token] = get_env_vars(spinner)
-
-    url = f"{base_url}/orchestrator_/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs"
-    _, personal_workspace_folder_id = get_personal_workspace_info(
-        base_url, token, spinner
-    )
-    project_name = _read_project_name()
-
-    _, release_key = get_release_info(
-        base_url, token, project_name, personal_workspace_folder_id, spinner
-    )
-    payload = {
-        "StartInfo": {
-            "ReleaseKey": str(release_key),
-            "RunAsMe": True,
-            "InputArguments": input,
-            "EntryPointPath": entrypoint,
+        _, release_key = get_release_info(
+            base_url, token, project_name, personal_workspace_folder_id
+        )
+        payload = {
+            "StartInfo": {
+                "ReleaseKey": str(release_key),
+                "RunAsMe": True,
+                "InputArguments": input,
+                "EntryPointPath": entrypoint,
+            }
+        }
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "x-uipath-organizationunitid": str(personal_workspace_folder_id),
         }
-    }
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "x-uipath-organizationunitid": str(personal_workspace_folder_id),
-    }
 
-    response = requests.post(url, json=payload, headers=headers)
-    spinner.stop()
+        response = requests.post(url, json=payload, headers=headers)
 
     if response.status_code == 201:
         job_key = None
         try:
             job_key = response.json()["value"][0]["Key"]
         except KeyError:
-            click.echo("Error: Failed to get job key from response")
-            click.Abort()
+            console.error("Error: Failed to get job key from response")
         if job_key:
-            job_url = f"{base_url}/orchestrator_/jobs(sidepanel:sidepanel/jobs/{job_key}/details)?fid={personal_workspace_folder_id}"
-            click.echo("✨ Job started successfully!")
-            click.echo(
-                "🔗 Monitor your job here: "
-                + click.style(
-                    f"\u001b]8;;{job_url}\u001b\\{job_url}\u001b]8;;\u001b\\",
-                    fg="bright_blue",
-                    bold=True,
-                )
-            )
+            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:
-        click.echo(f"\n❌ Error starting job: {response.text}")
-        click.Abort()
+        console.error(
+            f"Error: Failed to start job. Status code: {response.status_code} {response.text}"
+        )
 
 
 if __name__ == "__main__":

uipath/_cli/cli_new.py

@@ -1,12 +1,13 @@
 # type: ignore
 import os
 import shutil
-import traceback
 
 import click
 
+from ._utils._console import ConsoleLogger
 from .middlewares import Middlewares
-from .spinner import Spinner
+
+console = ConsoleLogger()
 
 
 def generate_script(target_directory):
@@ -26,9 +27,9 @@ version = "0.0.1"
 description = "{project_name}"
 authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
 dependencies = [
-    "uipath>=2.0.0"
+    "uipath>=2.0.26"
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 """
 
     with open(project_toml_path, "w") as f:
@@ -38,44 +39,38 @@ requires-python = ">=3.9"
 @click.command()
 @click.argument("name", type=str, default="")
 def new(name: str):
-    spinner = Spinner("Creating new project...")
+    """Generate a quick-start project."""
     directory = os.getcwd()
 
     if not name:
-        raise click.UsageError(
-            "Please specify a name for your project\n`uipath new hello-world`"
+        console.error(
+            "Please specify a name for your project:\n`uipath new hello-world`"
         )
 
-    click.echo(
-        click.style("✓ ", fg="green", bold=True)
-        + 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)
+        console.error(
+            result.error_message, include_traceback=result.should_include_stacktrace
+        )
 
     if result.info_message:
-        click.echo(result.info_message)
+        console.info(result.info_message)
 
     if not result.should_continue:
         return
 
-    generate_script(directory)
-    click.echo(click.style("✓ ", fg="green", bold=True) + "Created main.py file")
-    generate_pyproject(directory, name)
-    click.echo(click.style("✓ ", fg="green", bold=True) + "Created pyproject.toml file")
-    spinner.start()
-    ctx = click.get_current_context()
-    init_cmd = ctx.parent.command.get_command(ctx, "init")
-    ctx.invoke(init_cmd)
-    spinner.stop()
-
-    click.echo("""` uipath run main.py '{"message": "Hello World!"}' `""")
+    with console.spinner(f"Creating new project {name} in current directory ..."):
+        generate_script(directory)
+        console.success("Created 'main.py' file.")
+        generate_pyproject(directory, name)
+        console.success("Created 'pyproject.toml' file.")
+        ctx = click.get_current_context()
+        init_cmd = ctx.parent.command.get_command(ctx, "init")
+        ctx.invoke(init_cmd)
+        console.hint(
+            """Run project: uipath run main.py '{"message": "Hello World!"}'"""
+        )
 
 
 if __name__ == "__main__":

uipath/_cli/cli_pack.py

@@ -12,7 +12,9 @@ try:
 except ImportError:
     import tomli as tomllib
 
-from .spinner import Spinner
+from ._utils._console import ConsoleLogger
+
+console = ConsoleLogger()
 
 schema = "https://cloud.uipath.com/draft/2024-12/entry-point"
 
@@ -21,7 +23,7 @@ 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}")
+            console.error(f"uipath.json is missing the required field: {field}.")
 
 
 def check_config(directory):
@@ -29,9 +31,9 @@ def check_config(directory):
     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`")
+        console.error("uipath.json not found, please run `uipath init`.")
     if not os.path.isfile(toml_path):
-        raise Exception("pyproject.toml not found")
+        console.error("pyproject.toml not found.")
 
     with open(config_path, "r") as config_file:
         config_data = json.load(config_file)
@@ -206,7 +208,7 @@ def pack_fn(projectName, description, entryPoints, version, authors, directory):
     # Get bindings from uipath.json if available
     config_path = os.path.join(directory, "uipath.json")
     if not os.path.exists(config_path):
-        raise Exception("uipath.json not found, please run `uipath init`")
+        console.error("uipath.json not found, please run `uipath init`.")
 
     # Define the allowlist of file extensions to include
     file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml"]
@@ -305,18 +307,16 @@ 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:
-            raise Exception("pyproject.toml is missing the required field: project")
+            console.error("pyproject.toml is missing the required field: project.")
         if "name" not in content["project"]:
-            raise Exception(
-                "pyproject.toml is missing the required field: project.name"
-            )
+            console.error("pyproject.toml is missing the required field: project.name.")
         if "description" not in content["project"]:
-            raise Exception(
-                "pyproject.toml is missing the required field: project.description"
+            console.error(
+                "pyproject.toml is missing the required field: project.description."
             )
         if "version" not in content["project"]:
-            raise Exception(
-                "pyproject.toml is missing the required field: project.version"
+            console.error(
+                "pyproject.toml is missing the required field: project.version."
             )
 
         return {
@@ -330,63 +330,80 @@ def read_toml_project(file_path: str) -> dict[str, any]:
 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")
+        console.warning("pyproject.toml not found. Using default version 0.0.1")
         return "0.0.1"
     toml_data = read_toml_project(toml_path)
     return toml_data["version"]
 
 
+def display_project_info(config):
+    max_label_length = max(
+        len(label) for label in ["Name", "Version", "Description", "Authors"]
+    )
+
+    max_length = 100
+    description = config["description"]
+    if len(description) >= max_length:
+        description = description[: max_length - 3] + " ..."
+
+    console.log(f"{'Name'.ljust(max_label_length)}: {config['project_name']}")
+    console.log(f"{'Version'.ljust(max_label_length)}: {config['version']}")
+    console.log(f"{'Description'.ljust(max_label_length)}: {description}")
+    console.log(f"{'Authors'.ljust(max_label_length)}: {config['authors']}")
+
+
 @click.command()
 @click.argument("root", type=str, default="./")
 def pack(root):
+    """Pack the project."""
     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."
+        console.error(
+            "uipath.json not found. Please run `uipath init` in the project directory."
         )
-        return
     config = check_config(root)
     if not config["project_name"] or config["project_name"].strip() == "":
-        raise Exception("❌ Project name cannot be empty")
+        console.error(
+            "Project name cannot be empty. Please specify a name in pyproject.toml."
+        )
 
     if not config["description"] or config["description"].strip() == "":
-        raise Exception("❌ Project description cannot be empty")
+        console.error(
+            "Project description cannot be empty. Please specify a description in pyproject.toml."
+        )
 
     if not config["authors"] or config["authors"].strip() == "":
-        raise Exception("❌ Project authors cannot be empty")
+        console.error(
+            'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
+        )
 
     invalid_chars = ["&", "<", ">", '"', "'", ";"]
     for char in invalid_chars:
         if char in config["project_name"]:
-            raise Exception(f"❌ Project name contains invalid character: '{char}'")
+            console.error(f"Project name contains invalid character: '{char}'")
 
     for char in invalid_chars:
         if char in config["description"]:
-            raise Exception(
-                f"❌ Project description contains invalid character: '{char}'"
+            console.error(f"Project description contains invalid character: '{char}'")
+
+    with console.spinner("Packaging project ..."):
+        try:
+            pack_fn(
+                config["project_name"],
+                config["description"],
+                config["entryPoints"],
+                version or config["version"],
+                config["authors"],
+                root,
+            )
+            display_project_info(config)
+            console.success("Project successfully packaged.")
+
+        except Exception as e:
+            console.error(
+                f"Failed to create package {config['project_name']}.{version or config['version']}: {str(e)}"
             )
-    spinner = Spinner(
-        f"Packaging project {config['project_name']}:{version or config['version']} description {config['description']} authored by {config['authors']}"
-    )
-    try:
-        spinner.start()
-        pack_fn(
-            config["project_name"],
-            config["description"],
-            config["entryPoints"],
-            version or config["version"],
-            config["authors"],
-            root,
-        )
-        spinner.stop()
-        click.echo(
-            click.style("✓ ", fg="green", bold=True) + "Package created successfully!"
-        )
-    except Exception as e:
-        spinner.stop()
-        click.echo(f"\n❌ Error: {str(e)}")
-        click.Abort()
 
 
 if __name__ == "__main__":