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

uipath/_cli/_runtime/_logging.py

@@ -0,0 +1,193 @@
+import logging
+import os
+import sys
+from typing import Optional, TextIO, Union, cast
+
+
+class PersistentLogsHandler(logging.FileHandler):
+    """A simple log handler that always writes to a single file without rotation."""
+
+    def __init__(self, file: str):
+        """Initialize the handler to write logs to a single file, appending always.
+
+        Args:
+            file (str): The file where logs should be stored.
+        """
+        # Open file in append mode ('a'), so logs are not overwritten
+        super().__init__(file, mode="a", encoding="utf8")
+
+        self.formatter = logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s")
+        self.setFormatter(self.formatter)
+
+
+class LogsInterceptor:
+    """Intercepts all logging and stdout/stderr, routing to either persistent log files or stdout based on whether it's running as a job or not."""
+
+    def __init__(
+        self,
+        min_level: Optional[str] = "INFO",
+        dir: Optional[str] = "__uipath",
+        file: Optional[str] = "execution.log",
+        job_id: Optional[str] = None,
+    ):
+        """Initialize the log interceptor.
+
+        Args:
+            min_level: Minimum logging level to capture.
+            dir (str): The directory where logs should be stored.
+            file (str): The log file name.
+            job_id (str, optional): If provided, logs go to file; otherwise, to stdout.
+        """
+        min_level = min_level or "INFO"
+        self.job_id = job_id
+
+        # Convert to numeric level for consistent comparison
+        self.numeric_min_level = getattr(logging, min_level.upper(), logging.INFO)
+
+        # Store the original disable level
+        self.original_disable_level = logging.root.manager.disable
+
+        self.root_logger = logging.getLogger()
+        self.original_level = self.root_logger.level
+        self.original_handlers = list(self.root_logger.handlers)
+
+        self.original_stdout: Optional[TextIO] = None
+        self.original_stderr: Optional[TextIO] = None
+
+        self.log_handler: Union[PersistentLogsHandler, logging.StreamHandler[TextIO]]
+
+        # Create either file handler (runtime) or stdout handler (debug)
+        if self.job_id:
+            # Ensure directory exists for file logging
+            dir = dir or "__uipath"
+            file = file or "execution.log"
+            os.makedirs(dir, exist_ok=True)
+            log_file = os.path.join(dir, file)
+            self.log_handler = PersistentLogsHandler(file=log_file)
+        else:
+            # Use stdout handler when not running as a job
+            self.log_handler = logging.StreamHandler(sys.stdout)
+            formatter = logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s")
+            self.log_handler.setFormatter(formatter)
+
+        self.log_handler.setLevel(self.numeric_min_level)
+        self.logger = logging.getLogger("runtime")
+        self.patched_loggers: set[str] = set()
+
+        # Store system stdout/stderr
+        self.sys_stdout = cast(TextIO, sys.__stdout__)
+        self.sys_stderr = cast(TextIO, sys.__stderr__)
+
+    def _clean_all_handlers(self, logger: logging.Logger) -> None:
+        """Remove ALL handlers from a logger except ours."""
+        handlers_to_remove = list(logger.handlers)
+        for handler in handlers_to_remove:
+            logger.removeHandler(handler)
+
+        # Now add our handler
+        logger.addHandler(self.log_handler)
+
+    def setup(self) -> None:
+        """Configure logging to use our persistent handler."""
+        # Use global disable to prevent all logging below our minimum level
+        if self.numeric_min_level > logging.NOTSET:
+            logging.disable(self.numeric_min_level - 1)
+
+        # Set root logger level
+        self.root_logger.setLevel(self.numeric_min_level)
+
+        # Remove ALL handlers from root logger and add only ours
+        self._clean_all_handlers(self.root_logger)
+
+        # Set up propagation for all existing loggers
+        for logger_name in logging.root.manager.loggerDict:
+            logger = logging.getLogger(logger_name)
+            logger.propagate = False  # Prevent double-logging
+            self._clean_all_handlers(logger)
+            self.patched_loggers.add(logger_name)
+
+        # Set up stdout/stderr redirection
+        self._redirect_stdout_stderr()
+
+    def _redirect_stdout_stderr(self) -> None:
+        """Redirect stdout and stderr to the logging system."""
+        self.original_stdout = sys.stdout
+        self.original_stderr = sys.stderr
+
+        class LoggerWriter:
+            def __init__(
+                self,
+                logger: logging.Logger,
+                level: int,
+                min_level: int,
+                sys_file: TextIO,
+            ):
+                self.logger = logger
+                self.level = level
+                self.min_level = min_level
+                self.buffer = ""
+                self.sys_file = sys_file  # Store reference to system stdout/stderr
+
+            def write(self, message: str) -> None:
+                if message and message.strip() and self.level >= self.min_level:
+                    self.logger.log(self.level, message.rstrip())
+
+            def flush(self) -> None:
+                pass
+
+            def fileno(self) -> int:
+                # Return the file descriptor of the original system stdout/stderr
+                return self.sys_file.fileno()
+
+        # Set up stdout and stderr loggers with propagate=False
+        stdout_logger = logging.getLogger("stdout")
+        stdout_logger.propagate = False
+        self._clean_all_handlers(stdout_logger)
+
+        stderr_logger = logging.getLogger("stderr")
+        stderr_logger.propagate = False
+        self._clean_all_handlers(stderr_logger)
+
+        # Use the min_level in the LoggerWriter to filter messages
+        sys.stdout = LoggerWriter(
+            stdout_logger, logging.INFO, self.numeric_min_level, self.sys_stdout
+        )
+        sys.stderr = LoggerWriter(
+            stderr_logger, logging.ERROR, self.numeric_min_level, self.sys_stderr
+        )
+
+    def teardown(self) -> None:
+        """Restore original logging configuration."""
+        # Restore the original disable level
+        logging.disable(self.original_disable_level)
+
+        if self.log_handler in self.root_logger.handlers:
+            self.root_logger.removeHandler(self.log_handler)
+
+        for logger_name in self.patched_loggers:
+            logger = logging.getLogger(logger_name)
+            if self.log_handler in logger.handlers:
+                logger.removeHandler(self.log_handler)
+
+        self.root_logger.setLevel(self.original_level)
+        for handler in self.original_handlers:
+            if handler not in self.root_logger.handlers:
+                self.root_logger.addHandler(handler)
+
+        if self.original_stdout and self.original_stderr:
+            sys.stdout = self.original_stdout
+            sys.stderr = self.original_stderr
+
+        self.log_handler.close()
+
+    def __enter__(self):
+        self.setup()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            self.logger.error(
+                f"Exception occurred: {exc_val}", exc_info=(exc_type, exc_val, exc_tb)
+            )
+        self.teardown()
+        return False

uipath/_cli/_runtime/_runtime.py

@@ -0,0 +1,264 @@
+"""Python script runtime implementation for executing and managing python scripts."""
+
+import importlib.util
+import inspect
+import json
+import logging
+import os
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
+
+from ._contracts import (
+    UiPathBaseRuntime,
+    UiPathErrorCategory,
+    UiPathRuntimeError,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class UiPathRuntime(UiPathBaseRuntime):
+    """Runtime for executing Python scripts."""
+
+    async def execute(self) -> Optional[UiPathRuntimeResult]:
+        """Execute the Python script with the provided input and configuration.
+
+        Returns:
+            Dictionary with execution results
+
+        Raises:
+            UiPathRuntimeError: If execution fails
+        """
+        await self.validate()
+
+        try:
+            if self.context.entrypoint is None:
+                return None
+
+            script_result = self._execute_python_script(
+                self.context.entrypoint, self.context.input_json
+            )
+
+            if self.context.job_id is None:
+                logger.info(script_result)
+
+            self.context.result = UiPathRuntimeResult(
+                output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
+            )
+
+            return self.context.result
+
+        except Exception as e:
+            if isinstance(e, UiPathRuntimeError):
+                raise
+
+            raise UiPathRuntimeError(
+                "EXECUTION_ERROR",
+                "Python script execution failed",
+                f"Error: {str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
+
+    async def validate(self) -> None:
+        """Validate runtime inputs."""
+        if not self.context.entrypoint:
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_MISSING",
+                "No entrypoint specified",
+                "Please provide a path to a Python script.",
+                UiPathErrorCategory.USER,
+            )
+
+        if not os.path.exists(self.context.entrypoint):
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_NOT_FOUND",
+                "Script not found",
+                f"Script not found at path {self.context.entrypoint}.",
+                UiPathErrorCategory.USER,
+            )
+
+        try:
+            if self.context.input:
+                self.context.input_json = json.loads(self.context.input)
+            else:
+                self.context.input_json = {}
+        except json.JSONDecodeError as e:
+            raise UiPathRuntimeError(
+                "INPUT_INVALID_JSON",
+                "Invalid JSON input",
+                f"The input data is not valid JSON: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+    async def cleanup(self) -> None:
+        """Cleanup runtime resources."""
+        pass
+
+    def _execute_python_script(self, script_path: str, input_data: Any) -> Any:
+        """Execute the Python script with the given input."""
+        spec = importlib.util.spec_from_file_location("dynamic_module", script_path)
+        if not spec or not spec.loader:
+            raise UiPathRuntimeError(
+                "IMPORT_ERROR",
+                "Module import failed",
+                f"Could not load spec for {script_path}",
+                UiPathErrorCategory.USER,
+            )
+
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise UiPathRuntimeError(
+                "MODULE_EXECUTION_ERROR",
+                "Module execution failed",
+                f"Error executing module: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+        for func_name in ["main", "run", "execute"]:
+            if hasattr(module, func_name):
+                main_func = getattr(module, func_name)
+                sig = inspect.signature(main_func)
+                params = list(sig.parameters.values())
+
+                # Case 1: No parameters
+                if not params:
+                    try:
+                        result = main_func()
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+                input_param = params[0]
+                input_type = input_param.annotation
+
+                # Case 2: Class or dataclass parameter
+                if input_type != inspect.Parameter.empty and (
+                    is_dataclass(input_type) or hasattr(input_type, "__annotations__")
+                ):
+                    try:
+                        valid_type = cast(Type[Any], input_type)
+                        typed_input = self._convert_to_class(input_data, valid_type)
+                        result = main_func(typed_input)
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function with typed input",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+                # Case 3: Dict parameter
+                else:
+                    try:
+                        result = main_func(input_data)
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function with dictionary input",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+        raise UiPathRuntimeError(
+            "ENTRYPOINT_FUNCTION_MISSING",
+            "No entry function found",
+            f"No main function (main, run, or execute) found in {script_path}",
+            UiPathErrorCategory.USER,
+        )
+
+    def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
+        """Convert a dictionary to either a dataclass or regular class instance."""
+        if is_dataclass(cls):
+            field_types = get_type_hints(cls)
+            converted_data = {}
+
+            for field_name, field_type in field_types.items():
+                if field_name not in data:
+                    continue
+
+                value = data[field_name]
+                if (
+                    is_dataclass(field_type) or hasattr(field_type, "__annotations__")
+                ) and isinstance(value, dict):
+                    typed_field = cast(Type[Any], field_type)
+                    value = self._convert_to_class(value, typed_field)
+                converted_data[field_name] = value
+
+            return cast(T, cls(**converted_data))
+        else:
+            sig = inspect.signature(cls.__init__)
+            params = sig.parameters
+
+            init_args = {}
+
+            for param_name, param in params.items():
+                if param_name == "self":
+                    continue
+
+                if param_name in data:
+                    value = data[param_name]
+                    param_type = (
+                        param.annotation
+                        if param.annotation != inspect.Parameter.empty
+                        else Any
+                    )
+
+                    if (
+                        is_dataclass(param_type)
+                        or hasattr(param_type, "__annotations__")
+                    ) and isinstance(value, dict):
+                        typed_param = cast(Type[Any], param_type)
+                        value = self._convert_to_class(value, typed_param)
+
+                    init_args[param_name] = value
+                elif param.default != inspect.Parameter.empty:
+                    init_args[param_name] = param.default
+
+            return cls(**init_args)
+
+    def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
+        """Convert a class instance (dataclass or regular) to a dictionary."""
+        if obj is None:
+            return {}
+
+        if is_dataclass(obj):
+            # Make sure obj is an instance, not a class
+            if isinstance(obj, type):
+                return {}
+            return asdict(obj)
+        elif hasattr(obj, "__dict__"):
+            result = {}
+            for key, value in obj.__dict__.items():
+                # Skip private attributes
+                if not key.startswith("_"):
+                    if hasattr(value, "__dict__") or is_dataclass(value):
+                        result[key] = self._convert_from_class(value)
+                    else:
+                        result[key] = value
+            return result
+        return {} if obj is None else {str(type(obj).__name__): str(obj)}  # Fallback

uipath/_cli/_templates/.psmdcp.template

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<coreProperties xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties">
+  <dc:creator>$creator</dc:creator>
+  <dc:description>$description</dc:description>
+  <dc:identifier>$projectName</dc:identifier>
+  <version>$packageVersion</version>
+  <keywords></keywords>
+  <lastModifiedBy>NuGet.Packaging, Version=6.12.1.1, Culture=neutral, PublicKeyToken=$publicKeyToken;.NET 5.0</lastModifiedBy>
+</coreProperties>

uipath/_cli/_templates/.rels.template

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="$nuspecPath" Id="$nuspecId" />
+  <Relationship Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="$psmdcpPath" Id="$psmdcpId" />
+</Relationships>

uipath/_cli/_templates/[Content_Types].xml.template

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
+  <Default Extension="psmdcp" ContentType="application/vnd.openxmlformats-package.core-properties+xml" />
+  <Default Extension="json" ContentType="application/octet" />
+  <Default Extension="py" ContentType="application/octet" />
+  <Default Extension="txt" ContentType="application/octet" />
+  <Default Extension="nuspec" ContentType="application/octet" />
+</Types>

uipath/_cli/_templates/main.py.template

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class EchoIn:
+    message: str
+    repeat: Optional[int] = 1
+    prefix: Optional[str] = None
+
+
+@dataclass
+class EchoOut:
+    message: str
+
+
+def main(input: EchoIn) -> EchoOut:
+    result = []
+    for _ in range(input.repeat):
+        line = input.message
+        if input.prefix:
+            line = f"{input.prefix}: {line}"
+        result.append(line)
+
+    return EchoOut(message="\n".join(result))

uipath/_cli/_templates/package.nuspec.template

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2011/10/nuspec.xsd">
+  <metadata>
+    <id>$packageName</id>
+    <version>$packageVersion</version>
+    <authors>$authors</authors>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>$description</description>
+  </metadata>
+</package>

uipath/_cli/_utils/_common.py

@@ -0,0 +1,24 @@
+import click
+
+
+def environment_options(function):
+    function = click.option(
+        "--alpha",
+        "domain",
+        flag_value="alpha",
+        help="Use alpha environment",
+    )(function)
+    function = click.option(
+        "--staging",
+        "domain",
+        flag_value="staging",
+        help="Use staging environment",
+    )(function)
+    function = click.option(
+        "--cloud",
+        "domain",
+        flag_value="cloud",
+        default=True,
+        help="Use production environment",
+    )(function)
+    return function

uipath/_cli/_utils/_input_args.py

@@ -0,0 +1,126 @@
+import importlib.util
+import inspect
+import sys
+from dataclasses import fields, is_dataclass
+from types import ModuleType
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+SchemaType = Literal["object", "integer", "double", "string", "boolean", "array"]
+
+TYPE_MAP: Dict[str, SchemaType] = {
+    "int": "integer",
+    "float": "double",
+    "str": "string",
+    "bool": "boolean",
+    "list": "array",
+    "dict": "object",
+    "List": "array",
+    "Dict": "object",
+}
+
+
+def get_type_schema(type_hint: Any) -> Dict[str, Any]:
+    """Convert a type hint to a JSON schema."""
+    if type_hint is None or type_hint == inspect.Parameter.empty:
+        return {"type": "object"}
+
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    if origin is Union:
+        if type(None) in args:
+            real_type = next(arg for arg in args if arg is not type(None))
+            return get_type_schema(real_type)
+        return {"type": "object"}
+
+    if origin in (list, List):
+        item_type = args[0] if args else Any
+        return {"type": "array", "items": get_type_schema(item_type)}
+
+    if origin in (dict, Dict):
+        return {"type": "object"}
+
+    if inspect.isclass(type_hint):
+        if is_dataclass(type_hint):
+            properties = {}
+            required = []
+
+            for field in fields(type_hint):
+                field_schema = get_type_schema(field.type)
+                properties[field.name] = field_schema
+                if field.default == field.default_factory:
+                    required.append(field.name)
+
+            return {"type": "object", "properties": properties, "required": required}
+        elif hasattr(type_hint, "__annotations__"):
+            properties = {}
+            required = []
+
+            for name, field_type in type_hint.__annotations__.items():
+                field_schema = get_type_schema(field_type)
+                properties[name] = field_schema
+                # For regular classes, we'll consider all annotated fields as required
+                # unless they have a default value in __init__
+                if hasattr(type_hint, "__init__"):
+                    sig = inspect.signature(type_hint.__init__)
+                    if (
+                        name in sig.parameters
+                        and sig.parameters[name].default == inspect.Parameter.empty
+                    ):
+                        required.append(name)
+                else:
+                    required.append(name)
+
+            return {"type": "object", "properties": properties, "required": required}
+
+    type_name = type_hint.__name__ if hasattr(type_hint, "__name__") else str(type_hint)
+    schema_type = TYPE_MAP.get(type_name, "object")
+
+    return {"type": schema_type}
+
+
+def load_module(file_path: str) -> ModuleType:
+    """Load a Python module from file path."""
+    spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
+    if not spec or not spec.loader:
+        raise ImportError(f"Could not load spec for {file_path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["dynamic_module"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def generate_args(path: str) -> Dict[str, Dict[str, Any]]:
+    """Generate input/output schema from main function type hints."""
+    module = load_module(path)
+
+    main_func = None
+    for func_name in ["main", "run", "execute"]:
+        if hasattr(module, func_name):
+            main_func = getattr(module, func_name)
+            break
+
+    if not main_func:
+        raise ValueError("No main function found in module")
+
+    hints = get_type_hints(main_func)
+    sig = inspect.signature(main_func)
+
+    if not sig.parameters:
+        return {"input": {}, "output": get_type_schema(hints.get("return", None))}
+
+    input_param_name = next(iter(sig.parameters))
+    input_schema = get_type_schema(hints.get(input_param_name))
+    output_schema = get_type_schema(hints.get("return"))
+
+    return {"input": input_schema, "output": output_schema}