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

waldiez/io/models/user_response.py

@@ -1,10 +1,14 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportUnnecessaryIsInstance=false,reportUnknownVariableType=false
+# pyright: reportUnknownArgumentType=false,reportArgumentType=false
+
 """User response model and validation."""
 
 import json
 from pathlib import Path
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable
 
 from pydantic import ValidationError, field_validator
 
@@ -26,7 +30,7 @@ class UserResponse(StructuredBase):
     @classmethod
     def validate_data(
         cls, value: Any
-    ) -> Optional[Union[str, UserInputData, list[UserInputData]]]:
+    ) -> str | UserInputData | list[UserInputData] | None:
         """Validate the data field in UserResponse.
 
         Parameters
@@ -51,16 +55,16 @@ class UserResponse(StructuredBase):
 
         handlers: dict[
             type,
-            Callable[[Any], Union[str, UserInputData, list[UserInputData]]],
+            Callable[[Any], str | UserInputData | list[UserInputData]],
         ] = {
             str: cls._handle_string,
             dict: cls._handle_dict,
             list: cls._handle_list,
         }
 
-        value_type = type(value)  # pyright: ignore
+        value_type = type(value)
         handler = handlers.get(
-            value_type,  # pyright: ignore
+            value_type,
             cls._handle_default,
         )
         result = handler(value)
@@ -71,16 +75,13 @@ class UserResponse(StructuredBase):
         """Check if value is already a valid type."""
         return isinstance(value, UserInputData) or (
             isinstance(value, list)
-            and all(
-                isinstance(item, UserInputData)
-                for item in value  # pyright: ignore
-            )
+            and all(isinstance(item, UserInputData) for item in value)
         )
 
     @classmethod
     def _handle_string(
         cls, value: str
-    ) -> Union[str, UserInputData, list[UserInputData]]:
+    ) -> str | UserInputData | list[UserInputData]:
         """Handle string input.
 
         Parameters
@@ -97,9 +98,9 @@ class UserResponse(StructuredBase):
         try:
             parsed_value = json.loads(value)
             if isinstance(parsed_value, dict):
-                return cls._handle_dict(parsed_value)  # pyright: ignore
+                return cls._handle_dict(parsed_value)
             if isinstance(parsed_value, list):
-                return cls._handle_list(parsed_value)  # pyright: ignore
+                return cls._handle_list(parsed_value)
             return cls._create_text_input(str(parsed_value))
         except json.JSONDecodeError:
             return cls._create_text_input(value)
@@ -127,18 +128,18 @@ class UserResponse(StructuredBase):
     @classmethod
     def _handle_list(
         cls, value: list[Any]
-    ) -> Union[UserInputData, list[UserInputData]]:
+    ) -> UserInputData | list[UserInputData]:
         result: list[UserInputData] = []
 
         for item in value:
             if isinstance(item, UserInputData):
                 result.append(item)
             elif isinstance(item, dict):
-                result.append(cls._handle_dict(item))  # pyright: ignore
+                result.append(cls._handle_dict(item))
             elif isinstance(item, str):
                 result.append(cls._create_text_input(item))
             elif isinstance(item, list):
-                nested_result = cls._handle_list(item)  # pyright: ignore
+                nested_result = cls._handle_list(item)
                 if isinstance(nested_result, list):
                     result.extend(nested_result)
                 else:
@@ -207,7 +208,7 @@ class UserResponse(StructuredBase):
                 uploads_root=uploads_root, base_name=base_name
             ).strip()
         # we have probably returned sth till here
-        if isinstance(self.data, str):  # pyright: ignore # pragma: no cover
+        if isinstance(self.data, str):  # pragma: no cover
             return self.data
         # noinspection PyUnreachableCode
         return (  # pragma: no cover

waldiez/io/mqtt.py

@@ -7,6 +7,9 @@
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 # pylint: disable=too-many-locals,too-many-instance-attributes
 
+# pyright: reportMissingTypeStubs=false,reportUnknownMemberType=false
+# pyright: reportUnusedParameter=false
+
 """An MQTT I/O stream for handling print and input messages."""
 
 import json
@@ -17,12 +20,7 @@ import uuid
 from pathlib import Path
 from threading import Event, Lock
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    Type,
-)
+from typing import Any, Callable
 
 try:
     from paho.mqtt import client as mqtt
@@ -44,7 +42,7 @@ from .models import (
     UserInputRequest,
     UserResponse,
 )
-from .utils import gen_id, now
+from .utils import gen_id, get_message_dump, now
 
 LOG = logging.getLogger(__name__)
 
@@ -62,8 +60,8 @@ class MqttIOStream(IOStream):
     client: mqtt.Client
     task_id: str
     input_timeout: int
-    on_input_request: Optional[Callable[[str, str, str], None]]
-    on_input_received: Optional[Callable[[str, str], None]]
+    on_input_request: Callable[[str, str, str], None] | None
+    on_input_response: Callable[[str, str], None] | None
     max_retain_messages: int
     output_topic: str
     input_request_topic: str
@@ -87,8 +85,8 @@ class MqttIOStream(IOStream):
         input_timeout: int = 120,
         connect_timeout: int = 10,
         max_retain_messages: int = 1000,
-        on_input_request: Optional[Callable[[str, str, str], None]] = None,
-        on_input_response: Optional[Callable[[str, str], None]] = None,
+        on_input_request: Callable[[str, str, str], None] | None = None,
+        on_input_response: Callable[[str, str], None] | None = None,
         mqtt_client_kwargs: dict[str, Any] | None = None,
         uploads_root: Path | str | None = None,
         username: str | None = None,
@@ -173,9 +171,9 @@ class MqttIOStream(IOStream):
         # Set up TLS
         if use_tls:
             if ca_cert_path:
-                self.client.tls_set(ca_cert_path)  # pyright: ignore
+                self.client.tls_set(ca_cert_path)
             else:  # pragma: no cover
-                self.client.tls_set()  # pyright: ignore
+                self.client.tls_set()
 
         # Set up callbacks
         self.client.on_connect = self._on_connect
@@ -320,11 +318,13 @@ class MqttIOStream(IOStream):
             LOG.debug(
                 "Received message on topic %s: %s",
                 msg.topic,
-                msg.payload.decode(),
+                msg.payload.decode("utf-8", errors="replace"),
             )
 
             if msg.topic == self.input_response_topic:  # pragma: no branch
-                self._handle_input_response(msg.payload.decode())
+                self._handle_input_response(
+                    msg.payload.decode("utf-8", errors="replace")
+                )
 
         except Exception as e:  # pragma: no cover
             LOG.error("Error handling message: %s", e)
@@ -396,7 +396,7 @@ class MqttIOStream(IOStream):
 
     def __exit__(
         self,
-        exc_type: Type[Exception] | None,
+        exc_type: type[Exception] | None,
         exc_value: Exception | None,
         traceback: TracebackType | None,
     ) -> None:
@@ -487,23 +487,10 @@ class MqttIOStream(IOStream):
         message : BaseEvent | BaseMessage
             The message or event to send.
         """
-        try:
-            message_dump = message.model_dump(mode="json")
-        except Exception:
-            try:
-                message_dump = message.model_dump(
-                    serialize_as_any=True, mode="json", fallback=str
-                )
-            except Exception as e:
-                message_dump = {
-                    "error": str(e),
-                    "type": message.__class__.__name__,
-                }
-
+        message_dump = get_message_dump(message)
         message_type = message_dump.get("type", None)
         if not message_type:  # pragma: no cover
             message_type = message.__class__.__name__
-
         self._print(
             {
                 "type": message_type,
@@ -652,7 +639,7 @@ class MqttIOStream(IOStream):
     @staticmethod
     def _create_user_response(
         message_data: dict[str, Any],
-    ) -> Optional["UserResponse"]:
+    ) -> UserResponse | None:
         """Create UserResponse object from validated data."""
         try:
             # Handle nested JSON in 'data' field

waldiez/io/redis.py

@@ -4,6 +4,8 @@
 # flake8: noqa: E501
 # pylint: disable=too-many-try-statements,broad-exception-caught
 # pylint: disable=line-too-long,duplicate-code
+# pyright: reportMissingTypeStubs=false,reportUnknownArgumentType=false
+# pyright: reportUnknownMemberType=false
 
 """A Redis I/O stream for handling print and input messages."""
 
@@ -12,16 +14,10 @@ import logging
 import time
 import traceback as tb
 import uuid
+from collections.abc import Awaitable
 from pathlib import Path
 from types import TracebackType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    Optional,
-    Type,
-)
+from typing import TYPE_CHECKING, Any, Callable
 
 try:
     import redis
@@ -60,10 +56,10 @@ class RedisIOStream(IOStream):
     redis: Redis
     task_id: str
     input_timeout: int
-    on_input_request: Optional[Callable[[str, str, str], None]]
-    on_input_received: Optional[Callable[[str, str], None]]
+    on_input_request: Callable[[str, str, str], None] | None
+    on_input_response: Callable[[str, str], None] | None
     max_stream_size: int
-    output_stream: str
+    task_output_stream: str
     input_request_channel: str
     input_response_channel: str
 
@@ -73,8 +69,8 @@ class RedisIOStream(IOStream):
         task_id: str | None = None,
         input_timeout: int = 120,
         max_stream_size: int = 1000,
-        on_input_request: Optional[Callable[[str, str, str], None]] = None,
-        on_input_response: Optional[Callable[[str, str], None]] = None,
+        on_input_request: Callable[[str, str, str], None] | None = None,
+        on_input_response: Callable[[str, str], None] | None = None,
         redis_connection_kwargs: dict[str, Any] | None = None,
         uploads_root: Path | str | None = None,
     ) -> None:
@@ -127,7 +123,7 @@ class RedisIOStream(IOStream):
 
     def __exit__(
         self,
-        exc_type: Type[Exception] | None,
+        exc_type: type[Exception] | None,
         exc_value: Exception | None,
         traceback: TracebackType | None,
     ) -> None:
@@ -165,7 +161,7 @@ class RedisIOStream(IOStream):
         """
         LOG.debug("Sending print message: %s", payload)
         RedisIOStream.try_do(
-            self.redis.xadd,  # pyright: ignore
+            self.redis.xadd,
             self.task_output_stream,
             payload,
             maxlen=self.max_stream_size,
@@ -182,7 +178,7 @@ class RedisIOStream(IOStream):
         """
         LOG.debug("Sending print message: %s", payload)
         RedisIOStream.try_do(
-            self.redis.xadd,  # pyright: ignore
+            self.redis.xadd,
             self.common_output_stream,
             payload,
             maxlen=self.max_stream_size,
@@ -414,7 +410,7 @@ class RedisIOStream(IOStream):
         )
 
     @staticmethod
-    def _extract_message_data(data: Any) -> Optional[dict[str, Any]]:
+    def _extract_message_data(data: Any) -> dict[str, Any] | None:
         """Extract and parse the message data field."""
         message_data = data
 
@@ -431,7 +427,7 @@ class RedisIOStream(IOStream):
             LOG.error("Invalid message data format: %s", message_data)
             return None
 
-        return message_data  # pyright: ignore
+        return message_data  # pyright: ignore[reportUnknownVariableType]
 
     @staticmethod
     def _message_has_required_fields(message_data: dict[str, Any]) -> bool:
@@ -445,7 +441,7 @@ class RedisIOStream(IOStream):
     @staticmethod
     def _process_nested_data(
         message_data: dict[str, Any],
-    ) -> Optional[dict[str, Any]]:
+    ) -> dict[str, Any] | None:
         """Process nested JSON data if present."""
         # Create a copy to avoid modifying the original
         processed_data = message_data.copy()
@@ -467,7 +463,7 @@ class RedisIOStream(IOStream):
     @staticmethod
     def _create_user_response(
         message_data: dict[str, Any],
-    ) -> Optional["UserResponse"]:
+    ) -> UserResponse | None:
         """Create UserResponse object from validated data."""
         try:
             return UserResponse.model_validate(message_data)
@@ -684,7 +680,7 @@ class RedisIOStream(IOStream):
         """
         for key in redis_client.scan_iter("task:*:output", count=100):
             RedisIOStream.try_do(
-                redis_client.xtrim,  # pyright: ignore
+                redis_client.xtrim,
                 key,
                 maxlen=maxlen,
                 approximate=approximate,
@@ -760,7 +756,7 @@ class RedisIOStream(IOStream):
         ):  # pragma: no branch
             before = await redis_client.xlen(key)
             await RedisIOStream.a_try_do(
-                redis_client.xtrim,  # pyright: ignore
+                redis_client.xtrim,
                 key,
                 maxlen=maxlen,
                 approximate=approximate,