waldiez 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

waldiez/__init__.py

@@ -1,17 +1,50 @@
 """Waldiez package."""
 
+import logging
+
 from ._version import __version__
 from .conflict_checker import check_conflicts
 from .exporter import WaldiezExporter
 from .models import Waldiez
 from .runner import WaldiezRunner
 
+
+# pylint: disable=too-few-public-methods
+class FlamlFilter(logging.Filter):
+    """Filter out flaml.automl is not available message."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Filter out flaml.automl is not available message.
+
+        this is just annoying:
+
+        ```
+        flaml.automl is not available.
+        Please install flaml[automl] to enable AutoML functionalities.
+        ```
+
+        Parameters
+        ----------
+        record : logging.LogRecord
+            Log record to filter.
+
+        Returns
+        -------
+        bool
+            Whether to filter out the log record.
+        """
+        return "flaml.automl is not available" not in record.getMessage()
+
+
 # flag to check if ag2 and autogen-agentchat
 # are installed at the same time
 __WALDIEZ_CHECKED_FOR_CONFLICTS = False
+# flag to handle flaml logging
+# suppress the annoying message about flaml.automl
+__WALDIEZ_HANDLED_FLAML_LOGGING = False
 
 
-def _check_conflicts_once() -> None:
+def _check_conflicts() -> None:
     """Check for conflicts once."""
     # pylint: disable=global-statement
     global __WALDIEZ_CHECKED_FOR_CONFLICTS
@@ -20,8 +53,18 @@ def _check_conflicts_once() -> None:
         __WALDIEZ_CHECKED_FOR_CONFLICTS = True
 
 
-_check_conflicts_once()
+def _handle_flaml_logging() -> None:
+    """Handle flaml logging once."""
+    # pylint: disable=global-statement
+    global __WALDIEZ_HANDLED_FLAML_LOGGING
+    if __WALDIEZ_HANDLED_FLAML_LOGGING is False:
+        __WALDIEZ_HANDLED_FLAML_LOGGING = True
+        flam_logger = logging.getLogger("flaml")
+        flam_logger.addFilter(FlamlFilter())
+
 
+_check_conflicts()
+_handle_flaml_logging()
 
 __all__ = [
     "Waldiez",

waldiez/_version.py

@@ -1,3 +1,3 @@
 """Version information for Waldiez."""
 
-__version__ = "0.1.17"
+__version__ = "0.1.19"

waldiez/cli.py

@@ -90,7 +90,7 @@ def run(
             raise typer.Exit(code=1) from error
     waldiez = Waldiez.from_dict(data)
     runner = WaldiezRunner(waldiez)
-    results = runner.run(stream=None, output_path=output_path)
+    results = runner.run(output_path=output_path)
     logger = _get_logger()
     if isinstance(results, list):
         logger.info("Results:")

waldiez/runner.py

@@ -7,16 +7,18 @@ return the results. Before running the flow, any additional environment
 variables specified in the waldiez file are set.
 """
 
+# pylint: disable=import-outside-toplevel,reimported
+
 import datetime
 import importlib.util
 import io
 import os
 import shutil
+import site
 import subprocess  # nosemgrep # nosec
 import sys
 import tempfile
 from contextlib import contextmanager
-from contextvars import ContextVar
 from pathlib import Path
 from types import TracebackType
 from typing import (
@@ -36,8 +38,6 @@ from .models.waldiez import Waldiez
 if TYPE_CHECKING:
     from autogen import ChatResult  # type: ignore
 
-    from .io import WaldiezIOStream
-
 
 @contextmanager
 def _chdir(to: Union[str, Path]) -> Iterator[None]:
@@ -71,10 +71,8 @@ class WaldiezRunner:
         self._waldiez = waldiez
         self._running = False
         self._file_path = file_path
-        self._stream: ContextVar[Optional["WaldiezIOStream"]] = ContextVar(
-            "waldiez_stream", default=None
-        )
         self._exporter = WaldiezExporter(waldiez)
+        self._called_install_requirements = False
 
     @classmethod
     def load(
@@ -136,10 +134,6 @@ class WaldiezRunner:
         """Exit the context manager."""
         if self._running:
             self._running = False
-        token = self._stream.get()
-        if token is not None:
-            self._stream.reset(token)
-            del token
 
     @property
     def waldiez(self) -> Waldiez:
@@ -151,24 +145,15 @@ class WaldiezRunner:
         """Get the running status."""
         return self._running
 
-    def _get_print_function(self) -> Callable[..., None]:
-        """Get the print function."""
-        token = self._stream.get()
-        if token is not None:
-            return token.print
-        return print
-
-    def _install_requirements(self) -> None:
+    def install_requirements(self) -> None:
         """Install the requirements for the flow."""
+        self._called_install_requirements = True
+        printer = get_printer()
         extra_requirements = set(
             req for req in self.waldiez.requirements if req not in sys.modules
         )
         if extra_requirements:
-            print_function = self._get_print_function()
-            # pylint: disable=inconsistent-quotes
-            print_function(
-                f"Installing requirements: {', '.join(extra_requirements)}"
-            )
+            printer(f"Installing requirements: {', '.join(extra_requirements)}")
             pip_install = [sys.executable, "-m", "pip", "install"]
             if not in_virtualenv():
                 pip_install.append("--user")
@@ -180,18 +165,17 @@ class WaldiezRunner:
             ) as proc:
                 if proc.stdout:
                     for line in io.TextIOWrapper(proc.stdout, encoding="utf-8"):
-                        print_function(line.strip())
+                        printer(line.strip())
                 if proc.stderr:
                     for line in io.TextIOWrapper(proc.stderr, encoding="utf-8"):
-                        print_function(line.strip())
-            print_function(
-                "Requirements installed.\n"
-                "NOTE: If new packages were added and you are using Jupyter, "
-                "you might need to restart the kernel."
-            )
+                        printer(line.strip())
+            refresh_environment()
 
+    @staticmethod
     def _after_run(
-        self, temp_dir: Path, output_path: Optional[Union[str, Path]]
+        temp_dir: Path,
+        output_path: Optional[Union[str, Path]],
+        printer: Callable[..., None],
     ) -> None:
         if output_path:
             destination_dir = Path(output_path).parent
@@ -202,9 +186,7 @@ class WaldiezRunner:
             )
             destination_dir.mkdir(parents=True, exist_ok=True)
             # copy the contents of the temp dir to the destination dir
-            self._get_print_function()(
-                f"Copying the results to {destination_dir}"
-            )
+            printer(f"Copying the results to {destination_dir}")
             for item in temp_dir.iterdir():
                 # skip cache files
                 if (
@@ -257,6 +239,16 @@ class WaldiezRunner:
         Union[ChatResult, List[ChatResult]]
             The result(s) of the chat(s).
         """
+        if not self._called_install_requirements:
+            self.install_requirements()
+        else:
+            refresh_environment()
+        printer = get_printer()
+        printer(
+            "Requirements installed.\n"
+            "NOTE: If new packages were added and you are using Jupyter, "
+            "you might need to restart the kernel."
+        )
         results: Union["ChatResult", List["ChatResult"]] = []
         if not uploads_root:
             uploads_root = Path(tempfile.mkdtemp())
@@ -284,32 +276,15 @@ class WaldiezRunner:
             old_vars = self._set_env_vars()
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
-            print_function = self._get_print_function()
-            print_function("Starting workflow...")
+            printer("<Waldiez> - Starting workflow...")
             results = module.main()
             sys.path.pop(0)
             self._reset_env_vars(old_vars)
-        self._after_run(temp_dir, output_path)
+        self._after_run(temp_dir, output_path, printer)
         return results
 
-    def _run(
-        self,
-        output_path: Optional[Union[str, Path]],
-        uploads_root: Optional[Union[str, Path]],
-    ) -> Union["ChatResult", List["ChatResult"]]:
-        self._install_requirements()
-        token = self._stream.get()
-        if token is not None:
-            # pylint: disable=import-outside-toplevel
-            from .io import WaldiezIOStream
-
-            with WaldiezIOStream.set_default(token):
-                return self._do_run(output_path, uploads_root)
-        return self._do_run(output_path, uploads_root)
-
     def run(
         self,
-        stream: Optional["WaldiezIOStream"] = None,
         output_path: Optional[Union[str, Path]] = None,
         uploads_root: Optional[Union[str, Path]] = None,
     ) -> Union["ChatResult", List["ChatResult"]]:
@@ -317,8 +292,6 @@ class WaldiezRunner:
 
         Parameters
         ----------
-        stream : Optional[WaldiezIOStream], optional
-            The stream to use, by default None.
         output_path : Optional[Union[str, Path]], optional
             The output path, by default None.
         uploads_root : Optional[Union[str, Path]], optional
@@ -337,14 +310,11 @@ class WaldiezRunner:
         if self._running is True:
             raise RuntimeError("Workflow already running")
         self._running = True
-        token = self._stream.set(stream)
         file_path = output_path or self._file_path
         try:
-            return self._run(file_path, uploads_root)
+            return self._do_run(file_path, uploads_root)
         finally:
             self._running = False
-            self._stream.reset(token)
-            del token
 
 
 def in_virtualenv() -> bool:
@@ -358,3 +328,37 @@ def in_virtualenv() -> bool:
     return hasattr(sys, "real_prefix") or (
         hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
     )
+
+
+def refresh_environment() -> None:
+    """Refresh the environment."""
+    # backup the default IOStream
+    from autogen.io import IOStream  # type: ignore
+
+    default_io_stream = IOStream.get_default()
+    site.main()
+    # pylint: disable=import-outside-toplevel
+    modules_to_reload = [
+        mod for mod in sys.modules if mod.startswith("autogen")
+    ]
+    for mod in modules_to_reload:
+        del sys.modules[mod]
+    import autogen
+    from autogen.io import IOStream
+
+    importlib.reload(autogen)
+    # restore the default IOStream
+    IOStream.set_global_default(default_io_stream)
+
+
+def get_printer() -> Callable[..., None]:
+    """Get the printer function.
+
+    Returns
+    -------
+    Callable[..., None]
+        The printer function.
+    """
+    from autogen.io import IOStream
+
+    return IOStream.get_default().print

{waldiez-0.1.17.dist-info → waldiez-0.1.19.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: waldiez
-Version: 0.1.17
+Version: 0.1.19
 Summary: waldiez
 Project-URL: homepage, https://waldiez.github.io/waldiez/
 Project-URL: repository, https://github.com/waldiez/waldiez.git
 Author-email: Panagiotis Kasnesis <pkasnesis@thingenious.io>, Lazaros Toumanidis <laztoum@protonmail.com>, Stella Ioannidou <stella@humancentered.gr>
+License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -60,7 +61,7 @@ Requires-Dist: mdx-include==1.4.2; extra == 'docs'
 Requires-Dist: mdx-truly-sane-lists==1.3; extra == 'docs'
 Requires-Dist: mkdocs-jupyter==0.25.1; extra == 'docs'
 Requires-Dist: mkdocs-macros-plugin==1.3.7; extra == 'docs'
-Requires-Dist: mkdocs-material==9.5.48; extra == 'docs'
+Requires-Dist: mkdocs-material==9.5.49; extra == 'docs'
 Requires-Dist: mkdocs-minify-html-plugin==0.2.3; extra == 'docs'
 Requires-Dist: mkdocs==1.6.1; extra == 'docs'
 Requires-Dist: mkdocstrings-python==1.12.2; extra == 'docs'
@@ -88,7 +89,7 @@ To a python script or a jupyter notebook with the corresponding [ag2](https://gi
 
 - Convert .waldiez flows to .py or .ipynb
 - Run a .waldiez flow
-- Provide a custom [IOSStream](https://ag2ai.github.io/ag2/docs/reference/io/base#iostream) to handle input and output.
+- Store the runtime logs of a flow to csv for further analysis
 
 ## Installation
 
@@ -178,73 +179,6 @@ runner = WaldiezRunner.load(flow_path)
 runner.run(output_path=output_path)
 ```
 
-#### Run a flow with a custom IOStream
-
-```python
-# Run the flow with a custom IOStream
-# In case the standard 'input' and 'print' functions cannot be used
-import time
-import threading
-
-from typing import Any
-
-from waldiez import WaldiezRunner
-from waldiez.io import WaldiezIOStream
-
-flow_path = "/path/to/a/flow.waldiez"
-output_path = "/path/to/an/output.py"
-
-
-def custom_print_function(*args: Any, sep: str = " ", **kwargs: Any) -> None:
-    """Custom print function."""
-    print(*args, sep=sep, **kwargs)
-
-
-# Custom input handler
-class InputProcessorWrapper:
-    """Wrapper input processor.
-    
-    To manage the interaction between the custom input processor and IOStream.
-    """
-
-    def __init__(self):
-        self.stream = None  # Placeholder for the WaldiezIOStream instance
-        self.lock = threading.Lock()  # Ensure thread-safe operations
-
-    def custom_input_processor(self, prompt: str) -> None:
-        """Simulate external input and send it back to the IOStream."""
-        def external_input_simulation():
-            with self.lock:  # Ensure thread-safe access
-                time.sleep(2)  # Simulate delay for network input
-                if self.stream:
-                    self.stream.set_input("Simulated external input")
-                else:
-                    raise RuntimeError("Stream reference not set!")
-
-        threading.Thread(target=external_input_simulation, daemon=True).start()
-
-    def set_stream(self, stream: "WaldiezIOStream"):
-        """Set the WaldiezIOStream instance."""
-        with self.lock:  # Ensure thread-safe setting of the stream
-            self.stream = stream
-
-processor_wrapper = InputProcessorWrapper()
-
-stream = WaldiezIOStream(
-    input_timeout=30,
-    print_function=
-    on_prompt_input=processor_wrapper.custom_input_processor,
-)
-
-# Link the processor wrapper to the WaldiezIOStream instance
-processor_wrapper.set_stream(custom_stream)
-
-with WaldiezIOStream.set_default(io_stream):
-    runner = WaldiezRunner.load(flow_path)
-    runner.run(stream=io_stream, output_path=output_path)
-
-```
-
 ### Tools
 
 - [ag2 (formerly AutoGen)](https://github.com/ag2ai/ag2)

{waldiez-0.1.17.dist-info → waldiez-0.1.19.dist-info}/RECORD

@@ -1,11 +1,11 @@
-waldiez/__init__.py,sha256=ASGmxP3JcASIv89_tMYhYxvW0FlHK1jM0Nfb1hMN-z0,722
+waldiez/__init__.py,sha256=9BLMLUURndkGEwnSNF1RXg1XKm4WTYM3cUeuYo-M0qY,1936
 waldiez/__main__.py,sha256=mUQWu4CF03Jbbscvcfb_9EFTnIMliJJJmAuWf0sRRZU,110
-waldiez/_version.py,sha256=JZiuUXn7Efmws1BQsY7xqwPgrly1krkrpN-yh6tNz8s,63
-waldiez/cli.py,sha256=Ayp6Xu2HSBBFIouYh8cArjOjgXv5kbtZd_PYewcDklU,6347
+waldiez/_version.py,sha256=EX_WkICFRi_lmrwAjPX_8gLn_pS_uIsuK3aso-wK5Hk,63
+waldiez/cli.py,sha256=19LFqep8urzcLm6TzVSyJEOKI2Q8XXZbuuFsgV0k9LQ,6334
 waldiez/conflict_checker.py,sha256=E-w0TfTivDAVpNvjd_NSBeaaFsWtWAyxKoSz0-g6x2U,880
 waldiez/exporter.py,sha256=iKe-l_Me8NRWsXHIdBcrOrnLT9XIyp4iYi4HLuuj2jA,9342
 waldiez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-waldiez/runner.py,sha256=v4A4NHdSnh96TQ5Vx1vs8UrTsshc2oAwDZrEHmq4RkU,11537
+waldiez/runner.py,sha256=10GoT27cxEJdrapmQ4ny9aN7ZcnmsNHApzwIft5ZxP0,11220
 waldiez/exporting/__init__.py,sha256=GMY7qTRpNmc7tpaCFNGLT5wX9eu26NvoNPuYX8MzP50,344
 waldiez/exporting/agents/__init__.py,sha256=v5KA112W_EFYwXE2TSBKYyO8rRKUOUAOpFS5CMSnfRs,110
 waldiez/exporting/agents/agent.py,sha256=d2ut2B90-aG4uBRhPWS7B4MKIvSJqQva6DjlXiqleVQ,7513
@@ -39,7 +39,6 @@ waldiez/exporting/utils/method_utils.py,sha256=7-RUMTylNM2W0iM1bPX2_Gn3553XZSl2s
 waldiez/exporting/utils/naming.py,sha256=VdoVODQduhXIs9hQFWUVEVqTaSyNDt7rkECsuIgXYwI,3196
 waldiez/exporting/utils/object_string.py,sha256=2kdIu4in3iUV92a2KbLWwp9POhvY-fzF_r2AGVnCKls,2166
 waldiez/exporting/utils/path_check.py,sha256=aO49sbk6hUHEr65UjNNUSKO5WCGnQitiT733W-kGVtI,1062
-waldiez/io/__init__.py,sha256=-w6ywIjG8ByxGtpSeRt1bjhnP4CZzpHf8WRWckjs4ng,5172
 waldiez/models/__init__.py,sha256=IMq8vzuAgmv92kHSSuZQLF38vVd31ojgOHonuHqWYj0,2888
 waldiez/models/waldiez.py,sha256=yI38WEXPJa-FmRF6Try-MabWoPCeqlxq8VUt0sD-fJg,9428
 waldiez/models/agents/__init__.py,sha256=3ZyVYBHMFzZjRMIdPrBF6HLg82LPAlEubL6utL6KhfU,1856
@@ -85,8 +84,8 @@ waldiez/models/model/model_data.py,sha256=VLPb60rJeZEgVZCjjkQGiwTrKz7OddVLrXCrEu
 waldiez/models/skill/__init__.py,sha256=rU88bajKOGMYoHFcE8MP0jW9H0MswbQmvz5wxS35BYE,169
 waldiez/models/skill/skill.py,sha256=fhsAI413an2_d4DBIkf7dzEuWk6rGs2t4sl97a4dj20,3473
 waldiez/models/skill/skill_data.py,sha256=RTWn8Od6w7g-nRIpsS29sqZ8sPm5dCPiK7-qXmU-KD4,815
-waldiez-0.1.17.dist-info/METADATA,sha256=xfStnh_3pvXf9OU87UM3VMr3l8mchce7g2-OnfCI3mg,10262
-waldiez-0.1.17.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-waldiez-0.1.17.dist-info/entry_points.txt,sha256=9MQ8Y1rD19CU7UwjNPwoyTRpQsPs2QimjrtwTD0bD6k,44
-waldiez-0.1.17.dist-info/licenses/LICENSE,sha256=VQEHM6WMQLRu1qaGl3GWsoOknDwro-69eGo4NLIJPIM,1064
-waldiez-0.1.17.dist-info/RECORD,,
+waldiez-0.1.19.dist-info/METADATA,sha256=w6B5mTtRqZ80Y42gnIU1MbjKtCOWK94WdXKTbhgKpw0,8161
+waldiez-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+waldiez-0.1.19.dist-info/entry_points.txt,sha256=9MQ8Y1rD19CU7UwjNPwoyTRpQsPs2QimjrtwTD0bD6k,44
+waldiez-0.1.19.dist-info/licenses/LICENSE,sha256=VQEHM6WMQLRu1qaGl3GWsoOknDwro-69eGo4NLIJPIM,1064
+waldiez-0.1.19.dist-info/RECORD,,

{waldiez-0.1.17.dist-info → waldiez-0.1.19.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

waldiez/io/__init__.py

@@ -1,142 +0,0 @@
-"""Custom IOStream class to use with autogen.
-
-It is meant to be used when we want to use custom
-`print` and `input`. For example, when a websocket
-is used to trigger a UI element that requires user input.
-and sends back the user's input to the websocket. In the same
-way, we can use it to forward what is meant to be printed.
-"""
-
-import threading
-from typing import Any, Callable, Optional
-
-from autogen.io import IOStream  # type: ignore[import-untyped]
-
-
-class WaldiezIOStream(IOStream):
-    """Custom IOStream class to handle `print` and `input` functions."""
-
-    def __init__(
-        self,
-        input_timeout: float = 60.0,
-        print_function: Optional[Callable[..., None]] = None,
-        on_prompt_input: Optional[Callable[[str], None]] = None,
-    ) -> None:
-        """
-        Initialize the IOStream.
-
-        Parameters
-        ----------
-        input_timeout : float, optional
-            The input timeout in seconds, by default 60.0.
-        print_function : Optional[Callable[..., None]], optional
-            The function to handle print operations, by default None.
-        on_prompt_input : Optional[Callable[[str], None]], optional
-            The function to call for processing input prompts, by default None.
-
-        Notes
-        -----
-        - on_prompt_input: It does not return a string (like 'input' does).
-            Instead, it is meant to be used to forward the prompt somewhere else
-            (e.g., a websocket). When we get the input, we can call
-            `waldiez_io_stream.set_input(input_data)` with the input data.
-        """
-        self.input_timeout = input_timeout  # Timeout for input
-        self.print_function = print_function  # Custom print handler
-        self._on_prompt_input = on_prompt_input  # Custom input prompt handler
-        self.current_input: Optional[str] = None  # Store the current input
-        self._input_event = threading.Event()  # Event to signal input readiness
-        self.allow_input = True  # Flag to allow or block input setting
-
-    def print(
-        self,
-        *objects: Any,
-        sep: str = " ",
-        end: str = "\n",
-        flush: bool = False,
-    ) -> None:
-        """
-        Mock the `print` function.
-
-        Parameters
-        ----------
-        objects : Any
-            The objects to print.
-        sep : str, optional
-            The separator, by default " ".
-        end : str, optional
-            The ending string, by default a new line.
-        flush : bool, optional
-            Whether to flush the output, by default False.
-        """
-        print_function: Callable[..., None] = self.print_function or print
-        print_function(*objects, sep=sep, end=end, flush=flush)
-
-    def input(self, prompt: str = "", *, password: bool = False) -> str:
-        """
-        Mock the `input` function with optional timeout handling.
-
-        Parameters
-        ----------
-        prompt : str, optional
-            The prompt to show, by default "".
-        password : bool, optional
-            Whether to hide the input as password (not used), by default False.
-
-        Returns
-        -------
-        str
-            The user's input or '\n' if timeout occurs.
-        """
-        _prompt = prompt or "Your input:"
-        if _prompt in (">", "> "):  # pragma: no cover
-            _prompt = "Your input:"
-        if prompt:
-            if self._on_prompt_input:
-                self._on_prompt_input(_prompt)
-            self.print(_prompt, end="")
-
-        # Only reset if no input is currently set
-        # e.g. handle the case when we call set_input(..) before input(..)
-        already_set = self._input_event.is_set()
-        if not self._input_event.is_set():
-            self.current_input = None  # Reset previous input
-            self._input_event.clear()  # Clear the event before waiting
-
-        # Wait for input or timeout
-        if not self._input_event.wait(self.input_timeout):
-            # Timeout occurred, return what we have so far
-            to_return = (
-                self.current_input if self.current_input is not None else "\n"
-            )
-            self.current_input = None
-            self._input_event.clear()
-            # if we had already set the input, return it
-            return to_return if already_set else "\n"
-
-        # Input is ready, return it
-        to_return = (
-            self.current_input if self.current_input is not None else "\n"
-        )
-        self.current_input = None
-        self._input_event.clear()  # Clear the event after waiting
-        return to_return
-
-    def set_input(self, value: str) -> None:
-        """
-        Set the input value and signal that input is ready.
-
-        Parameters
-        ----------
-        value : str
-            The value to set as input.
-        """
-        if self.allow_input:  # Respect the allow_input flag
-            self.current_input = value
-            self._input_event.set()  # Signal that input is ready
-
-    def reset_state(self) -> None:
-        """Reset the IOStream state for testing."""
-        self.current_input = None
-        self._input_event.clear()
-        self.allow_input = True  # Re-enable input setting