h3cx
207a91811e
Derived units now use a DLUnit class similar to a DLPak to be easily stored and loaded, the public API has been updated to either take a DLUnit object or a Path where it reads the DLUnit from a *.dlunit file The .dlunit file is a ZIP compressed archive containing two files, a manifest.json which stores the units uuid, its input signals and its output signal, and unit.py which is the python code for the unit, the same rules apply (one python function with a specifically structured signature) as when a string was passed in the old API Errors have been added to have a DLUnitError similar to the DLPakError as the DLUnit class is heavily inspired from the DLPak architecutre Logging may still be primitive, this will be covered in the next AI logging sweep to homogenize and clean up the logging aspect of things
151 lines
4.6 KiB
Python
151 lines
4.6 KiB
Python
from datetime import datetime, timezone
|
|
from queue import Queue
|
|
from uuid import uuid4
|
|
from zipfile import BadZipFile
|
|
|
|
import pytest
|
|
|
|
from dynalab_core.buffer import ValueBuffer
|
|
from dynalab_core.derive import DeriveRegistry, DeriveUnit
|
|
from dynalab_core.dlpak import DLPak
|
|
from dynalab_core.dlunit import DLUnit
|
|
from dynalab_core.errors import (
|
|
CoreError,
|
|
DLPakError,
|
|
DeriveError,
|
|
DynaLabError,
|
|
PlaybackError,
|
|
)
|
|
from dynalab_core.playback import PlaybackEngine
|
|
from dynalab_core.protocols.packets.data import ValueDescriptor
|
|
from dynalab_core.protocols.packets.handshake import SignalDescriptor
|
|
|
|
|
|
def _identity(
|
|
value: ValueDescriptor, output: SignalDescriptor
|
|
) -> ValueDescriptor:
|
|
return ValueDescriptor(
|
|
signal_id=output.id,
|
|
value=value.value,
|
|
timestamp=value.timestamp,
|
|
)
|
|
|
|
|
|
def test_subsystem_errors_share_public_base_and_code() -> None:
|
|
error = PlaybackError("Playback data is unavailable", code="no_data")
|
|
|
|
assert isinstance(error, DynaLabError)
|
|
assert error.code == "no_data"
|
|
assert str(error) == "Playback data is unavailable"
|
|
|
|
|
|
def test_core_rejects_invalid_mode_and_missing_recording() -> None:
|
|
from dynalab_core import Core
|
|
|
|
core = Core.__new__(Core)
|
|
core._processing_buffer = None
|
|
|
|
with pytest.raises(CoreError, match="Unknown core mode") as mode:
|
|
core.set_mode("invalid") # type: ignore[arg-type]
|
|
with pytest.raises(CoreError, match="no recording") as recording:
|
|
core.write(".", "unused")
|
|
|
|
assert mode.value.code == "invalid_mode"
|
|
assert recording.value.code == "no_recording"
|
|
|
|
|
|
def test_dlpak_requires_data_before_manifest() -> None:
|
|
package = DLPak()
|
|
|
|
with pytest.raises(DLPakError, match="before setting its data") as raised:
|
|
package.set_manifest(datetime.now(timezone.utc), [])
|
|
|
|
assert raised.value.code == "no_data"
|
|
|
|
|
|
def test_dlpak_wraps_archive_read_failures(tmp_path) -> None:
|
|
invalid_archive = tmp_path / "invalid.dlpak"
|
|
invalid_archive.write_text("not a zip archive")
|
|
|
|
with pytest.raises(DLPakError, match="Could not read") as raised:
|
|
DLPak().read(invalid_archive)
|
|
|
|
assert raised.value.code == "read_failed"
|
|
assert isinstance(raised.value.__cause__, BadZipFile)
|
|
|
|
|
|
def test_derive_unit_reports_argument_mismatch() -> None:
|
|
input_signal = SignalDescriptor(id=uuid4(), name="Input", type="number")
|
|
output_signal = SignalDescriptor(
|
|
id=uuid4(), name="Output", type="number", origin="derived"
|
|
)
|
|
unit = DeriveUnit(uuid4(), _identity, [input_signal], output_signal, Queue())
|
|
|
|
try:
|
|
with pytest.raises(DeriveError, match="expected 1 input") as raised:
|
|
unit.process_offline([])
|
|
finally:
|
|
unit.stop()
|
|
|
|
assert raised.value.code == "argument_mismatch"
|
|
|
|
|
|
def test_derive_registry_wraps_invalid_source() -> None:
|
|
registry = DeriveRegistry(Queue(), lambda signal_id: None)
|
|
output_signal = SignalDescriptor(
|
|
id=uuid4(), name="Output", type="number", origin="derived"
|
|
)
|
|
|
|
try:
|
|
with pytest.raises(DeriveError, match="Could not load") as raised:
|
|
dlunit = DLUnit()
|
|
dlunit.set_manifest(uuid4(), [], output_signal)
|
|
dlunit.set_data("def broken(")
|
|
registry.register(dlunit)
|
|
finally:
|
|
registry.stop()
|
|
|
|
assert raised.value.code == "invalid_source"
|
|
assert isinstance(raised.value.__cause__, SyntaxError)
|
|
|
|
|
|
def test_derive_unit_rejects_configured_input_mismatch() -> None:
|
|
output_signal = SignalDescriptor(
|
|
id=uuid4(), name="Output", type="number", origin="derived"
|
|
)
|
|
|
|
with pytest.raises(DeriveError, match="input signal") as raised:
|
|
DeriveUnit(uuid4(), _identity, [], output_signal, Queue())
|
|
|
|
assert raised.value.code == "input_signal_mismatch"
|
|
|
|
|
|
def test_playback_rejects_incomplete_data_and_negative_seek() -> None:
|
|
engine = PlaybackEngine(Queue())
|
|
|
|
try:
|
|
with pytest.raises(PlaybackError, match="incomplete") as incomplete:
|
|
engine.set_data(DLPak())
|
|
with pytest.raises(PlaybackError, match="cannot be negative") as timestamp:
|
|
engine.seek(-1)
|
|
finally:
|
|
engine.stop()
|
|
|
|
assert incomplete.value.code == "incomplete_data"
|
|
assert timestamp.value.code == "invalid_timestamp"
|
|
|
|
|
|
def test_playback_accepts_complete_dlpak() -> None:
|
|
signal = SignalDescriptor(id=uuid4(), name="Input", type="number")
|
|
data = ValueBuffer()
|
|
data.append(1, signal.id, 2.0)
|
|
package = DLPak()
|
|
package.set_data(data)
|
|
package.set_manifest(datetime.now(timezone.utc), [signal])
|
|
engine = PlaybackEngine(Queue())
|
|
|
|
try:
|
|
engine.set_data(package)
|
|
finally:
|
|
engine.stop()
|