waldiez 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

waldiez/exporting/core/result.py

@@ -59,7 +59,7 @@ class ExportResult:
         position : ImportPosition, optional
             The position of the import, by default THIRD_PARTY
         """
-        if statement and statement.strip():
+        if statement and statement.strip():  # pragma: no branch
             self.imports.add(
                 ImportStatement(
                     statement=statement.strip(),
@@ -123,7 +123,7 @@ class ExportResult:
         comment : Optional[str], optional
             Optional comment for the argument, by default None
         """
-        if name and value is not None:
+        if name and value is not None:  # pragma: no branch
             arg = InstanceArgument(
                 instance_id=instance_id,
                 name=name,
@@ -173,7 +173,7 @@ class ExportResult:
         position : ExportPosition, optional
             The position for the merged content, by default AGENTS
         """
-        if other.main_content:
+        if other.main_content:  # pragma: no branch
             self.main_content = (
                 (self.main_content or "") + "\n" + other.main_content
             ).strip()
@@ -241,7 +241,7 @@ class ExportResult:
             Additional metadata for the content, by default None
         """
         order_value = order.value if isinstance(order, ContentOrder) else order
-        if content and content.strip():
+        if content and content.strip():  # pragma: no branch
             positioned = PositionedContent(
                 content=content.strip() if not skip_strip else content,
                 position=position,
@@ -273,7 +273,7 @@ class ExportResult:
         required : bool, optional
             Whether the variable is required, by default True
         """
-        if name and value:
+        if name and value:  # pragma: no branch
             env_var = EnvironmentVariable(
                 name=name,
                 value=value,

waldiez/exporting/flow/merger.py

@@ -167,7 +167,7 @@ class ContentMerger:
             # Log conflicts but continue
             for conflict in conflicts:
                 self.context.get_logger().warning(
-                    f"Import conflict: {conflict}"
+                    "Import conflict: %s", conflict
                 )
 
         return set(grouped.values())
@@ -309,7 +309,7 @@ class ContentMerger:
             # Log conflicts but continue (non-fatal)
             for conflict in conflicts:
                 self.context.get_logger().warning(
-                    f"Environment variable conflict: {conflict}"
+                    "Environment variable conflict: %s", conflict
                 )
 
         return list(env_vars.values())

waldiez/exporting/flow/orchestrator.py

@@ -249,6 +249,7 @@ class ExportOrchestrator:
                 agent_names=self.agent_names,
                 tools=self.tools,
                 tool_names=self.tool_names,
+                is_async=self.waldiez.is_async,
                 output_dir=self.config.output_directory,
                 context=self.context,
             )

waldiez/exporting/flow/utils/common.py

@@ -120,8 +120,8 @@ def main_doc_string() -> str:
 
     Raises
     ------
-    RuntimeError
-        If the chat session fails.
+    SystemExit
+        If the user interrupts the chat session.
     """'''
 
 

waldiez/exporting/flow/utils/importing.py

@@ -208,6 +208,7 @@ def get_the_imports_string(
         final_string += "\n"
 
     if is_async:
+        builtin_imports.insert(0, "import asyncio")
         final_string += (
             "\nimport aiofiles"
             "\nimport aiosqlite"

waldiez/exporting/flow/utils/logging.py

@@ -113,7 +113,7 @@ def get_sync_sqlite_out() -> str:
         cursor = conn.execute(query)
         rows = cursor.fetchall()
         column_names = [description[0] for description in cursor.description]
-        data = [dict(zip(column_names, row)) for row in rows]
+        data = [dict(zip(column_names, row, strict=True)) for row in rows]
         conn.close()
         with open(csv_file, "w", newline="", encoding="utf-8") as file:
             csv_writer = csv.DictWriter(file, fieldnames=column_names)
@@ -148,7 +148,8 @@ def get_sync_sqlite_out() -> str:
     content += "    rows = cursor.fetchall()\n"
     content += "    column_names = [description[0] for description "
     content += "in cursor.description]\n"
-    content += "    data = [dict(zip(column_names, row)) for row in rows]\n"
+    # pylint: disable=line-too-long
+    content += "    data = [dict(zip(column_names, row, strict=True)) for row in rows]\n"
     content += "    conn.close()\n"
     content += (
         '    with open(csv_file, "w", newline="", encoding="utf-8") as file:\n'
@@ -200,7 +201,7 @@ def get_async_sqlite_out() -> str:
             return
         rows = await cursor.fetchall()
         column_names = [description[0] for description in cursor.description]
-        data = [dict(zip(column_names, row)) for row in rows]
+        data = [dict(zip(column_names, row, strict=True)) for row in rows]
         await cursor.close()
         await conn.close()
         async with aiofiles.open(csv_file, "w", newline="", encoding="utf-8") as file:
@@ -235,7 +236,7 @@ def get_async_sqlite_out() -> str:
     content += "    rows = await cursor.fetchall()\n"
     content += "    column_names = [description[0] for description "
     content += "in cursor.description]\n"
-    content += "    data = [dict(zip(column_names, row)) for row in rows]\n"
+    content += "    data = [dict(zip(column_names, row, strict=True)) for row in rows]\n"
     content += "    await cursor.close()\n"
     content += "    await conn.close()\n"
     content += '    async with aiofiles.open(csv_file, "w", newline="", encoding="utf-8") as file:\n'
@@ -369,9 +370,7 @@ def get_stop_logging(is_async: bool, tabs: int = 0) -> str:
     content += "def stop_logging() -> None:\n"
     content += '    """Stop logging."""\n'
     if is_async:
-        content += f"{tab}    # pylint: disable=import-outside-toplevel\n"
-        content += f"{tab}    from asyncer import asyncify\n\n"
-        content += f"{tab}    await asyncify(runtime_logging.stop)()\n"
+        content += f"{tab}    await asyncio.to_thread(runtime_logging.stop)\n"
     else:
         content += f"{tab}    runtime_logging.stop()\n"
     content += get_sqlite_out_call(tabs + 1, is_async)

waldiez/exporting/tools/exporter.py

@@ -32,6 +32,7 @@ class ToolsExporter(Exporter[ToolExtras]):
         agent_names: dict[str, str],
         tools: list[WaldiezTool],
         tool_names: dict[str, str],
+        is_async: bool,
         output_dir: str | Path | None = None,
         context: ExporterContext | None = None,
         **kwargs: Any,
@@ -50,6 +51,8 @@ class ToolsExporter(Exporter[ToolExtras]):
             The tools to export.
         tool_names : dict[str, str]
             Mapping of tool IDs to names.
+        is_async : bool
+            Whether the flow is asynchronous.
         output_dir : str | Path | None
             Output directory for generated files, by default None
         context : ExporterContext | None
@@ -64,6 +67,7 @@ class ToolsExporter(Exporter[ToolExtras]):
         self.agent_names = agent_names
         self.tools = tools
         self.tool_names = tool_names
+        self.is_async = is_async
         self.output_dir = Path(output_dir) if output_dir else None
 
         # Initialize extras with processed tool content
@@ -83,6 +87,7 @@ class ToolsExporter(Exporter[ToolExtras]):
             flow_name=self.flow_name,
             tools=self.tools,
             tool_names=self.tool_names,
+            is_async=self.is_async,
             output_dir=self.output_dir,
         )
 

waldiez/exporting/tools/factory.py

@@ -16,6 +16,7 @@ def create_tools_exporter(
     agent_names: dict[str, str],
     tools: list[WaldiezTool],
     tool_names: dict[str, str],
+    is_async: bool,
     output_dir: str | Path | None = None,
     context: ExporterContext | None = None,
 ) -> ToolsExporter:
@@ -33,6 +34,8 @@ def create_tools_exporter(
         The tools to export.
     tool_names : dict[str, str]
         Mapping of tool IDs to names.
+    is_async : bool
+        Whether the flow is asynchronous.
     output_dir : str | Path | None, optional
         Output directory for generated files, by default None
     context : ExporterContext | None, optional
@@ -52,5 +55,6 @@ def create_tools_exporter(
         tools=tools,
         tool_names=tool_names,
         output_dir=output_dir,
+        is_async=is_async,
         context=context,
     )

waldiez/exporting/tools/processor.py

@@ -33,6 +33,7 @@ class ToolProcessor:
         flow_name: str,
         tools: list[WaldiezTool],
         tool_names: dict[str, str],
+        is_async: bool,
         output_dir: Path | None = None,
     ):
         """Initialize the tool processor.
@@ -52,6 +53,7 @@ class ToolProcessor:
         self.tools = tools
         self.tool_names = tool_names
         self.output_dir = output_dir
+        self.is_async = is_async
 
     def process(self) -> ToolProcessingResult:
         """Process all tools and return consolidated result.
@@ -94,7 +96,9 @@ class ToolProcessor:
             The result to add processed content to.
         """
         # Get tool content
-        tool_content = tool.get_content()
+        tool_content = tool.get_content(
+            runtime_kwargs={"is_async": self.is_async}
+        )
         if tool_content:  # pragma: no branch
             # Add interop conversion if needed
             if tool.is_interop:

waldiez/io/_ws.py

@@ -5,6 +5,7 @@
 """WebSocket IOStream implementation for AsyncIO."""
 
 import asyncio
+import logging
 from typing import Any, Protocol
 
 HAS_WS_LIB = False
@@ -13,7 +14,7 @@ try:
     from starlette.websockets import WebSocket  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]  # noqa
 
     HAS_WS_LIB = True  # pyright: ignore
-except ImportError:
+except ImportError:  # pragma: no cover
     pass
 
 try:
@@ -68,6 +69,7 @@ class WebSocketsAdapter:
             The websockets library connection.
         """
         self.websocket = websocket
+        self.log = logging.getLogger(__name__)
 
     async def send_message(self, message: str) -> None:
         """Send a message using websockets library.
@@ -100,11 +102,14 @@ class WebSocketsAdapter:
             )
             if isinstance(response, bytes):
                 return response.decode("utf-8")
+            # noinspection PyUnreachableCode
             return response if isinstance(response, str) else str(response)
         except asyncio.TimeoutError:
             return ""
-        except BaseException:  # pylint: disable=broad-exception-caught
-            # Handle other exceptions that may occur during receive
+        except BaseException as exc:  # pylint: disable=broad-exception-caught
+            self.log.error(
+                "WebsocketsAdapter: Error receiving message: %s", exc
+            )  # pragma: no cover
             return ""
 
 
@@ -120,6 +125,7 @@ class StarletteAdapter:
             The Starlette/FastAPI WebSocket connection.
         """
         self.websocket = websocket
+        self.log = logging.getLogger(__name__)
 
     async def send_message(self, message: str) -> None:
         """Send a message using Starlette WebSocket.
@@ -151,8 +157,10 @@ class StarletteAdapter:
             )
         except asyncio.TimeoutError:
             return ""
-        except BaseException:  # pylint: disable=broad-exception-caught
-            # Handle other exceptions that may occur during receive
+        except BaseException as exc:  # pylint: disable=broad-exception-caught
+            self.log.error(
+                "StarletteAdapter: Error receiving message: %s", exc
+            )  # pragma: no cover
             return ""
 
 

waldiez/io/models/content/image.py

@@ -61,6 +61,7 @@ class ImageUrlMediaContent(BaseModel):
     type: Literal["image_url"] = "image_url"
     image_url: ImageContent
 
+    # noinspection DuplicatedCode
     def to_string(
         self,
         uploads_root: Path | None,

waldiez/io/models/user_input.py

@@ -97,7 +97,7 @@ class UserInputData(BaseModel):
                 parsed = json.loads(parsed)
             except json.JSONDecodeError:
                 return TextMediaContent(type="text", text=parsed)
-            if isinstance(parsed, str):
+            if isinstance(parsed, str):  # pragma: no cover
                 return TextMediaContent(type="text", text=parsed)
         return cls.validate_content(parsed)
 
@@ -256,15 +256,15 @@ def extract_filename_from_path(path_or_url: str) -> str:
         filename = os.path.basename(parsed.path)
 
         # Handle edge cases where path might be empty or end with /
-        if not filename and parsed.path.endswith("/"):
+        if not filename and parsed.path.endswith("/"):  # pragma: no cover
             # Try to get the last directory name
             path_parts = [p for p in parsed.path.split("/") if p]
             filename = path_parts[-1] if path_parts else parsed.netloc
-        elif not filename:
+        elif not filename:  # pragma: no cover
             # Fallback to using netloc (domain) if no path
             filename = parsed.netloc
 
         return filename
     # else:
     # Local file path
-    return os.path.basename(path_or_url)
+    return os.path.basename(path_or_url)  # pragma: no cover

waldiez/io/models/user_response.py

@@ -209,6 +209,7 @@ class UserResponse(StructuredBase):
         # we have probably returned sth till here
         if isinstance(self.data, str):  # pyright: ignore # pragma: no cover
             return self.data
+        # noinspection PyUnreachableCode
         return (  # pragma: no cover
             json.dumps(self.data)
             if hasattr(self.data, "__dict__")

waldiez/io/mqtt.py

@@ -473,7 +473,7 @@ class MqttIOStream(IOStream):
         print_message = PrintMessage.create(*args, **kwargs)
         try:
             payload = print_message.model_dump(mode="json")
-        except Exception:
+        except Exception:  # pragma: no cover
             payload = print_message.model_dump(
                 serialize_as_any=True, mode="json", fallback=str
             )

waldiez/io/structured.py

@@ -104,7 +104,7 @@ class StructuredIOStream(IOStream):
         """
         request_id = uuid4().hex
         prompt = prompt or ">"
-        if not prompt or prompt in [">", "> "]:
+        if not prompt or prompt in [">", "> "]:  # pragma: no cover
             # if the prompt is just ">" or "> ",
             # let's use a more descriptive one
             prompt = "Enter your message to start the conversation: "
@@ -116,22 +116,6 @@ class StructuredIOStream(IOStream):
             uploads_root=self.uploads_root,
             base_name=request_id,
         )
-        # let's keep an eye here:
-        # https://github.com/ag2ai/ag2/blob/main/autogen/agentchat/conversable_agent.py#L2973
-        # reply = await iostream.input(prompt) ???? (await???)
-        if self.is_async:
-            # let's make a coroutine to just return the user response
-            async def async_input() -> str:
-                """Asynchronous input method.
-
-                Returns
-                -------
-                str
-                    The line read from the input stream.
-                """
-                return user_response
-
-            return async_input()  # type: ignore
         return user_response
 
     # noinspection PyMethodMayBeStatic
@@ -205,6 +189,11 @@ class StructuredIOStream(IOStream):
         except queue.Empty:
             self._send_timeout_message(request_id)
             return ""
+        except BaseException as e:
+            self._send_error_message(request_id, str(e))
+            return ""
+        finally:
+            input_thread.join(timeout=1)
 
     def _send_timeout_message(self, request_id: str) -> None:
         timeout_payload = {
@@ -216,6 +205,17 @@ class StructuredIOStream(IOStream):
         }
         print(json.dumps(timeout_payload), flush=True, file=sys.stderr)
 
+    # noinspection PyMethodMayBeStatic
+    def _send_error_message(self, request_id: str, error_message: str) -> None:
+        error_payload = {
+            "id": gen_id(),
+            "type": "error",
+            "request_id": request_id,
+            "timestamp": now(),
+            "data": error_message,
+        }
+        print(json.dumps(error_payload), flush=True, file=sys.stderr)
+
     def _handle_user_input(
         self, user_input_raw: str, request_id: str
     ) -> UserResponse:

waldiez/io/utils.py

@@ -170,7 +170,7 @@ def try_parse_maybe_serialized(value: str) -> Any:
     """
     for parser in (json.loads, ast.literal_eval):
         # pylint: disable=broad-exception-caught, too-many-try-statements
-        # noinspection PyBroadException
+        # noinspection PyBroadException,TryExceptPass
         try:
             parsed: dict[str, Any] | list[Any] | str = parser(value)
             # Normalize: if it's a single-item list of a string

waldiez/io/ws.py

@@ -29,7 +29,7 @@ from .utils import (
 
 LOG = logging.getLogger(__name__)
 
-if not is_websocket_available():
+if not is_websocket_available():  # pragma: no cover
     raise ImportError(
         "WebSocket support requires "
         "either the 'websockets' or 'starlette' package. "
@@ -72,14 +72,14 @@ class AsyncWebsocketsIOStream(IOStream):
             websocket, "receive_message"
         ):
             self.websocket: WebSocketConnection = websocket
-        else:
+        else:  # pragma: no cover
             self.websocket = create_websocket_adapter(websocket)
 
         self.is_async = is_async
         self.verbose = verbose
         self.receive_timeout = receive_timeout
 
-        if isinstance(uploads_root, str):
+        if isinstance(uploads_root, str):  # pragma: no cover
             uploads_root = Path(uploads_root)
         if uploads_root is not None:
             uploads_root = uploads_root.resolve()
@@ -94,7 +94,7 @@ class AsyncWebsocketsIOStream(IOStream):
             except RuntimeError:
                 pass
 
-            if loop is not None:
+            if loop is not None:  # pragma: no cover
                 # We're in an async context, create a task
                 asyncio.create_task(self.websocket.send_message(json_dump))
             else:
@@ -119,7 +119,7 @@ class AsyncWebsocketsIOStream(IOStream):
         msg = sep.join(str(arg) for arg in args)
 
         is_dumped = is_json_dumped(msg)
-        if is_dumped and end.endswith("\n"):
+        if is_dumped and end.endswith("\n"):  # pragma: no cover
             msg = json.loads(msg)
         else:
             msg = f"{msg}{end}"
@@ -145,7 +145,7 @@ class AsyncWebsocketsIOStream(IOStream):
         """
         message_dump = get_message_dump(message)
 
-        if message_dump.get("type") == "text":
+        if message_dump.get("type") == "text":  # pragma: no cover
             content_block = message_dump.get("content")
             if (
                 isinstance(content_block, dict)
@@ -186,7 +186,7 @@ class AsyncWebsocketsIOStream(IOStream):
 
         try:
             return asyncio.run(coro)
-        except RuntimeError:
+        except RuntimeError:  # pragma: no cover
             loop = asyncio.get_event_loop()
             future = asyncio.run_coroutine_threadsafe(coro, loop)
             return future.result()
@@ -215,7 +215,7 @@ class AsyncWebsocketsIOStream(IOStream):
         str
             The user input, or empty string if timeout exceeded.
         """
-        if timeout is None:
+        if timeout is None:  # pragma: no branch
             timeout = self.receive_timeout or 120.0
 
         request_id = uuid.uuid4().hex
@@ -239,9 +239,7 @@ class AsyncWebsocketsIOStream(IOStream):
         await self.websocket.send_message(prompt_dump)
         response = await self.websocket.receive_message(timeout=timeout)
 
-        # Handle empty response from timeout
-        if not response:
-            LOG.warning("Input request timed out after %s seconds", timeout)
+        if not response:  # pragma: no cover
             return ""
 
         if self.verbose: