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

uipath/_cli/cli_run.py

@@ -0,0 +1,133 @@
+# type: ignore
+import asyncio
+import logging
+import os
+import traceback
+from os import environ as env
+from typing import Optional
+from uuid import uuid4
+
+import click
+from dotenv import load_dotenv
+
+from ._runtime._contracts import (
+    UiPathRuntimeContext,
+    UiPathRuntimeError,
+    UiPathTraceContext,
+)
+from ._runtime._runtime import UiPathRuntime
+from .middlewares import MiddlewareResult, Middlewares
+
+logger = logging.getLogger(__name__)
+load_dotenv()
+
+
+def python_run_middleware(
+    entrypoint: Optional[str], input: Optional[str], resume: bool
+) -> MiddlewareResult:
+    """Middleware to handle Python script execution.
+
+    Args:
+        entrypoint: Path to the Python script to execute
+        input: JSON string with input data
+        resume: Flag indicating if this is a resume execution
+
+    Returns:
+        MiddlewareResult with execution status and messages
+    """
+    if not entrypoint:
+        return MiddlewareResult(
+            should_continue=False,
+            info_message="""Error: No entrypoint specified. Please provide a path to a Python script.
+Usage: `uipath run <entrypoint_path> <input_arguments>`""",
+        )
+
+    if not os.path.exists(entrypoint):
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=f"""Error: Script not found at path {entrypoint}.
+Usage: `uipath run <entrypoint_path> <input_arguments>`""",
+        )
+
+    try:
+
+        async def execute():
+            context = UiPathRuntimeContext.from_config(
+                env.get("UIPATH_CONFIG_PATH", "uipath.json")
+            )
+            context.entrypoint = entrypoint
+            context.input = input
+            context.resume = resume
+            context.job_id = env.get("UIPATH_JOB_KEY")
+            context.trace_id = env.get("UIPATH_TRACE_ID")
+            context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
+            context.trace_context = UiPathTraceContext(
+                trace_id=env.get("UIPATH_TRACE_ID"),
+                parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
+                root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
+                enabled=env.get("UIPATH_TRACING_ENABLED", True),
+                job_id=env.get("UIPATH_JOB_KEY"),
+                org_id=env.get("UIPATH_ORGANIZATION_ID"),
+                tenant_id=env.get("UIPATH_TENANT_ID"),
+                process_key=env.get("UIPATH_PROCESS_UUID"),
+                folder_key=env.get("UIPATH_FOLDER_KEY"),
+                reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
+            )
+            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
+
+            async with UiPathRuntime.from_context(context) as runtime:
+                await runtime.execute()
+
+        asyncio.run(execute())
+
+        # Return success
+        return MiddlewareResult(should_continue=False)
+
+    except UiPathRuntimeError as e:
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=f"Error: {e.error_info.title} - {e.error_info.detail}",
+            should_include_stacktrace=False,
+        )
+    except Exception as e:
+        # Handle unexpected errors
+        logger.exception("Unexpected error in Python runtime middleware")
+        return MiddlewareResult(
+            should_continue=False,
+            error_message=f"Error: Unexpected error occurred - {str(e)}",
+            should_include_stacktrace=True,
+        )
+
+
+@click.command()
+@click.argument("entrypoint", required=False)
+@click.argument("input", required=False, default="{}")
+@click.option("--resume", is_flag=True, help="Resume execution from a previous state")
+def run(entrypoint: Optional[str], input: Optional[str], resume: bool) -> None:
+    """Execute a Python script with JSON input."""
+    # Process through middleware chain
+    result = Middlewares.next("run", entrypoint, input, resume)
+
+    if result.should_continue:
+        result = python_run_middleware(
+            entrypoint=entrypoint, input=input, resume=resume
+        )
+
+    # Handle result from middleware
+    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 middleware chain completed but didn't handle the request
+    if result.should_continue:
+        click.echo("Error: Could not process the request with any available handler.")
+        click.get_current_context().exit(1)
+
+
+if __name__ == "__main__":
+    run()

uipath/_cli/middlewares.py

@@ -0,0 +1,113 @@
+import importlib.metadata
+import logging
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MiddlewareResult:
+    should_continue: bool
+    info_message: Optional[str] = None
+    error_message: Optional[str] = None
+    should_include_stacktrace: bool = False
+
+
+MiddlewareFunc = Callable[..., MiddlewareResult]
+
+
+class Middlewares:
+    _middlewares: Dict[str, List[MiddlewareFunc]] = {
+        "new": [],
+        "init": [],
+        "pack": [],
+        "publish": [],
+        "run": [],
+    }
+    _plugins_loaded = False
+
+    @classmethod
+    def register(cls, command: str, middleware: MiddlewareFunc) -> None:
+        """Register a middleware for a specific command."""
+        if command not in cls._middlewares:
+            cls._middlewares[command] = []
+        cls._middlewares[command].append(middleware)
+        logger.debug(
+            f"Registered middleware for command '{command}': {middleware.__name__}"
+        )
+
+    @classmethod
+    def get(cls, command: str) -> List[MiddlewareFunc]:
+        """Get all middlewares for a specific command."""
+        return cls._middlewares.get(command, [])
+
+    @classmethod
+    def next(cls, command: str, *args: Any, **kwargs: Any) -> MiddlewareResult:
+        """Invoke middleware."""
+        if not cls._plugins_loaded:
+            cls.load_plugins()
+
+        middlewares = cls.get(command)
+        for middleware in middlewares:
+            try:
+                result = middleware(*args, **kwargs)
+                if not result.should_continue:
+                    logger.debug(
+                        f"Command '{command}' stopped by {middleware.__name__}"
+                    )
+                    return result
+            except Exception as e:
+                logger.error(f"Middleware {middleware.__name__} failed: {str(e)}")
+                raise
+        return MiddlewareResult(should_continue=True)
+
+    @classmethod
+    def clear(cls, command: Optional[str] = None) -> None:
+        """Clear middlewares for a specific command or all middlewares if command is None."""
+        if command:
+            if command in cls._middlewares:
+                cls._middlewares[command] = []
+        else:
+            for cmd in cls._middlewares:
+                cls._middlewares[cmd] = []
+
+    @classmethod
+    def load_plugins(cls) -> None:
+        """Load all middlewares registered via entry points."""
+        if cls._plugins_loaded:
+            return
+
+        try:
+            try:
+                entry_points = importlib.metadata.entry_points()
+                if hasattr(entry_points, "select"):
+                    middlewares = list(entry_points.select(group="uipath.middlewares"))
+                else:
+                    middlewares = list(entry_points.get("uipath.middlewares", []))
+            except Exception:
+                middlewares = list(importlib.metadata.entry_points())  # type: ignore
+                middlewares = [
+                    ep for ep in middlewares if ep.group == "uipath.middlewares"
+                ]
+
+            if middlewares:
+                logger.info(f"Found {len(middlewares)} middleware plugins")
+
+                for entry_point in middlewares:
+                    try:
+                        register_func = entry_point.load()
+                        register_func()
+                        logger.info(f"Loaded middleware plugin: {entry_point.name}")
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to load middleware plugin {entry_point.name}: {str(e)}",
+                            exc_info=True,
+                        )
+            else:
+                logger.info("No middleware plugins found")
+
+        except Exception as e:
+            logger.error(f"No middleware plugins loaded: {str(e)}")
+        finally:
+            cls._plugins_loaded = True

uipath/_config.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    base_url: str
+    secret: str

uipath/_execution_context.py

@@ -0,0 +1,83 @@
+from os import environ as env
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from ._utils.constants import ENV_JOB_ID, ENV_JOB_KEY, ENV_ROBOT_KEY
+
+load_dotenv()
+
+
+class ExecutionContext:
+    """Manages the execution context for UiPath automation processes.
+
+    The ExecutionContext class handles information about the current execution environment,
+    including the job instance ID and robot key. This information is essential for
+    tracking and managing automation jobs in UiPath Automation Cloud.
+    """
+
+    def __init__(self) -> None:
+        try:
+            self._instance_key: Optional[str] = env[ENV_JOB_KEY]
+        except KeyError:
+            self._instance_key = None
+
+        try:
+            self._instance_id: Optional[str] = env[ENV_JOB_ID]
+        except KeyError:
+            self._instance_id = None
+
+        try:
+            self._robot_key: Optional[str] = env[ENV_ROBOT_KEY]
+        except KeyError:
+            self._robot_key = None
+
+        super().__init__()
+
+    @property
+    def instance_id(self) -> Optional[str]:
+        """Get the current job instance ID.
+
+        The instance ID uniquely identifies the current automation job execution
+        in UiPath Automation Cloud.
+
+        Returns:
+            Optional[str]: The job instance ID.
+
+        Raises:
+            ValueError: If the instance ID is not set in the environment.
+        """
+        if self._instance_id is None:
+            raise ValueError(f"Instance ID is not set ({ENV_JOB_ID})")
+
+        return self._instance_id
+
+    @property
+    def instance_key(self) -> Optional[str]:
+        """Get the current job instance key.
+
+        The instance key uniquely identifies the current automation job execution
+        in UiPath Automation Cloud.
+        """
+        if self._instance_key is None:
+            raise ValueError(f"Instance key is not set ({ENV_JOB_KEY})")
+
+        return self._instance_key
+
+    @property
+    def robot_key(self) -> Optional[str]:
+        """Get the current robot key.
+
+        The robot key identifies the UiPath Robot that is executing the current
+        automation job.
+
+        Returns:
+            Optional[str]: The robot key.
+
+        Raises:
+            ValueError: If the robot key is not set in the environment.
+        """
+        if self._robot_key is None:
+            raise ValueError(f"Robot key is not set ({ENV_ROBOT_KEY})")
+
+        return self._robot_key

uipath/_folder_context.py

@@ -0,0 +1,62 @@
+from os import environ as env
+from typing import Any, Optional
+
+from dotenv import load_dotenv
+
+from ._utils.constants import (
+    ENV_FOLDER_KEY,
+    ENV_FOLDER_PATH,
+    HEADER_FOLDER_KEY,
+    HEADER_FOLDER_PATH,
+)
+
+load_dotenv()
+
+
+class FolderContext:
+    """Manages the folder context for UiPath automation resources.
+
+    The FolderContext class handles information about the current folder in which
+    automation resources (like processes, assets, etc.) are being accessed or modified.
+    This is essential for organizing and managing resources in the UiPath Automation Cloud
+    folder structure.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        try:
+            self._folder_key: Optional[str] = env[ENV_FOLDER_KEY]
+        except KeyError:
+            self._folder_key = None
+
+        try:
+            self._folder_path: Optional[str] = env[ENV_FOLDER_PATH]
+        except KeyError:
+            self._folder_path = None
+
+        super().__init__(**kwargs)
+
+    @property
+    def folder_headers(self) -> dict[str, str]:
+        """Get the HTTP headers for folder-based API requests.
+
+        Returns headers containing either the folder key or folder path,
+        which are used to specify the target folder for API operations.
+        The folder context is essential for operations that need to be
+        performed within a specific folder in UiPath Automation Cloud.
+
+        Returns:
+            dict[str, str]: A dictionary containing the appropriate folder
+                header (either folder key or folder path).
+
+        Raises:
+            ValueError: If neither folder key nor folder path is set in
+                the environment.
+        """
+        if self._folder_key is not None:
+            return {HEADER_FOLDER_KEY: self._folder_key}
+        elif self._folder_path is not None:
+            return {HEADER_FOLDER_PATH: self._folder_path}
+        else:
+            raise ValueError(
+                f"Folder key or path is not set ({ENV_FOLDER_KEY} or {ENV_FOLDER_PATH})"
+            )

uipath/_models/__init__.py

@@ -0,0 +1,37 @@
+from .action_schema import ActionSchema
+from .actions import Action
+from .assets import UserAsset
+from .connections import Connection, ConnectionToken
+from .context_grounding import ContextGroundingQueryResponse
+from .exceptions import IngestionInProgressException
+from .interrupt_models import CreateAction, InvokeProcess, WaitAction, WaitJob
+from .job import Job
+from .processes import Process
+from .queues import (
+    CommitType,
+    QueueItem,
+    QueueItemPriority,
+    TransactionItem,
+    TransactionItemResult,
+)
+
+__all__ = [
+    "Action",
+    "UserAsset",
+    "ContextGroundingQueryResponse",
+    "Process",
+    "QueueItem",
+    "CommitType",
+    "TransactionItem",
+    "QueueItemPriority",
+    "TransactionItemResult",
+    "Connection",
+    "ConnectionToken",
+    "Job",
+    "InvokeProcess",
+    "ActionSchema",
+    "WaitJob",
+    "WaitAction",
+    "CreateAction",
+    "IngestionInProgressException",
+]

uipath/_models/action_schema.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FieldDetails(BaseModel):
+    name: str
+    key: str
+
+
+class ActionSchema(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    key: str
+    in_outs: Optional[List[FieldDetails]] = Field(default=None, alias="inOuts")
+    inputs: Optional[List[FieldDetails]] = None
+    outputs: Optional[List[FieldDetails]] = None
+    outcomes: Optional[List[FieldDetails]] = None

uipath/_models/actions.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Action(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    task_definition_properties_id: Optional[int] = Field(
+        default=None, alias="taskDefinitionPropertiesId"
+    )
+    app_tasks_metadata: Optional[Any] = Field(default=None, alias="appTasksMetadata")
+    action_label: Optional[str] = Field(default=None, alias="actionLabel")
+    status: Optional[Union[str, int]] = None
+    data: Optional[Dict[str, Any]] = None
+    action: Optional[str] = None
+    wait_job_state: Optional[str] = Field(default=None, alias="waitJobState")
+    organization_unit_fully_qualified_name: Optional[str] = Field(
+        default=None, alias="organizationUnitFullyQualifiedName"
+    )
+    tags: Optional[List[Any]] = None
+    assigned_to_user: Optional[Any] = Field(default=None, alias="assignedToUser")
+    task_sla_details: Optional[List[Any]] = Field(default=None, alias="taskSlaDetails")
+    completed_by_user: Optional[Any] = Field(default=None, alias="completedByUser")
+    task_assignment_criteria: Optional[str] = Field(
+        default=None, alias="taskAssignmentCriteria"
+    )
+    task_assignees: Optional[List[Any]] = Field(default=None, alias="taskAssignees")
+    title: Optional[str] = None
+    type: Optional[str] = None
+    priority: Optional[str] = None
+    assigned_to_user_id: Optional[int] = Field(default=None, alias="assignedToUserId")
+    organization_unit_id: Optional[int] = Field(
+        default=None, alias="organizationUnitId"
+    )
+    external_tag: Optional[str] = Field(default=None, alias="externalTag")
+    creator_job_key: Optional[str] = Field(default=None, alias="creatorJobKey")
+    wait_job_key: Optional[str] = Field(default=None, alias="waitJobKey")
+    last_assigned_time: Optional[datetime] = Field(
+        default=None, alias="lastAssignedTime"
+    )
+    completion_time: Optional[datetime] = Field(default=None, alias="completionTime")
+    parent_operation_id: Optional[str] = Field(default=None, alias="parentOperationId")
+    key: Optional[str] = None
+    is_deleted: bool = Field(default=False, alias="isDeleted")
+    deleter_user_id: Optional[int] = Field(default=None, alias="deleterUserId")
+    deletion_time: Optional[datetime] = Field(default=None, alias="deletionTime")
+    last_modification_time: Optional[datetime] = Field(
+        default=None, alias="lastModificationTime"
+    )
+    last_modifier_user_id: Optional[int] = Field(
+        default=None, alias="lastModifierUserId"
+    )
+    creation_time: Optional[datetime] = Field(default=None, alias="creationTime")
+    creator_user_id: Optional[int] = Field(default=None, alias="creatorUserId")
+    id: Optional[int] = None

uipath/_models/assets.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CredentialsConnectionData(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    url: str
+    body: str
+    bearer_token: str = Field(alias="bearerToken")
+
+
+class UserAsset(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    name: Optional[str] = Field(default=None, alias="Name")
+    value: Optional[str] = Field(default=None, alias="Value")
+    value_type: Optional[str] = Field(default=None, alias="ValueType")
+    string_value: Optional[str] = Field(default=None, alias="StringValue")
+    bool_value: Optional[bool] = Field(default=None, alias="BoolValue")
+    int_value: Optional[int] = Field(default=None, alias="IntValue")
+    credential_username: Optional[str] = Field(default=None, alias="CredentialUsername")
+    credential_password: Optional[str] = Field(default=None, alias="CredentialPassword")
+    external_name: Optional[str] = Field(default=None, alias="ExternalName")
+    credential_store_id: Optional[int] = Field(default=None, alias="CredentialStoreId")
+    key_value_list: Optional[List[Dict[str, str]]] = Field(
+        default=None, alias="KeyValueList"
+    )
+    connection_data: Optional[CredentialsConnectionData] = Field(
+        default=None, alias="ConnectionData"
+    )
+    id: Optional[int] = Field(default=None, alias="Id")

uipath/_models/connections.py

@@ -0,0 +1,51 @@
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Connection(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    owner: Optional[str] = None
+    create_time: Optional[str] = Field(default=None, alias="createTime")
+    update_time: Optional[str] = Field(default=None, alias="updateTime")
+    state: Optional[str] = None
+    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
+    element_instance_id: int = Field(alias="elementInstanceId")
+    connector: Optional[Any] = None
+    is_default: Optional[bool] = Field(default=None, alias="isDefault")
+    last_used_time: Optional[str] = Field(default=None, alias="lastUsedTime")
+    connection_identity: Optional[str] = Field(default=None, alias="connectionIdentity")
+    polling_interval_in_minutes: Optional[int] = Field(
+        default=None, alias="pollingIntervalInMinutes"
+    )
+    folder: Optional[Any] = None
+    element_version: Optional[str] = Field(default=None, alias="elementVersion")
+
+
+class ConnectionToken(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+        json_encoders={datetime: lambda v: v.isoformat() if v else None},
+    )
+
+    access_token: str = Field(alias="accessToken")
+    token_type: Optional[str] = Field(default=None, alias="tokenType")
+    scope: Optional[str] = None
+    expires_in: Optional[int] = Field(default=None, alias="expiresIn")
+    api_base_uri: Optional[str] = Field(default=None, alias="apiBaseUri")
+    element_instance_id: Optional[int] = Field(default=None, alias="elementInstanceId")

uipath/_models/context_grounding.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+
+
+class ContextGroundingMetadata(BaseModel):
+    operation_id: str
+    strategy: str
+
+
+class ContextGroundingQueryResponse(BaseModel):
+    id: str
+    reference: str
+    source: str
+    page_number: str
+    source_document_id: str
+    caption: str
+    score: float
+    content: str
+    metadata: ContextGroundingMetadata