uipath 2.0.25__tar.gz → 2.0.27__tar.gz

{uipath-2.0.25 → uipath-2.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.25
+Version: 2.0.27
 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.25 → uipath-2.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.25"
+version = "2.0.27"
 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.25 → uipath-2.0.27}/src/uipath/_cli/_auth/_auth_server.py

@@ -39,7 +39,6 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
                 content_length = int(self.headers["Content-Length"])
                 post_data = self.rfile.read(content_length)
                 token_data = json.loads(post_data.decode("utf-8"))
-                click.echo("Received authentication information")
 
                 self.send_response(200)
                 self.end_headers()

{uipath-2.0.25 → uipath-2.0.27}/src/uipath/_cli/_auth/_portal_service.py

@@ -5,6 +5,7 @@ from typing import Optional
 import click
 import requests
 
+from .._utils._console import ConsoleLogger
 from ._models import TenantsAndOrganizationInfoResponse, TokenData
 from ._oidc_utils import get_auth_config
 from ._utils import (
@@ -14,6 +15,8 @@ from ._utils import (
     update_env_file,
 )
 
+console = ConsoleLogger()
+
 
 class PortalService:
     """Service for interacting with the UiPath Portal API."""
@@ -49,18 +52,21 @@ class PortalService:
             self._tenants_and_organizations = result
             return result
         elif response.status_code == 401:
-            raise Exception("Unauthorized")
+            console.error("Unauthorized")
         else:
-            raise Exception(
+            console.error(
                 f"Failed to get tenants and organizations: {response.status_code} {response.text}"
             )
+        # Can't reach here, console.error exits, linting
+        raise Exception("Failed to get tenants")
 
     def get_uipath_orchestrator_url(self) -> str:
         if self._tenants_and_organizations is None:
             self._tenants_and_organizations = self.get_tenants_and_organizations()
         organization = self._tenants_and_organizations.get("organization")
         if organization is None:
-            raise Exception("Organization not found")
+            console.error("Organization not found.")
+            return ""
         account_name = organization.get("name")
         return f"https://{self.domain}.uipath.com/{account_name}/{self.selected_tenant}/orchestrator_"
 
@@ -80,9 +86,11 @@ class PortalService:
         if response.ok:
             return response.json()
         elif response.status_code == 401:
-            raise Exception("Unauthorized")
+            console.error("Unauthorized")
         else:
-            raise Exception(f"Failed to refresh token: {response.status_code}")
+            console.error(f"Failed to refresh token: {response.status_code}")
+        # Can't reach here, console.error exits, linting
+        raise Exception("Failed to refresh get token")
 
     def ensure_valid_token(self):
         """Ensure the access token is valid and refresh it if necessary.
@@ -146,15 +154,15 @@ def select_tenant(
     domain: str, tenants_and_organizations: TenantsAndOrganizationInfoResponse
 ):
     tenant_names = [tenant["name"] for tenant in tenants_and_organizations["tenants"]]
-    click.echo("Available tenants:")
-    for idx, name in enumerate(tenant_names):
-        click.echo(f"  {idx}: {name}")
+    console.display_options(tenant_names, "Select tenant:")
     tenant_idx = (
-        0 if len(tenant_names) == 1 else click.prompt("Select tenant", type=int)
+        0
+        if len(tenant_names) == 1
+        else console.prompt("Select tenant number", type=int)
     )
     tenant_name = tenant_names[tenant_idx]
     account_name = tenants_and_organizations["organization"]["name"]
-    click.echo(f"Selected tenant: {tenant_name}")
+    console.info(f"Selected tenant: {click.style(tenant_name, fg='cyan')}")
 
     update_env_file(
         {

uipath-2.0.27/src/uipath/_cli/_utils/_console.py

@@ -0,0 +1,215 @@
+from contextlib import contextmanager
+from enum import Enum
+from typing import Any, Iterator, List, Optional, Type, TypeVar
+
+import click
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner as RichSpinner
+from rich.text import Text
+
+
+class LogLevel(Enum):
+    """Enum for log levels with corresponding emojis."""
+
+    INFO = ""
+    SUCCESS = click.style("✓ ", fg="green", bold=True)
+    WARNING = "⚠️"
+    ERROR = "❌"
+    HINT = "💡"
+    CONFIG = "🔧"
+    SELECT = "👇"
+    LINK = "🔗"
+    MAGIC = "✨"
+
+
+T = TypeVar("T", bound="ConsoleLogger")
+
+
+class ConsoleLogger:
+    """A singleton wrapper class for terminal output with emoji support and spinners."""
+
+    # Class variable to hold the singleton instance
+    _instance: Optional["ConsoleLogger"] = None
+
+    def __new__(cls: Type[T]) -> T:
+        """Ensure only one instance of ConsoleLogger is created.
+
+        Returns:
+            The singleton instance of ConsoleLogger
+        """
+        if cls._instance is None:
+            cls._instance = super(ConsoleLogger, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance  # type: ignore
+
+    def __init__(self):
+        """Initialize the ConsoleLogger (only once)."""
+        # Only initialize once
+        if not getattr(self, "_initialized", False):
+            self._console = Console()
+            self._spinner_live: Optional[Live] = None
+            self._spinner = RichSpinner("dots")
+            self._initialized = True
+
+    def _stop_spinner_if_active(self) -> None:
+        """Internal method to stop the spinner if it's active."""
+        if self._spinner_live and self._spinner_live.is_started:
+            self._spinner_live.stop()
+            self._spinner_live = None
+
+    def log(
+        self, message: str, level: LogLevel = LogLevel.INFO, fg: Optional[str] = None
+    ) -> None:
+        """Log a message with the specified level and optional color.
+
+        Args:
+            message: The message to log
+            level: The log level (determines the emoji)
+            fg: Optional foreground color for the message
+        """
+        # Stop any active spinner before logging
+        self._stop_spinner_if_active()
+
+        if not level == LogLevel.INFO:
+            emoji = level.value
+            if fg:
+                formatted_message = f"{emoji} {click.style(message, fg=fg)}"
+            else:
+                formatted_message = f"{emoji} {message}"
+        else:
+            formatted_message = message
+
+        click.echo(formatted_message, err=LogLevel.ERROR in (level,))
+
+    def success(self, message: str) -> None:
+        """Log a success message."""
+        self.log(message, LogLevel.SUCCESS)
+
+    def error(self, message: str, include_traceback: bool = False) -> None:
+        """Log an error message with optional traceback.
+
+        Args:
+            message: The error message to display
+            include_traceback: Whether to include the current exception traceback
+        """
+        self.log(message, LogLevel.ERROR, "red")
+
+        if include_traceback:
+            import traceback
+
+            click.echo(traceback.format_exc(), err=True)
+
+        click.get_current_context().exit(1)
+
+    def warning(self, message: str) -> None:
+        """Log a warning message."""
+        self.log(message, LogLevel.WARNING, "yellow")
+
+    def info(self, message: str) -> None:
+        """Log an informational message."""
+        self.log(message, LogLevel.INFO)
+
+    def hint(self, message: str) -> None:
+        """Log a hint message."""
+        self.log(message, LogLevel.HINT)
+
+    def magic(self, message: str) -> None:
+        """Log a magic message."""
+        self.log(message, LogLevel.MAGIC, "green")
+
+    def config(self, message: str) -> None:
+        """Log a configuration message."""
+        self.log(message, LogLevel.CONFIG)
+
+    def select(self, message: str) -> None:
+        """Log a selection message."""
+        self.log(message, LogLevel.SELECT)
+
+    def link(self, message: str, url: str) -> None:
+        """Log a clickable link.
+
+        Args:
+            message: The message to display
+            url: The URL to link to
+        """
+        formatted_url = f"\u001b]8;;{url}\u001b\\{url}\u001b]8;;\u001b\\"
+        self.log(
+            f"{message} {click.style(formatted_url, fg='bright_blue', bold=True)}",
+            LogLevel.LINK,
+        )
+
+    def prompt(self, message: str, **kwargs: Any) -> Any:
+        """Wrapper for click.prompt with emoji.
+
+        Args:
+            message: The prompt message
+            **kwargs: Additional arguments to pass to click.prompt
+
+        Returns:
+            The user's input
+        """
+        # Stop any active spinner before prompting
+        self._stop_spinner_if_active()
+
+        return click.prompt(click.style(f"{message}", fg="yellow", bold=True), **kwargs)
+
+    def display_options(
+        self, options: List[Any], message: str = "Select an option:"
+    ) -> None:
+        """Display a list of options with indices.
+
+        Args:
+            options: List of options to display
+            message: Optional message to display before the options
+        """
+        self.select(message)
+        for idx, option in enumerate(options, start=0):
+            click.echo(f"  {idx}: {option}")
+
+    @contextmanager
+    def spinner(self, message: str = "") -> Iterator[None]:
+        """Context manager for spinner operations.
+
+        Args:
+            message: The message to display alongside the spinner
+
+        Yields:
+            None
+        """
+        try:
+            # Stop any existing spinner before starting a new one
+            self._stop_spinner_if_active()
+
+            self._spinner.text = Text(message)
+            self._spinner_live = Live(
+                self._spinner,
+                console=self._console,
+                refresh_per_second=10,
+                transient=False,
+                auto_refresh=True,
+            )
+            self._spinner_live.start()
+            yield
+        finally:
+            self._stop_spinner_if_active()
+
+    def update_spinner(self, message: str) -> None:
+        """Update the message of an active spinner.
+
+        Args:
+            message: The new message to display
+        """
+        if self._spinner_live and self._spinner_live.is_started:
+            self._spinner.text = Text(message)
+
+    @classmethod
+    def get_instance(cls) -> "ConsoleLogger":
+        """Get the singleton instance of ConsoleLogger.
+
+        Returns:
+            The singleton instance
+        """
+        if cls._instance is None:
+            return cls()
+        return cls._instance

uipath-2.0.27/src/uipath/_cli/_utils/_folders.py

@@ -0,0 +1,27 @@
+from typing import Optional, Tuple
+
+import requests
+
+from ._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+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 = requests.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.")
+
+    user_data = user_response.json()
+    feed_id = user_data.get("PersonalWorskpaceFeedId")
+    personal_workspace = user_data.get("PersonalWorkspace")
+
+    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-2.0.25 → uipath-2.0.27}/src/uipath/_cli/_utils/_processes.py

@@ -1,19 +1,16 @@
 import json
 import urllib.parse
-from typing import Any, Optional
+from typing import Any
 
-import click
 import requests
 
-from ..spinner import Spinner
+from ._console import ConsoleLogger
+
+console = ConsoleLogger()
 
 
 def get_release_info(
-    base_url: str,
-    token: str,
-    package_name: str,
-    folder_id: str,
-    spinner: Optional[Spinner] = None,
+    base_url: str, token: str, package_name: str, folder_id: str
 ) -> None | tuple[Any, Any] | tuple[None, None]:
     headers = {
         "Authorization": f"Bearer {token}",
@@ -29,21 +26,13 @@ def get_release_info(
             release_key = data["value"][0]["Key"]
             return release_id, release_key
         except KeyError:
-            if spinner:
-                spinner.stop()
-            click.echo("\n⚠️ Warning: Failed to deserialize release data")
+            console.warning("Warning: Failed to deserialize release data")
             return None, None
         except IndexError:
-            if spinner:
-                spinner.stop()
-            click.echo(
-                "\n❌ Process not found in your workspace. Try publishing it first."
+            console.error(
+                "Error: No process found in your workspace. Please publish the process first."
             )
-            click.get_current_context().exit(1)
-
+            return None, None
     else:
-        if spinner:
-            spinner.stop()
-        click.echo("\n⚠️ Warning: Failed to fetch release info")
-        click.echo(f"Status code: {response.status_code}")
+        console.warning(f"Warning: Failed to fetch release info {response.status_code}")
         return None, None

uipath-2.0.27/src/uipath/_cli/cli_auth.py

@@ -0,0 +1,106 @@
+# type: ignore
+import json
+import os
+import socket
+import webbrowser
+
+import click
+from dotenv import load_dotenv
+
+from ._auth._auth_server import HTTPSServer
+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
+from ._utils._common import environment_options
+from ._utils._console import ConsoleLogger
+
+load_dotenv()
+console = ConsoleLogger()
+
+
+def is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("localhost", port))
+            s.close()
+            return False
+        except socket.error:
+            return True
+
+
+def set_port():
+    auth_config = get_auth_config()
+    port = auth_config.get("port", 8104)
+    port_option_one = auth_config.get("portOptionOne", 8104)
+    port_option_two = auth_config.get("portOptionTwo", 8055)
+    port_option_three = auth_config.get("portOptionThree", 42042)
+    if is_port_in_use(port):
+        if is_port_in_use(port_option_one):
+            if is_port_in_use(port_option_two):
+                if is_port_in_use(port_option_three):
+                    console.error(
+                        "All configured ports are in use. Please close applications using ports or configure different ports."
+                    )
+                else:
+                    port = port_option_three
+            else:
+                port = port_option_two
+        else:
+            port = port_option_one
+    auth_config["port"] = port
+    with open(
+        os.path.join(os.path.dirname(__file__), "..", "auth_config.json"), "w"
+    ) as f:
+        json.dump(auth_config, f)
+
+
+@click.command()
+@environment_options
+def auth(domain="alpha"):
+    """Authenticate with UiPath Cloud Platform."""
+    with console.spinner("Authenticating with UiPath ..."):
+        portal_service = PortalService(domain)
+        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 = HTTPSServer(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()
+            select_tenant(domain, tenants_and_organizations)
+            console.success(
+                "Authentication successful.",
+            )
+        else:
+            console.error(
+                "Authentication failed. Please try again.",
+            )

{uipath-2.0.25 → uipath-2.0.27}/src/uipath/_cli/cli_deploy.py

@@ -8,6 +8,7 @@ from .cli_publish import publish
 @click.command()
 @click.argument("root", type=str, default="./")
 def deploy(root):
+    """Pack and publish the project."""
     ctx = click.get_current_context()
     ctx.invoke(pack, root=root)
     ctx.invoke(publish)

uipath-2.0.27/src/uipath/_cli/cli_init.py

@@ -0,0 +1,112 @@
+# type: ignore
+import json
+import os
+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
+
+console = ConsoleLogger()
+
+
+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)
+        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")
+
+
+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):
+            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:
+        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:
+        console.error(
+            "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:
+    """Create uipath.json with input/output schemas and bindings."""
+    with console.spinner("Initializing UiPath project ..."):
+        current_directory = os.getcwd()
+        generate_env_file(current_directory)
+
+        result = Middlewares.next("init", entrypoint)
+
+        if result.error_message:
+            console.error(
+                result.error_message, include_traceback=result.should_include_stacktrace
+            )
+
+        if result.info_message:
+            console.info(result.info_message)
+
+        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)}")