uipath 2.1.88__tar.gz → 2.1.90__tar.gz

{uipath-2.1.88 → uipath-2.1.90}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.88"
+version = "2.1.90"
 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.1.88 → uipath-2.1.90}/scripts/update_agents_md.py

@@ -1,10 +1,9 @@
 #!/usr/bin/env python3
-"""Script to update AGENTS.md with complete library documentation.
+"""Script to update AGENTS.md reference files with complete library documentation.
 
 This script extracts information from the uipath SDK and CLI commands and updates
-the AGENTS.md file with comprehensive documentation including
-- SDK version
-- Quick API Reference (SDK services and methods)
+the AGENTS.md reference files with comprehensive documentation including
+- API Reference (SDK services and methods)
 - CLI Commands Reference
 """
 
@@ -147,101 +146,8 @@ def get_service_methods(service_class: type) -> list[tuple[str, Any]]:
     return methods
 
 
-def generate_required_structure() -> str:
-    """Generate Required Agent Structure documentation.
-
-    Returns:
-        Markdown string with required agent structure
-    """
-    output = StringIO()
-    output.write("\n## Required Agent Structure\n\n")
-    output.write(
-        "**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.\n\n"
-    )
-
-    output.write("### Required Components\n\n")
-    output.write(
-        "Every agent implementation MUST include these three Pydantic models:\n\n"
-    )
-    output.write("```python\n")
-    output.write("from pydantic import BaseModel\n\n")
-    output.write("class Input(BaseModel):\n")
-    output.write('    """Define input fields that the agent accepts"""\n')
-    output.write("    # Add your input fields here\n")
-    output.write("    pass\n\n")
-    output.write("class State(BaseModel):\n")
-    output.write(
-        '    """Define the agent\'s internal state that flows between nodes"""\n'
-    )
-    output.write("    # Add your state fields here\n")
-    output.write("    pass\n\n")
-    output.write("class Output(BaseModel):\n")
-    output.write('    """Define output fields that the agent returns"""\n')
-    output.write("    # Add your output fields here\n")
-    output.write("    pass\n")
-    output.write("```\n\n")
-
-    output.write("### Required LLM Initialization\n\n")
-    output.write(
-        "Unless the user explicitly requests a different LLM provider, always use `UiPathChat`:\n\n"
-    )
-    output.write("```python\n")
-    output.write("from uipath_langchain.chat import UiPathChat\n\n")
-    output.write('llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)\n')
-    output.write("```\n\n")
-    output.write("**Alternative LLMs** (only use if explicitly requested):\n")
-    output.write("- `ChatOpenAI` from `langchain_openai`\n")
-    output.write("- `ChatAnthropic` from `langchain_anthropic`\n")
-    output.write("- Other LangChain-compatible LLMs\n\n")
-
-    output.write("### Standard Agent Template\n\n")
-    output.write("Every agent should follow this basic structure:\n\n")
-    output.write("```python\n")
-    output.write("from langchain_core.messages import SystemMessage, HumanMessage\n")
-    output.write("from langgraph.graph import START, StateGraph, END\n")
-    output.write("from uipath_langchain.chat import UiPathChat\n")
-    output.write("from pydantic import BaseModel\n\n")
-    output.write("# 1. Define Input, State, and Output models\n")
-    output.write("class Input(BaseModel):\n")
-    output.write("    field: str\n\n")
-    output.write("class State(BaseModel):\n")
-    output.write("    field: str\n")
-    output.write('    result: str = ""\n\n')
-    output.write("class Output(BaseModel):\n")
-    output.write("    result: str\n\n")
-    output.write("# 2. Initialize UiPathChat LLM\n")
-    output.write('llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)\n\n')
-    output.write("# 3. Define agent nodes (async functions)\n")
-    output.write("async def process_node(state: State) -> State:\n")
-    output.write("    response = await llm.ainvoke([HumanMessage(state.field)])\n")
-    output.write("    return State(field=state.field, result=response.content)\n\n")
-    output.write("async def output_node(state: State) -> Output:\n")
-    output.write("    return Output(result=state.result)\n\n")
-    output.write("# 4. Build the graph\n")
-    output.write("builder = StateGraph(State, input=Input, output=Output)\n")
-    output.write('builder.add_node("process", process_node)\n')
-    output.write('builder.add_node("output", output_node)\n')
-    output.write('builder.add_edge(START, "process")\n')
-    output.write('builder.add_edge("process", "output")\n')
-    output.write('builder.add_edge("output", END)\n\n')
-    output.write("# 5. Compile the graph\n")
-    output.write("graph = builder.compile()\n")
-    output.write("```\n\n")
-
-    output.write("**Key Rules**:\n")
-    output.write("1. Always use async/await for all node functions\n")
-    output.write("2. All nodes (except output) must accept and return `State`\n")
-    output.write("3. The final output node must return `Output`\n")
-    output.write(
-        "4. Use `StateGraph(State, input=Input, output=Output)` for initialization\n"
-    )
-    output.write("5. Always compile with `graph = builder.compile()`\n\n")
-
-    return output.getvalue()
-
-
 def generate_quick_api_docs() -> str:
-    """Generate Quick API Reference documentation for SDK.
+    """Generate API Reference documentation for SDK.
 
     Returns:
         Markdown string with SDK API documentation
@@ -249,7 +155,7 @@ def generate_quick_api_docs() -> str:
     from uipath import UiPath
 
     output = StringIO()
-    output.write("\n## Quick API Reference\n\n")
+    output.write("\n## API Reference\n\n")
     output.write(
         "This section provides a comprehensive reference for all UiPath SDK services and methods. "
         "Each service is documented with complete method signatures, including parameter types and return types.\n\n"
@@ -567,103 +473,29 @@ def generate_cli_docs() -> str:
     return output.getvalue()
 
 
-def update_agents_md() -> None:
-    """Update the AGENTS.md file and generate separate reference files."""
+def generate_agents_md_reference_files() -> None:
+    """Generate separate reference files."""
     resources_dir = Path(__file__).parent.parent / "src" / "uipath" / "_resources"
-    agents_md_path = resources_dir / "AGENTS.md"
 
-    if not agents_md_path.exists():
-        print(f"Error: AGENTS.md not found at {agents_md_path}", file=sys.stderr)
-        sys.exit(1)
-
-    with open(agents_md_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    required_structure_marker = "## Required Agent Structure"
-    api_marker = "## Quick API Reference"
-    cli_marker = "## CLI Commands Reference"
-    reference_marker = "## Documentation Structure"
-
-    if reference_marker in content:
-        header = content.split(reference_marker)[0].rstrip()
-    elif required_structure_marker in content:
-        header = content.split(required_structure_marker)[0].rstrip()
-    elif api_marker in content:
-        header = content.split(api_marker)[0].rstrip()
-    elif cli_marker in content:
-        header = content.split(cli_marker)[0].rstrip()
-    else:
-        header = content.rstrip()
-
-    required_structure_path = resources_dir / "REQUIRED_STRUCTURE.md"
     sdk_reference_path = resources_dir / "SDK_REFERENCE.md"
     cli_reference_path = resources_dir / "CLI_REFERENCE.md"
 
-    required_structure = generate_required_structure()
     api_docs = generate_quick_api_docs()
     cli_docs = generate_cli_docs()
 
-    with open(required_structure_path, "w", encoding="utf-8") as f:
-        f.write(required_structure.lstrip("\n"))
-
     with open(sdk_reference_path, "w", encoding="utf-8") as f:
         f.write(api_docs.lstrip("\n"))
 
     with open(cli_reference_path, "w", encoding="utf-8") as f:
         f.write(cli_docs.lstrip("\n"))
 
-    updated_content = f"""{header}
-
-## Documentation Structure
-
-This documentation is split into multiple files for efficient context loading. Load only the files you need:
-
-### Core Documentation Files
-
-1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
-   - **When to load:** Creating a new agent or understanding required patterns
-   - **Contains:** Required Pydantic models (Input, State, Output), LLM initialization patterns, standard agent template
-   - **Size:** ~90 lines
-
-2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
-   - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
-   - **Contains:** All SDK services and methods with full signatures and type annotations
-   - **Size:** ~400 lines
-
-3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
-   - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
-   - **Contains:** Command syntax, options, usage examples, and workflows
-   - **Size:** ~200 lines
-
-### Usage Guidelines
-
-**For LLMs:**
-- Read this file (AGENTS.md) first to understand the documentation structure
-- Load .agent/REQUIRED_STRUCTURE.md when building new agents or need structure reference
-- Load .agent/SDK_REFERENCE.md only when you need to call specific SDK methods
-- Load .agent/CLI_REFERENCE.md only when working with CLI commands
-
-**Benefits:**
-- Reduced token usage by loading only relevant context
-- Faster response times
-- More focused context for specific tasks
-"""
-
-    with open(agents_md_path, "w", encoding="utf-8") as f:
-        f.write(updated_content)
-
-    print(f"Successfully updated {agents_md_path}")
-    print(f"Generated {required_structure_path}")
-    print(f"Generated {sdk_reference_path}")
-    print(f"Generated {cli_reference_path}")
-
 
 def main():
     """Main function."""
     try:
-        update_agents_md()
+        generate_agents_md_reference_files()
     except Exception as e:
-        print(f"Error updating AGENTS.md: {e}", file=sys.stderr)
+        print(f"Error updating AGENTS.md reference files: {e}", file=sys.stderr)
         sys.exit(1)
 
 

{uipath-2.1.88 → uipath-2.1.90}/src/uipath/_cli/_evals/_models/_evaluation_set.py

@@ -44,6 +44,15 @@ class LLMMockingStrategy(BaseMockingStrategy):
     )
 
 
+class InputMockingStrategy(BaseModel):
+    prompt: str = Field(..., alias="prompt")
+    model: Optional[ModelSettings] = Field(None, alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
 class MockingArgument(BaseModel):
     args: List[Any] = Field(default_factory=lambda: [], alias="args")
     kwargs: Dict[str, Any] = Field(default_factory=lambda: {}, alias="kwargs")
@@ -110,6 +119,10 @@ class EvaluationItem(BaseModel):
         default=None,
         alias="mockingStrategy",
     )
+    input_mocking_strategy: Optional[InputMockingStrategy] = Field(
+        default=None,
+        alias="inputMockingStrategy",
+    )
 
 
 class EvaluationSet(BaseModel):

{uipath-2.1.88 → uipath-2.1.90}/src/uipath/_cli/_evals/_runtime.py

@@ -11,6 +11,10 @@ from opentelemetry import context as context_api
 from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
+from uipath._cli._evals.mocks.input_mocker import (
+    generate_llm_input,
+)
+
 from ..._events._event_bus import EventBus
 from ..._events._events import (
     EvalItemExceptionDetails,
@@ -318,6 +322,10 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         evaluators: List[BaseEvaluator[Any]],
         event_bus: EventBus,
     ) -> EvaluationRunResult:
+        # Generate LLM-based input if input_mocking_strategy is defined
+        if eval_item.input_mocking_strategy:
+            eval_item = await self._generate_input_for_eval(eval_item)
+
         set_execution_context(eval_item, self.span_collector)
 
         await event_bus.publish(
@@ -417,6 +425,16 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         return evaluation_run_results
 
+    async def _generate_input_for_eval(
+        self, eval_item: EvaluationItem
+    ) -> EvaluationItem:
+        """Use LLM to generate a mock input for an evaluation item."""
+        # TODO(bai): get the input schema from agent definition, once it is available there.
+        input_schema: dict[str, Any] = {}
+        generated_input = await generate_llm_input(eval_item, input_schema)
+        updated_eval_item = eval_item.model_copy(update={"inputs": generated_input})
+        return updated_eval_item
+
     def _get_and_clear_execution_data(
         self, execution_id: str
     ) -> tuple[List[ReadableSpan], list[logging.LogRecord]]:

uipath-2.1.90/src/uipath/_cli/_evals/mocks/input_mocker.py

@@ -0,0 +1,111 @@
+"""LLM Input Mocker implementation."""
+
+import json
+from datetime import datetime
+from typing import Any, Dict
+
+from uipath import UiPath
+from uipath._cli._evals._models._evaluation_set import EvaluationItem
+from uipath.tracing._traced import traced
+
+from .mocker import UiPathInputMockingError
+
+
+def get_input_mocking_prompt(
+    input_schema: str,
+    input_generation_instructions: str,
+    expected_behavior: str,
+    expected_output: str,
+) -> str:
+    """Generate the LLM input mocking prompt."""
+    current_datetime = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+
+    return f"""You are simulating input for automated testing purposes of an Agent as part of a simulation run.
+You will need to generate realistic input to a LLM agent which will call various tools to achieve a goal. This must be in the exact format of the INPUT_SCHEMA.
+You may need to follow specific INPUT_GENERATION_INSTRUCTIONS. If no relevant instructions are provided pertaining to input generation, use the other provided information and your own judgement to generate input.
+If the INPUT_GENERATION_INSTRUCTIONS are provided, you MUST follow them exactly. For example if the instructions say to generate a value for a field to be before a certain calendar date, you must generate a value that is before that date.
+
+The current date and time is: {current_datetime}
+
+#INPUT_SCHEMA: You MUST OUTPUT THIS EXACT JSON SCHEMA
+{input_schema}
+#END_INPUT_SCHEMA
+
+#INPUT_GENERATION_INSTRUCTIONS
+{input_generation_instructions}
+#END_INPUT_GENERATION_INSTRUCTIONS
+
+#EXPECTED_BEHAVIOR
+{expected_behavior}
+#END_EXPECTED_BEHAVIOR
+
+#EXPECTED_OUTPUT
+{expected_output}
+#END_EXPECTED_OUTPUT
+
+Based on the above information, provide a realistic input to the LLM agent. Your response should:
+1. Match the expected input format according to the INPUT_SCHEMA exactly
+2. Be consistent with the style and level of detail in the example inputs
+3. Consider the context of the the agent being tested
+4. Be realistic and representative of what a real user might say or ask
+
+OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA in valid JSON. Do not include any explanations, quotation marks, or markdown."""
+
+
+@traced(name="__mocker__")
+async def generate_llm_input(
+    evaluation_item: EvaluationItem,
+    input_schema: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Generate synthetic input using an LLM based on the evaluation context."""
+    try:
+        llm = UiPath().llm
+
+        prompt = get_input_mocking_prompt(
+            input_schema=json.dumps(input_schema, indent=2),
+            input_generation_instructions=evaluation_item.input_mocking_strategy.prompt
+            if evaluation_item.input_mocking_strategy
+            else "",
+            expected_behavior=evaluation_item.expected_agent_behavior or "",
+            expected_output=json.dumps(evaluation_item.expected_output, indent=2)
+            if evaluation_item.expected_output
+            else "",
+        )
+
+        response_format = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": "agent_input",
+                "strict": True,
+                "schema": input_schema,
+            },
+        }
+
+        model_parameters = (
+            evaluation_item.input_mocking_strategy.model
+            if evaluation_item.input_mocking_strategy
+            else None
+        )
+        completion_kwargs = (
+            model_parameters.model_dump(by_alias=False, exclude_none=True)
+            if model_parameters
+            else {}
+        )
+
+        response = await llm.chat_completions(
+            [{"role": "user", "content": prompt}],
+            response_format=response_format,
+            **completion_kwargs,
+        )
+
+        generated_input_str = response.choices[0].message.content
+
+        return json.loads(generated_input_str)
+    except json.JSONDecodeError as e:
+        raise UiPathInputMockingError(
+            f"Failed to parse LLM response as JSON: {str(e)}"
+        ) from e
+    except UiPathInputMockingError:
+        raise
+    except Exception as e:
+        raise UiPathInputMockingError(f"Failed to generate input: {str(e)}") from e

{uipath-2.1.88 → uipath-2.1.90}/src/uipath/_cli/_evals/mocks/mocker.py

@@ -33,3 +33,9 @@ class UiPathMockResponseGenerationError(Exception):
     """Exception when a mocker is configured unable to generate a response."""
 
     pass
+
+
+class UiPathInputMockingError(Exception):
+    """Exception when input mocking fails."""
+
+    pass

{uipath-2.1.88 → uipath-2.1.90}/src/uipath/_cli/_push/sw_file_handler.py

@@ -1,14 +1,12 @@
 """Studio Web File Handler for managing file operations in UiPath projects."""
 
 import json
+import logging
 import os
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, Set
 
-import click
-
 from ...models.exceptions import EnrichedException
-from .._utils._console import ConsoleLogger
 from .._utils._constants import (
     AGENT_INITIAL_CODE_VERSION,
     AGENT_STORAGE_VERSION,
@@ -30,6 +28,8 @@ from .._utils._studio_project import (
     StudioClient,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class SwFileHandler:
     """Handler for Studio Web file operations.
@@ -58,7 +58,6 @@ class SwFileHandler:
         """
         self.directory = directory
         self.include_uv_lock = include_uv_lock
-        self.console = ConsoleLogger()
         self._studio_client = StudioClient(project_id)
         self._project_structure: Optional[ProjectStructure] = None
 
@@ -156,9 +155,7 @@ class SwFileHandler:
 
         for local_file in local_files:
             if not os.path.exists(local_file.file_path):
-                self.console.warning(
-                    f"File not found: {click.style(local_file.file_path, fg='cyan')}"
-                )
+                logger.info(f"File not found: '{local_file.file_path}'")
                 continue
 
             # Skip agent.json as it's handled separately
@@ -175,9 +172,7 @@ class SwFileHandler:
                         id=remote_file.id, content_file_path=local_file.file_path
                     )
                 )
-                self.console.info(
-                    f"Updating {click.style(local_file.file_name, fg='yellow')}"
-                )
+                logger.info(f"Updating '{local_file.file_name}'")
             else:
                 parent_path = os.path.dirname(local_file.relative_path)
                 structural_migration.added_resources.append(
@@ -188,9 +183,7 @@ class SwFileHandler:
                         else "source_code",
                     )
                 )
-                self.console.info(
-                    f"Uploading {click.style(local_file.relative_path, fg='cyan')}"
-                )
+                logger.info(f"Uploading '{local_file.relative_path}'")
 
         # identify and add deleted files
         structural_migration.deleted_resources.extend(
@@ -236,9 +229,7 @@ class SwFileHandler:
         for _, remote_file in source_code_files.items():
             if remote_file.id not in processed_source_file_paths:
                 deleted_files.add(remote_file.id)
-                self.console.info(
-                    f"Deleting {click.style(remote_file.name, fg='bright_red')}"
-                )
+                logger.info(f"Deleting '{remote_file.name}'")
 
         return deleted_files
 
@@ -263,16 +254,14 @@ class SwFileHandler:
             for folder_info in empty_folder_ids:
                 try:
                     await self._studio_client.delete_item_async(folder_info["id"])
-                    self.console.info(
-                        f"Deleted empty folder {click.style(folder_info['name'], fg='bright_red')}"
-                    )
+                    logger.info(f"Deleted empty folder '{folder_info['name']}'")
                 except Exception as e:
-                    self.console.warning(
-                        f"Failed to delete empty folder {folder_info['name']}: {str(e)}"
+                    logger.warning(
+                        f"Failed to delete empty folder '{folder_info['name']}': {str(e)}"
                     )
 
         except Exception as e:
-            self.console.warning(f"Failed to cleanup empty folders: {str(e)}")
+            logger.warning(f"Failed to cleanup empty folders: {str(e)}")
 
     def _collect_empty_folders(self, folder: ProjectFolder) -> list[dict[str, str]]:
         """Recursively collect IDs and names of empty folders.
@@ -335,8 +324,8 @@ class SwFileHandler:
                 entry_points_json["entryPoints"] = uipath_config["entryPoints"]
 
             except Exception:
-                self.console.warning(
-                    "Could not parse existing entry-points.json file, using default version"
+                logger.info(
+                    "Could not parse existing 'entry-points.json' file, using default version"
                 )
             structural_migration.modified_resources.append(
                 ModifiedResource(
@@ -344,12 +333,10 @@ class SwFileHandler:
                     content_string=json.dumps(entry_points_json),
                 )
             )
-            self.console.info(
-                f"Updating {click.style('entry-points.json', fg='yellow')}"
-            )
+            logger.info("Updating 'entry-points.json'")
 
         else:
-            self.console.warning(
+            logger.info(
                 "'entry-points.json' file does not exist in Studio Web project, initializing using default version"
             )
             entry_points_json = {
@@ -363,9 +350,7 @@ class SwFileHandler:
                     content_string=json.dumps(entry_points_json),
                 )
             )
-            self.console.info(
-                f"Uploading {click.style('entry-points.json', fg='cyan')}"
-            )
+            logger.info("Uploading 'entry-points.json'")
 
     async def _prepare_agent_json_migration(
         self,
@@ -400,9 +385,10 @@ class SwFileHandler:
             input_schema = uipath_config["entryPoints"][0]["input"]
             output_schema = uipath_config["entryPoints"][0]["output"]
         except (FileNotFoundError, KeyError) as e:
-            self.console.error(
+            logger.error(
                 f"Unable to extract entrypoints from configuration file. Please run 'uipath init' : {str(e)}",
             )
+            return
 
         author = get_author_from_token_or_toml()
 
@@ -444,8 +430,8 @@ class SwFileHandler:
                         AGENT_INITIAL_CODE_VERSION[:-1] + "1"
                     )
             except Exception:
-                self.console.warning(
-                    "Could not parse existing agent.json file, using default version"
+                logger.info(
+                    "Could not parse existing 'agent.json' file, using default version"
                 )
 
             structural_migration.modified_resources.append(
@@ -454,9 +440,9 @@ class SwFileHandler:
                     content_string=json.dumps(agent_json),
                 )
             )
-            self.console.info(f"Updating {click.style('agent.json', fg='yellow')}")
+            logger.info("Updating 'agent.json'")
         else:
-            self.console.warning(
+            logger.info(
                 "'agent.json' file does not exist in Studio Web project, initializing using default version"
             )
             structural_migration.added_resources.append(
@@ -465,7 +451,7 @@ class SwFileHandler:
                     content_string=json.dumps(agent_json),
                 )
             )
-            self.console.info(f"Uploading {click.style('agent.json', fg='cyan')}")
+            logger.info("Uploading 'agent.json'")
 
     async def upload_source_files(self, config_data: dict[str, Any]) -> None:
         """Main method to upload source files to the UiPath project.
@@ -502,9 +488,7 @@ class SwFileHandler:
         if not source_code_folder:
             await self._studio_client.create_folder_async("source_code")
 
-            self.console.success(
-                f"Created {click.style('source_code', fg='cyan')} folder"
-            )
+            logger.info("Created 'source_code' folder.")
             source_code_files = {}
 
         # Get files to upload and process them

{uipath-2.1.88 → uipath-2.1.90}/src/uipath/_cli/_runtime/_logging.py

@@ -266,6 +266,10 @@ class LogsInterceptor:
             def writable(self) -> bool:
                 return True
 
+            def __getattr__(self, name):
+                # Delegate any unknown attributes to the original file
+                return getattr(self.sys_file, name)
+
         # Set up stdout and stderr loggers
         stdout_logger = logging.getLogger("stdout")
         stderr_logger = logging.getLogger("stderr")