feat: redesigned protocol

.github/linters/.mypy.ini

@@ -2,3 +2,4 @@
 disallow_incomplete_defs = true
 disallow_untyped_defs = true
 ignore_missing_imports = true
+plugins = pydantic.mypy

pyproject.toml

@@ -17,18 +17,18 @@ safe-ds-runner = "safeds_runner.main:main"
 
 [tool.poetry.dependencies]
 python = "^3.11,<3.13"
-safe-ds = ">=0.22.1,<0.23"
-hypercorn = "^0.16.0"
 psutil = "^5.9.8"
 pydantic = "^2.7.0"
-quart = "^0.19.4"
+python-socketio = "^5.11.2"
+safe-ds = ">=0.22.1,<0.23"
+uvicorn = "^0.29.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^8.2.0"
+pytest-asyncio = "^0.23.6"
 pytest-cov = "^5.0.0"
 pytest-timeout = "^2.3.1"
-pytest-asyncio = "^0.23.6"
-simple-websocket = "^1.0.0"
+python-socketio = {extras = ["asyncio-client"], version = "^5.11.2"}
 torch = [
     # Install the CUDA version on Windows. Projects that depend on us always get their dependencies from PyPI, so
     # there's no point moving this to the main dependencies section.
@@ -58,3 +58,6 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.black]
 line-length = 120
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

src/safeds_runner/__init__.py

@@ -1,17 +1,23 @@
 """A runner for the Python code generated from Safe-DS programs."""
 
-from .server._pipeline_manager import (
+from .interface._files import (
     absolute_path,
     file_mtime,
+)
+from .interface._memoization import (
     memoized_dynamic_call,
     memoized_static_call,
-    save_placeholder,
+)
+from .interface._reporters import (
+    report_placeholder_computed,
+    report_placeholder_value,
 )
 
 __all__ = [
     "absolute_path",
     "file_mtime",
     "memoized_static_call",
     "memoized_dynamic_call",
-    "save_placeholder",
+    "report_placeholder_computed",
+    "report_placeholder_value",
 ]

src/safeds_runner/interface/__init__.py

@@ -0,0 +1 @@
+"""Functions that can be called in generated code."""

src/safeds_runner/interface/_files.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import typing
+from pathlib import Path
+
+
+@typing.overload
+def file_mtime(filenames: str) -> int | None: ...
+
+
+@typing.overload
+def file_mtime(filenames: list[str]) -> list[int | None]: ...
+
+
+def file_mtime(filenames: str | list[str]) -> int | None | list[int | None]:
+    """
+    Get the last modification timestamp of the provided file.
+
+    Parameters
+    ----------
+    filenames:
+        Names of the files.
+
+    Returns
+    -------
+    timestamps:
+        Last modification timestamp or None for each provided file, depending on whether the file exists or not.
+    """
+    if isinstance(filenames, list):
+        return [file_mtime(f) for f in filenames]
+
+    try:
+        return Path(filenames).stat().st_mtime_ns
+    except FileNotFoundError:
+        return None
+
+
+@typing.overload
+def absolute_path(filenames: str) -> str: ...
+
+
+@typing.overload
+def absolute_path(filenames: list[str]) -> list[str]: ...
+
+
+def absolute_path(filenames: str | list[str]) -> str | list[str]:
+    """
+    Get the absolute path of the provided file.
+
+    Parameters
+    ----------
+    filenames:
+        Names of the files.
+
+    Returns
+    -------
+    absolute_paths:
+        Absolute paths of the provided files.
+    """
+    if isinstance(filenames, list):
+        return [absolute_path(f) for f in filenames]
+
+    return str(Path(filenames).resolve())

src/safeds_runner/interface/_memoization.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import typing
+from typing import Any
+
+from safeds_runner.server._pipeline_manager import get_current_pipeline_process
+
+
+def memoized_static_call(
+    fully_qualified_function_name: str,
+    callable_: typing.Callable,
+    positional_arguments: list[Any],
+    keyword_arguments: dict[str, Any],
+    hidden_arguments: list[Any],
+) -> Any:
+    """
+    Call a function that can be memoized and save the result.
+
+    If a function has been previously memoized, the previous result may be reused.
+
+    Parameters
+    ----------
+    fully_qualified_function_name:
+        Fully qualified function name.
+    callable_:
+        Function that is called and memoized if the result was not found in the memoization map.
+    positional_arguments:
+        List of positions arguments for the function.
+    keyword_arguments:
+        Dictionary of keyword arguments for the function.
+    hidden_arguments:
+        List of hidden arguments for the function. This is used for memoizing some impure functions.
+
+    Returns
+    -------
+    result:
+        The result of the specified function, if any exists.
+    """
+    current_pipeline = get_current_pipeline_process()
+    if current_pipeline is None:
+        return None  # pragma: no cover
+
+    memoization_map = current_pipeline.get_memoization_map()
+    return memoization_map.memoized_function_call(
+        fully_qualified_function_name,
+        callable_,
+        positional_arguments,
+        keyword_arguments,
+        hidden_arguments,
+    )
+
+
+def memoized_dynamic_call(
+    receiver: Any,
+    function_name: str,
+    positional_arguments: list[Any],
+    keyword_arguments: dict[str, Any],
+    hidden_arguments: list[Any],
+) -> Any:
+    """
+    Dynamically call a function that can be memoized and save the result.
+
+    If a function has been previously memoized, the previous result may be reused. Dynamic calling in this context
+    means, the function name will be used to look up the function on the instance passed as receiver.
+
+    Parameters
+    ----------
+    receiver : Any
+        Instance the function should be called on.
+    function_name:
+        Simple function name.
+    positional_arguments:
+        List of positions arguments for the function.
+    keyword_arguments:
+        Dictionary of keyword arguments for the function.
+    hidden_arguments:
+        List of hidden parameters for the function. This is used for memoizing some impure functions.
+
+    Returns
+    -------
+    result:
+        The result of the specified function, if any exists.
+    """
+    current_pipeline = get_current_pipeline_process()
+    if current_pipeline is None:
+        return None  # pragma: no cover
+
+    fully_qualified_function_name = (
+        receiver.__class__.__module__ + "." + receiver.__class__.__qualname__ + "." + function_name
+    )
+
+    member = getattr(receiver, function_name)
+    callable_ = member.__func__
+
+    memoization_map = get_current_pipeline_process().get_memoization_map()
+    return memoization_map.memoized_function_call(
+        fully_qualified_function_name,
+        callable_,
+        [receiver, *positional_arguments],
+        keyword_arguments,
+        hidden_arguments,
+    )

src/safeds_runner/interface/_reporters.py

@@ -0,0 +1,67 @@
+from typing import Any
+
+from safeds_runner.server._pipeline_manager import get_current_pipeline_process
+from safeds_runner.server.messages._from_server import create_placeholder_value_message, create_progress_message
+from safeds_runner.utils._get_type_name import get_type_name
+from safeds_runner.utils._make_value_json_serializable import make_value_json_serializable
+
+
+def report_placeholder_computed(placeholder_name: str) -> None:
+    """
+    Report that a placeholder has been computed.
+
+    Parameters
+    ----------
+    placeholder_name:
+        Name of the placeholder.
+    """
+    current_pipeline = get_current_pipeline_process()
+    if current_pipeline is None:
+        return  # pragma: no cover
+
+    current_pipeline.send_message(
+        create_progress_message(
+            run_id=current_pipeline._payload.run_id,
+            placeholder_name=placeholder_name,
+            percentage=100,
+        ),
+    )
+
+
+def report_placeholder_value(placeholder_name: str, value: Any) -> None:
+    """
+    Report the value of a placeholder.
+
+    Parameters
+    ----------
+    placeholder_name:
+        Name of the placeholder.
+    value:
+        Value of the placeholder.
+    """
+    current_pipeline = get_current_pipeline_process()
+    if current_pipeline is None:
+        return  # pragma: no cover
+
+    # Also send a progress message
+    current_pipeline.send_message(
+        create_progress_message(
+            run_id=current_pipeline._payload.run_id,
+            placeholder_name=placeholder_name,
+            percentage=100,
+        ),
+    )
+
+    # Send the actual value
+    requested_table_window = current_pipeline._payload.table_window
+    serialized_value, chosen_window = make_value_json_serializable(value, requested_table_window)
+
+    current_pipeline.send_message(
+        create_placeholder_value_message(
+            run_id=current_pipeline._payload.run_id,
+            placeholder_name=placeholder_name,
+            value=serialized_value,
+            type_=get_type_name(value),
+            window=chosen_window,
+        ),
+    )