From f5eb8037e16a1c7282c2c34d7eb750a49a9837fb Mon Sep 17 00:00:00 2001 From: Gary Yendell Date: Thu, 12 Mar 2026 11:06:57 +0000 Subject: [PATCH] Add odin detector tutorial --- README.md | 13 + docs/snippets/odin01.py | 14 ++ docs/snippets/odin02.py | 19 ++ docs/snippets/odin03.py | 29 +++ docs/snippets/odin04.py | 31 +++ docs/snippets/odin05.py | 48 ++++ docs/snippets/odin06.py | 87 +++++++ docs/snippets/odin07.py | 101 ++++++++ docs/snippets/odin08.py | 118 +++++++++ docs/snippets/odin09.py | 120 +++++++++ docs/snippets/odin10.py | 138 +++++++++++ docs/snippets/odin11.py | 142 +++++++++++ docs/snippets/odin12.py | 147 +++++++++++ docs/tutorials/odin-detector.md | 419 ++++++++++++++++++++++++++++++++ pyproject.toml | 5 +- tests/test_docs_snippets.py | 9 + uv.lock | 144 +++++++++++ 17 files changed, 1583 insertions(+), 1 deletion(-) create mode 100644 docs/snippets/odin01.py create mode 100644 docs/snippets/odin02.py create mode 100644 docs/snippets/odin03.py create mode 100644 docs/snippets/odin04.py create mode 100644 docs/snippets/odin05.py create mode 100644 docs/snippets/odin06.py create mode 100644 docs/snippets/odin07.py create mode 100644 docs/snippets/odin08.py create mode 100644 docs/snippets/odin09.py create mode 100644 docs/snippets/odin10.py create mode 100644 docs/snippets/odin11.py create mode 100644 docs/snippets/odin12.py create mode 100644 docs/tutorials/odin-detector.md create mode 100644 tests/test_docs_snippets.py diff --git a/README.md b/README.md index 88d6d39..eeb4523 100644 --- a/README.md +++ b/README.md @@ -80,6 +80,19 @@ To run local versions of odin-data / odin-control python applications install it the virtual environment with `$ pip install -e ...` to override the versions installed from GitHub. +#### Odin Data Example + +Another option is to run an odin deployment and open the fastcs-odin devcontainer in +isolation. Detector repositories provide container images and dev deployments, such as +the [odin-data-example](https://github.com/odin-detector/odin-data-example): + +``` +podman run --rm -it ghcr.io/odin-detector/odin-data-example-runtime +``` + +This deployment will host an odin server that the default fastcs-odin `Odin IOC` launch +config will connect to. + ### Isolated Development Environment While it is necessary to work on odin-control / odin-data alongside fastcs-odin in some diff --git a/docs/snippets/odin01.py b/docs/snippets/odin01.py new file mode 100644 index 0000000..867fe68 --- /dev/null +++ b/docs/snippets/odin01.py @@ -0,0 +1,14 @@ +from fastcs.attributes import AttrRW +from fastcs.control_system import FastCS +from fastcs.controllers import Controller +from fastcs.datatypes import Int + + +class ExampleOdinController(Controller): + foo = AttrRW(Int()) + + +fastcs = FastCS(ExampleOdinController(), []) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin02.py b/docs/snippets/odin02.py new file mode 100644 index 0000000..0f23269 --- /dev/null +++ b/docs/snippets/odin02.py @@ -0,0 +1,19 @@ +from fastcs.attributes import AttrRW +from fastcs.control_system import FastCS +from fastcs.controllers import Controller +from fastcs.datatypes import Int +from fastcs.transports.epics import EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + + +class ExampleOdinController(Controller): + foo = AttrRW(Int()) + + +fastcs = FastCS( + ExampleOdinController(), + [EpicsCATransport(EpicsIOCOptions(pv_prefix="EXAMPLE"))], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin03.py b/docs/snippets/odin03.py new file mode 100644 index 0000000..2dc9baa --- /dev/null +++ b/docs/snippets/odin03.py @@ -0,0 +1,29 @@ +from pathlib import Path + +from fastcs.attributes import AttrRW +from fastcs.control_system import FastCS +from fastcs.controllers import Controller +from fastcs.datatypes import Int +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + + +class ExampleOdinController(Controller): + foo = AttrRW(Int()) + + +fastcs = FastCS( + ExampleOdinController(), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin04.py b/docs/snippets/odin04.py new file mode 100644 index 0000000..82cfc2e --- /dev/null +++ b/docs/snippets/odin04.py @@ -0,0 +1,31 @@ +from pathlib import Path + +from fastcs.attributes import AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.datatypes import Int +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController + + +class ExampleOdinController(OdinController): + foo = AttrRW(Int()) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin05.py b/docs/snippets/odin05.py new file mode 100644 index 0000000..2b47e3f --- /dev/null +++ b/docs/snippets/odin05.py @@ -0,0 +1,48 @@ +from pathlib import Path + +from fastcs.attributes import AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.datatypes import Int, String +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef + + +class ExampleOdinController(OdinController): + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin06.py b/docs/snippets/odin06.py new file mode 100644 index 0000000..2f1f4eb --- /dev/null +++ b/docs/snippets/odin06.py @@ -0,0 +1,87 @@ +from pathlib import Path + +from fastcs.attributes import AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Int, String +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin07.py b/docs/snippets/odin07.py new file mode 100644 index 0000000..a15cad3 --- /dev/null +++ b/docs/snippets/odin07.py @@ -0,0 +1,101 @@ +from pathlib import Path + +from fastcs.attributes import AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Int, String +from fastcs.methods import Command, command +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + @command() + async def acquire(self): + await self.FP.start_writing() + await self.DETECTOR.start() + + @command() + async def stop(self): + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin08.py b/docs/snippets/odin08.py new file mode 100644 index 0000000..5148371 --- /dev/null +++ b/docs/snippets/odin08.py @@ -0,0 +1,118 @@ +from pathlib import Path + +from fastcs.attributes import AttrR, AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Bool, Int, String +from fastcs.methods import Command, command +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.io.status_summary_attribute_io import StatusSummaryAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + status_acquiring: AttrR[bool] + status_frames: AttrR[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + @command() + async def acquire(self): + await self.FP.start_writing() + await self.DETECTOR.start() + + @command() + async def stop(self): + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + self.acquiring = AttrR( + Bool(), + io_ref=StatusSummaryAttributeIORef( + [], "", any, [self.FP.writing, self.DETECTOR.status_acquiring] + ), + ) + self.frames_captured = AttrR( + Int(), + io_ref=StatusSummaryAttributeIORef( + [], "", min, [self.DETECTOR.status_frames, self.FP.frames_written] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin09.py b/docs/snippets/odin09.py new file mode 100644 index 0000000..faeefba --- /dev/null +++ b/docs/snippets/odin09.py @@ -0,0 +1,120 @@ +from pathlib import Path + +from fastcs.attributes import AttrR, AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Bool, Int, String +from fastcs.methods import Command, command +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.io.status_summary_attribute_io import StatusSummaryAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + status_acquiring: AttrR[bool] + status_frames: AttrR[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + @command() + async def acquire(self): + await self.FP.start_writing() + await self.FP.writing.wait_for_value(True, timeout=1) + + await self.DETECTOR.start() + + @command() + async def stop(self): + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + self.acquiring = AttrR( + Bool(), + io_ref=StatusSummaryAttributeIORef( + [], "", any, [self.FP.writing, self.DETECTOR.status_acquiring] + ), + ) + self.frames_captured = AttrR( + Int(), + io_ref=StatusSummaryAttributeIORef( + [], "", min, [self.DETECTOR.status_frames, self.FP.frames_written] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin10.py b/docs/snippets/odin10.py new file mode 100644 index 0000000..610eb97 --- /dev/null +++ b/docs/snippets/odin10.py @@ -0,0 +1,138 @@ +from io import BytesIO +from pathlib import Path + +import numpy as np +from fastcs.attributes import AttrR, AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Bool, Int, String, Waveform +from fastcs.methods import Command, command, scan +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport +from PIL import Image + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.io.status_summary_attribute_io import StatusSummaryAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + status_acquiring: AttrR[bool] + status_frames: AttrR[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + live_view_image = AttrR(Waveform("uint8", shape=(256, 256))) + + @scan(1) + async def monitor_live_view(self): + response, image_bytes = await self.connection.get_bytes( + f"{self.API_PREFIX}/live/image" + ) + + if response.status != 200: + return + + image = Image.open(BytesIO(image_bytes)) + numpy_array = np.asarray(image) + await self.live_view_image.update(numpy_array[:, :, 0]) + + @command() + async def acquire(self): + await self.FP.start_writing() + await self.FP.writing.wait_for_value(True, timeout=1) + + await self.DETECTOR.start() + + @command() + async def stop(self): + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + self.acquiring = AttrR( + Bool(), + io_ref=StatusSummaryAttributeIORef( + [], "", any, [self.FP.writing, self.DETECTOR.status_acquiring] + ), + ) + self.frames_captured = AttrR( + Int(), + io_ref=StatusSummaryAttributeIORef( + [], "", min, [self.DETECTOR.status_frames, self.FP.frames_written] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ) + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin11.py b/docs/snippets/odin11.py new file mode 100644 index 0000000..3ddc759 --- /dev/null +++ b/docs/snippets/odin11.py @@ -0,0 +1,142 @@ +from io import BytesIO +from pathlib import Path + +import numpy as np +from fastcs.attributes import AttrR, AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Bool, Int, String, Waveform +from fastcs.methods import Command, command, scan +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport +from fastcs.transports.epics.pva.transport import EpicsPVATransport +from PIL import Image + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.io.status_summary_attribute_io import StatusSummaryAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + status_acquiring: AttrR[bool] + status_frames: AttrR[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + live_view_image = AttrR(Waveform("uint8", shape=(256, 256))) + + @scan(1) + async def monitor_live_view(self): + response, image_bytes = await self.connection.get_bytes( + f"{self.API_PREFIX}/live/image" + ) + + if response.status != 200: + return + + image = Image.open(BytesIO(image_bytes)) + numpy_array = np.asarray(image) + await self.live_view_image.update(numpy_array[:, :, 0]) + + @command() + async def acquire(self): + await self.FP.start_writing() + await self.FP.writing.wait_for_value(True, timeout=1) + + await self.DETECTOR.start() + + @command() + async def stop(self): + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + self.acquiring = AttrR( + Bool(), + io_ref=StatusSummaryAttributeIORef( + [], "", any, [self.FP.writing, self.DETECTOR.status_acquiring] + ), + ) + self.frames_captured = AttrR( + Int(), + io_ref=StatusSummaryAttributeIORef( + [], "", min, [self.DETECTOR.status_frames, self.FP.frames_written] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + ), + EpicsPVATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ), + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/snippets/odin12.py b/docs/snippets/odin12.py new file mode 100644 index 0000000..3ef0e52 --- /dev/null +++ b/docs/snippets/odin12.py @@ -0,0 +1,147 @@ +from io import BytesIO +from pathlib import Path + +import numpy as np +from fastcs.attributes import AttrR, AttrRW +from fastcs.connections import IPConnectionSettings +from fastcs.control_system import FastCS +from fastcs.controllers import BaseController +from fastcs.datatypes import Bool, Int, String, Waveform +from fastcs.logging import LogLevel, configure_logging, logger +from fastcs.methods import Command, command, scan +from fastcs.transports.epics import EpicsGUIOptions, EpicsIOCOptions +from fastcs.transports.epics.ca.transport import EpicsCATransport +from fastcs.transports.epics.pva.transport import EpicsPVATransport +from PIL import Image + +from fastcs_odin.controllers import OdinController +from fastcs_odin.controllers.odin_adapter_controller import OdinAdapterController +from fastcs_odin.controllers.odin_data.frame_processor import ( + FrameProcessorAdapterController, +) +from fastcs_odin.http_connection import HTTPConnection +from fastcs_odin.io.config_fan_sender_attribute_io import ConfigFanAttributeIORef +from fastcs_odin.io.status_summary_attribute_io import StatusSummaryAttributeIORef +from fastcs_odin.util import OdinParameter + + +class ExampleFrameProcessorAdapterController(FrameProcessorAdapterController): + frames: AttrRW[int] + + +class ExampleDetectorAdapterController(OdinAdapterController): + config_frames: AttrRW[int] + + status_acquiring: AttrR[bool] + status_frames: AttrR[int] + + start: Command + stop: Command + + +class ExampleOdinController(OdinController): + FP: ExampleFrameProcessorAdapterController + DETECTOR: ExampleDetectorAdapterController + + live_view_image = AttrR(Waveform("uint8", shape=(256, 256))) + + @scan(1) + async def monitor_live_view(self): + response, image_bytes = await self.connection.get_bytes( + f"{self.API_PREFIX}/live/image" + ) + + if response.status != 200: + return + + image = Image.open(BytesIO(image_bytes)) + numpy_array = np.asarray(image) + await self.live_view_image.update(numpy_array[:, :, 0]) + + @command() + async def acquire(self): + logger.info("Starting writing") + await self.FP.start_writing() + await self.FP.writing.wait_for_value(True, timeout=1) + + await self.DETECTOR.start() + + @command() + async def stop(self): + logger.info("Stopping writing") + await self.FP.stop_writing() + await self.DETECTOR.stop() + + async def initialise(self): + await super().initialise() + + self.file_path = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_path]), + ) + self.file_prefix = AttrRW( + String(), + io_ref=ConfigFanAttributeIORef([self.FP.file_prefix]), + ) + self.frames = AttrRW( + Int(), + io_ref=ConfigFanAttributeIORef( + [self.FP.frames, self.DETECTOR.config_frames] + ), + ) + + self.acquiring = AttrR( + Bool(), + io_ref=StatusSummaryAttributeIORef( + [], "", any, [self.FP.writing, self.DETECTOR.status_acquiring] + ), + ) + self.frames_captured = AttrR( + Int(), + io_ref=StatusSummaryAttributeIORef( + [], "", min, [self.DETECTOR.status_frames, self.FP.frames_written] + ), + ) + + def _create_adapter_controller( + self, + connection: HTTPConnection, + parameters: list[OdinParameter], + adapter: str, + module: str, + ) -> BaseController: + match module: + case "ExampleDetectorAdapter": + return ExampleDetectorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case "FrameProcessorAdapter": + return ExampleFrameProcessorAdapterController( + connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios + ) + case _: + return super()._create_adapter_controller( + connection, parameters, adapter, module + ) + + +configure_logging(LogLevel.TRACE) + +fastcs = FastCS( + ExampleOdinController(IPConnectionSettings("127.0.0.1", 8888)), + [ + EpicsCATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + ), + EpicsPVATransport( + EpicsIOCOptions(pv_prefix="EXAMPLE"), + gui=EpicsGUIOptions( + output_path=Path.cwd() / "opis" / "example.bob", + title="Odin Example Detector", + ), + ), + ], +) + +if __name__ == "__main__": + fastcs.run() diff --git a/docs/tutorials/odin-detector.md b/docs/tutorials/odin-detector.md new file mode 100644 index 0000000..1d2adf0 --- /dev/null +++ b/docs/tutorials/odin-detector.md @@ -0,0 +1,419 @@ +# Creating an Odin Detector Driver + +## Introduction + +This tutorial walks through creating a FastCS driver for a detector controlled by +[Odin](https://github.com/odin-detector). The +`fastcs-odin` package builds on FastCS to provide an `OdinController` that introspects +an Odin server and creates sub controllers and attributes for each adapter it finds. + +This tutorial will walk through the creation of a driver that can: + +- Introspect an Odin deployment and expose all parameters as PVs +- Configure and run detector acquisitions from a single top-level API +- Display a live view of captured frames +- Use logging and tracing to debug the data path + +## Set Up + +### Odin Deployment + +The odin-data-example deployment container should be started: + +```bash +docker run --rm -it --security-opt label=disable \ + -v /dev/shm:/dev/shm -v /tmp:/tmp --net=host \ + ghcr.io/odin-detector/odin-data-example-runtime:0.2.3 +``` + +All applications should start without errors. + +### Python Environment + +Clone [fastcs-odin](https://github.com/DiamondLightSource/fastcs-odin) and open it in +VS Code. Reopen in the dev container and install the dependencies: + +```bash +pip install 'fastcs[epics]' pillow aioca +``` + +An `example.py` file should be created in the project root. + +### Phoebus + +A [Phoebus container](https://github.com/epics-containers/ec-phoebus) should be started. +A settings file will likely be needed to configure name servers for both PVA and CA. + +## A Minimal Controller + +The core of a FastCS device driver is the `Controller`. An `ExampleOdinController` +should be created that inherits from `Controller` with a single read-write integer +attribute, and launched with `FastCS`. + +::::{admonition} Code 1 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin01.py +::: + +:::: + +The application will start and drop into an interactive shell. The attribute can be read +and written from the shell: + +``` +In [1]: controller.foo.get() +Out[1]: 0 + +In [2]: await controller.foo.put(1) + +In [3]: controller.foo.get() +Out[3]: 1 +``` + +:::{note} +There is also a helper if there are errors about running on the wrong event loop: +```python +run(controller.foo.put(1)) +``` +::: + +## Adding an EPICS Transport + +An EPICS CA transport can be added to expose the controller's attributes as PVs. The PV +prefix should be unique. + +::::{admonition} Code 2 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin02.py +:emphasize-lines: 5,6,15 +::: + +:::: + +The IOC will now be serving PVs. They can be listed in the interactive shell and +interacted with from a terminal: + +``` +In [1]: dbl() +EXAMPLE:Foo_RBV +EXAMPLE:Foo +EXAMPLE:PVI_PV +``` + +```bash +❯ caget EXAMPLE:Foo_RBV +EXAMPLE:Foo_RBV 1 +❯ caput EXAMPLE:Foo 5 +Old : EXAMPLE:Foo 1 +New : EXAMPLE:Foo 5 +❯ caget EXAMPLE:Foo_RBV +EXAMPLE:Foo_RBV 5 +``` + +## Generating a Phoebus UI + +FastCS can be configured to generate a Phoebus `.bob` file for a UI. + +::::{admonition} Code 3 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin03.py +:emphasize-lines: 1,7,20-22 +::: + +:::: + +`opis/example.bob` should appear and can be opened in Phoebus with +File > Open > example.bob. Values can be set from the UI to verify it works. + +## Connecting to Odin + +The controller should be updated to inherit from `OdinController` instead of +`Controller`. This controller connects to an Odin server, introspects all of its adapters, and +creates sub controllers and attributes for each one automatically. + +::::{admonition} Code 4 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin04.py +:emphasize-lines: 4,10,13,18 +::: + +:::: + +:::{note} +Warnings about parameters failing to be read are expected for some adapter parameters. +::: + +The PVs can be listed in the interactive shell to see what has been created: + +``` +In [1]: dbl() +EXAMPLE:DETECTOR:ConfigExposureTime_RBV +... +EXAMPLE:FP:0:HDF:FileUseNumbers_RBV +... +EXAMPLE:FR:2:DecoderEnablePacketLogging_RBV +... +EXAMPLE:DETECTOR:Start +``` + +The controller now has sub controllers for each adapter: + +``` +In [2]: controller.sub_controllers +Out[2]: +{'DETECTOR': OdinAdapterController(path=DETECTOR, sub_controllers=None), + 'FR': FrameReceiverAdapterController(path=FR, sub_controllers=['0', '1', '2', '3']), + 'FP': FrameProcessorAdapterController(path=FP, sub_controllers=['0', '1', '2', '3']), + 'LIVE': OdinAdapterController(path=LIVE, sub_controllers=None), + 'SYSTEM': OdinAdapterController(path=SYSTEM, sub_controllers=None)} +``` + +Sub controllers for adapters can be mapped to specific classes, or the +fallback `OdinAdapterController`, which introspects the parameter tree and adds no +additional logic. + +### Phoebus UI + +The display can be reloaded in Phoebus (right-click > Re-load display). There should now +be buttons for each sub controller. + +- Open the DETECTOR screen. Pressing Start should cause the frame counter to + tick up. +- The FP screen has top-level attributes that read/write each individual FP instance. + Things that must differ per instance (like `CtrlEndpoint`) are excluded. These can be + seen in the screen for the specific instance, e.g. `FP0`. +- The FP screen also has PVs for the `example` dataset. These are detector-specific + and defined in the Odin config file. + +## Running an Acquisition + +An acquisition can now be run using the sub controller screens: + +1. Set `FP.FilePath` = `/tmp` +2. Set `FP.FilePrefix` = `test` +3. Set `FP.Frames` = `10` +4. Press `FP.StartWriting` +5. Check that `FP.Writing` is set +6. Set `DETECTOR.Frames` = `10` +7. Press `DETECTOR.Start` +8. Watch `FP.FramesWritten` count up to 10 and then `FP.Writing` unset + +The interactive shell will show the parameters that are being set. + +## Improving the API + +Navigating between sub screens is fiddly. Top-level attributes can be added that fan +values out to the relevant sub controllers. The `foo` attribute should be removed and an +`initialise` method added to create new attributes after the Odin introspection has +completed. + +::::{admonition} Code 5 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin05.py +:emphasize-lines: 6,12,15-33 +::: + +:::: + +After running and reloading the display, the new PVs will appear on the top screen. + +:::{note} +`FP` and `DETECTOR` are accessed as attributes of `self`, but they are unknown to static +type checkers because they are only created at runtime during Odin introspection. There +will be no autocompletion for them yet. +::: + +## Type Hints for Sub Controllers + +FastCS validates type-hinted attributes, methods and sub controllers during +initialisation to fail early if something is wrong. Typed sub controller classes can be +created and type hints added to `ExampleOdinController`. + +An `ExampleFrameProcessorAdapterController` inheriting from +`FrameProcessorAdapterController` with a `frames` attribute hint, and an +`ExampleDetectorAdapterController` inheriting from `OdinAdapterController` with a +`config_frames` attribute hint should be created. + +:::{note} +`frames` has since been added to the parent `FrameProcessorAdapterController`, but is +kept here as an example of the pattern that can be applied to any other attribute on the +parent controller. +::: + +Type hints for `FP` and `DETECTOR` should be added on `ExampleOdinController`, and +`_create_adapter_controller` overridden so that the correct controller types are +instantiated. + +::::{admonition} Code 6 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin06.py +:emphasize-lines: 6,12-15,19-27,31,32,53-72 +::: + +:::: + +Without overriding `_create_adapter_controller`, the application will fail with: + +``` +RuntimeError: Controller 'ExampleOdinController' introspection of hinted sub controller +'DETECTOR' does not match defined type. Expected 'ExampleDetectorAdapterController' +got 'OdinAdapterController'. +``` + +Type hints for attributes or sub controllers that don't exist will also fail: + +``` +RuntimeError: Controller `ExampleOdinController` failed to introspect hinted +controller `FOO` during initialisation +``` + +``` +RuntimeError: Controller `ExampleOdinController` failed to introspect hinted +attribute `foo` during initialisation +``` + +## Adding Commands + +Parameters can now be set from the top screen, but acquisitions cannot be run yet. +`start` and `stop` type hints should be added on `ExampleDetectorAdapterController`, +along with `acquire` and `stop` command methods on `ExampleOdinController`. + +::::{admonition} Code 7 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin07.py +:emphasize-lines: 8,29,30,37-45 +::: + +:::: + +:::{note} +`FrameProcessorAdapterController` already has `start_writing` and `stop_writing` defined +statically, so they do not need to be added to +`ExampleFrameProcessorAdapterController`. +::: + +After running and reloading Phoebus, an acquisition can now be started and stopped from +the top screen. + +## Adding Status Attributes + +The top screen can trigger acquisitions but has no status. `status_acquiring` and +`status_frames` type hints should be added to `ExampleDetectorAdapterController`, and +top-level summary attributes created that aggregate status from multiple sub +controllers. + +::::{admonition} Code 8 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin08.py +:emphasize-lines: 3,7,19,30,31,69-80 +::: + +:::: + +The `StatusSummaryAttributeIORef` aggregates values from multiple attributes. The `any` +function is used for `acquiring` (true if any source is active) and `min` for +`frames_captured` (the lowest count across sources). + +## Controller Logic + +There is a risk that the file writer is slower to start than the detector and frames will +be missed. `wait_for_value` can be used to ensure that the file writers have started +before starting the detector. + +::::{admonition} Code 9 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin09.py +:emphasize-lines: 44 +::: + +:::: + +## Live View with Scan Methods + +The live view adapter can be used to see frames as they pass through. A `Waveform` +attribute can be added to display the image along with a `@scan` method to periodically +query the live view adapter for images. + +::::{admonition} Code 10 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin10.py +:emphasize-lines: 1,4,9,10,13,44,46-57 +::: + +:::: + +:::{note} +The image dimensions and dtype could be queried from `LIVE.Shape` and `LIVE.FrameDtype` +at runtime to create `live_view_image` dynamically. +::: + +The EPICS CA transport does not support 2D arrays, so it will give a warning and the +`LiveViewImage` PV will not be created via CA. + +## Adding PV Access + +An `EpicsPVATransport` can be added alongside the existing `EpicsCATransport` to serve +both transports simultaneously. PVA supports 2D array attributes, so the +`LiveViewImage` PV will be available over PVA. + +::::{admonition} Code 11 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin11.py +:emphasize-lines: 13,131-137 +::: + +:::: + +An acquisition can be run and the live view watched (LiveViewImage button): + +1. Set `DETECTOR.Frames` = `0` (continuous) +2. Press `DETECTOR.Start` + +## Logging and Tracing + +There is a custom logger built into fastcs that allows structured logging and +trace-level logging that can be enabled at runtime per-attribute. + +Add INFO level log statements to the `acquire` and `stop` commands to record when +writing starts and stops. + +::::{admonition} Code 12 +:class: dropdown, hint + +:::{literalinclude} /snippets/odin12.py +:emphasize-lines: 10,63,71,128 +::: + +:::: + +Running an acquisition will then produce log output: + +``` +[2025-12-23 12:07:31.615+0000 I] Starting writing +[2025-12-23 12:07:32.012+0000 I] Stopping writing +``` + +TRACE level logging must be configured for trace messages to appear. This will not +produce additional output until tracing is enabled at runtime, although it will enable +DEBUG level output. There are trace level messages logged throughout the fastcs +codebase to enable debugging live systems. All classes that inherit `Tracer` can call +`log_event` to emit trace messages, which can be enabled at runtime by calling +`enable_tracing`. For example, `Attribute`s: + +``` +In [1]: controller.FP[0].HDF.file_path.enable_tracing() +[2025-12-23 12:07:31.615+0000 T] Query for parameter [ParameterTreeAttributeIO] uri=api/0.1/fp/0/config/hdf/file/path, response={'path': '/tmp'} +... +In [2]: controller.FP[0].HDF.file_path.disable_tracing() +``` diff --git a/pyproject.toml b/pyproject.toml index ec8b804..1973b91 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,6 +28,9 @@ authors = [ [dependency-groups] dev = [ + "fastcs[epicspva]", + "pillow", + "requests", "copier", "myst-parser", "pre-commit", @@ -65,7 +68,7 @@ reportMissingImports = false # Ignore missing stubs in imported modules [tool.pytest.ini_options] # Run pytest with all our checkers, and don't spam us with massive tracebacks on error addopts = """ - --tb=native -vv --doctest-modules --doctest-glob="*.rst" + --tb=native -vv --doctest-modules --doctest-glob="*.rst" --ignore-glob docs/snippets/*.py """ # https://iscinumpy.gitlab.io/post/bound-version-constraints/#watch-for-warnings filterwarnings = "error" diff --git a/tests/test_docs_snippets.py b/tests/test_docs_snippets.py new file mode 100644 index 0000000..35f5886 --- /dev/null +++ b/tests/test_docs_snippets.py @@ -0,0 +1,9 @@ +import glob +import runpy + +import pytest + + +@pytest.mark.parametrize("filename", glob.glob("docs/snippets/*.py")) +def test_snippet(filename): + runpy.run_path(filename) diff --git a/uv.lock b/uv.lock index 81d2d3a..4881536 100644 --- a/uv.lock +++ b/uv.lock @@ -851,6 +851,10 @@ epicsca = [ { name = "pvi" }, { name = "softioc" }, ] +epicspva = [ + { name = "p4p" }, + { name = "pvi" }, +] [[package]] name = "fastcs-odin" @@ -863,7 +867,9 @@ dependencies = [ [package.dev-dependencies] dev = [ { name = "copier" }, + { name = "fastcs", extra = ["epicspva"] }, { name = "myst-parser" }, + { name = "pillow" }, { name = "pre-commit" }, { name = "pydata-sphinx-theme" }, { name = "pyright" }, @@ -871,6 +877,7 @@ dev = [ { name = "pytest-asyncio" }, { name = "pytest-cov" }, { name = "pytest-mock" }, + { name = "requests" }, { name = "ruff" }, { name = "sphinx-autobuild" }, { name = "sphinx-copybutton" }, @@ -892,7 +899,9 @@ requires-dist = [ [package.metadata.requires-dev] dev = [ { name = "copier" }, + { name = "fastcs", extras = ["epicspva"] }, { name = "myst-parser" }, + { name = "pillow" }, { name = "pre-commit" }, { name = "pydata-sphinx-theme", specifier = ">=0.12" }, { name = "pyright" }, @@ -900,6 +909,7 @@ dev = [ { name = "pytest-asyncio" }, { name = "pytest-cov" }, { name = "pytest-mock" }, + { name = "requests" }, { name = "ruff" }, { name = "sphinx-autobuild" }, { name = "sphinx-copybutton" }, @@ -1652,6 +1662,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, ] +[[package]] +name = "nose2" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/b2/73553c0e19c4bfe174940de03c2e1814f407e3524628690800f2536bf7f7/nose2-0.16.0.tar.gz", hash = "sha256:19db5ad20e264501a8ee64e3e157a3766a5e744170e54ceecb4e5ca09b08655a", size = 172667, upload-time = "2026-03-02T00:49:52.122Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/3b/e93d177001ac3ba3cb2ebed7727442e1ee61990271f2bf39caef63798ead/nose2-0.16.0-py3-none-any.whl", hash = "sha256:a637c508b1fff5882c5f0f573226abe6f43b2f8005fef8896f57174d7d0e0c31", size = 213451, upload-time = "2026-03-02T00:49:50.609Z" }, +] + [[package]] name = "numpy" version = "2.4.1" @@ -1770,6 +1789,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/27/fb8d7338b4d551900fa3e580acbe7a0cf655d940e164cb5c00ec31961094/orderly_set-5.5.0-py3-none-any.whl", hash = "sha256:46f0b801948e98f427b412fcabb831677194c05c3b699b80de260374baa0b1e7", size = 13068, upload-time = "2025-07-10T20:10:54.377Z" }, ] +[[package]] +name = "p4p" +version = "4.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "epicscorelibs" }, + { name = "nose2" }, + { name = "numpy" }, + { name = "ply" }, + { name = "pvxslibs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/81/b1/cbb46a39cf571b5fcf8a61ead702f60f324a00d1728ab082307bd47c980f/p4p-4.2.2.tar.gz", hash = "sha256:1685ffab0d0a1a1e3da647dd9f027933a10d57b71b3c4f5dd762fcabeba7e31e", size = 390763, upload-time = "2026-01-08T03:14:25.043Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/ca/7efb55121ce69994203c29daf0e6675f4f48fdea411862c732319ead5893/p4p-4.2.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a778596f0cd9fd83546d9684523d20923d2ff0aa7300f43a5b591dad704cdff6", size = 665814, upload-time = "2026-01-08T03:14:03.914Z" }, + { url = "https://files.pythonhosted.org/packages/9e/cc/30c03930f41cbc7e2911c9f9ee641a5ddd0b93514ddcbcf6ec86262c81ca/p4p-4.2.2-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:90c2fbcc1adc72cc18194f7287c9c97ac4244e03e9c0b4196a3405c6315f48de", size = 412720, upload-time = "2026-01-08T03:14:05.331Z" }, + { url = "https://files.pythonhosted.org/packages/a0/09/97e984a0b61690638af9eda5c4dc5229332e432473ee6e1865dc83f34247/p4p-4.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:92e6f9225e24941b5c83062229a21e552d46f59a4246794e1155216da4e58873", size = 327879, upload-time = "2026-01-08T03:14:06.254Z" }, + { url = "https://files.pythonhosted.org/packages/21/28/ff570f5d992087bb25b7a27189ac29a3a4da0edd64d8cb8d666c1c8ff852/p4p-4.2.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e614f602e8d1e977afb85a23321d878e3f1131f8e06c385bff270314a6c1814", size = 667922, upload-time = "2026-01-08T03:14:07.172Z" }, + { url = "https://files.pythonhosted.org/packages/e9/45/863765ab799e3197d1863c2035bf0ce1f7e925d33a5c1d1153cc01c888e3/p4p-4.2.2-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:a1fbd9c52169e849546dcaf5689a09340bb79ce28eacf4abeff6babf203dac3d", size = 407581, upload-time = "2026-01-08T03:14:08.298Z" }, + { url = "https://files.pythonhosted.org/packages/cb/21/b4357e8f66a6f6183386356ac206aa9d78b1fb08812836acc103d8aaa03a/p4p-4.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:82dee1207a72a3ea5dbb086c12b8897eb349f594b7855c8bfe1a4e2e5e332704", size = 328047, upload-time = "2026-01-08T03:14:10.463Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0f/cfa351a745ec2a3547e1a4711fb202ec32ec9d342ca1c9dbaed0d5b39ab7/p4p-4.2.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:1d30d0bb36c1b7e23f5c9cb82723d34621507a3dfd2b53de40c7781c54e42e8d", size = 665314, upload-time = "2026-01-08T03:14:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/dd/fb/4939594c20028eca7ee54cea21de25762ef6934a5fb168b8130599921c88/p4p-4.2.2-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:106b1dc2c54eaf2d90da6d1fbe2a79dadfb8c796341edaaabe9fedac90246e07", size = 407030, upload-time = "2026-01-08T03:14:12.434Z" }, + { url = "https://files.pythonhosted.org/packages/18/c4/9874ed185d2a78a717c81cc4fa59ead18187435bca7f4e72aeaefd778f6e/p4p-4.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:ef94ae9d56885ce6419816671941bb06f8f6c621d1ebba1cb0d352282d6849a9", size = 328124, upload-time = "2026-01-08T03:14:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fb/0e58517f29e3b9b89fd803d7650176992e441b34a543b28beb1769ce9a0a/p4p-4.2.2-cp313-cp313t-manylinux2014_x86_64.whl", hash = "sha256:553a19531a33f49998db0c68b43f86869b139ccb34d01853415ea43696fbbb3d", size = 406459, upload-time = "2026-01-08T03:14:14.132Z" }, + { url = "https://files.pythonhosted.org/packages/25/c5/c076489a63ba53b9d7c903f41728da0befd598eaae2e874148eac0076de7/p4p-4.2.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:61b932ccb4ebf93920dd181907fa2642071be7ae235c1c95088affaae1d258a2", size = 668243, upload-time = "2026-01-08T03:14:15.051Z" }, + { url = "https://files.pythonhosted.org/packages/c4/7e/305f9a51190f9573589276b91e7082c6c358a1c0d85f36743bae8219847f/p4p-4.2.2-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:31d5a53e68c633a9d791e74950ac0ce9d336809e6a250e9b66fbe60de7e18e0b", size = 419699, upload-time = "2026-01-08T03:14:16.217Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/bd7e83b413c9f83ae2fc4401546d7e4c0fd3445c72c1552cd6c252d41132/p4p-4.2.2-cp314-cp314-win_amd64.whl", hash = "sha256:1e8972d75fb7500e4a4fc72beb4136438d84b5fdf89869c5b70171971a143d50", size = 334442, upload-time = "2026-01-08T03:14:17.345Z" }, + { url = "https://files.pythonhosted.org/packages/ce/00/4e9361380019899f132122982b84f9d1b5e73e6e700686cd8435163663e9/p4p-4.2.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:11f9e61162380535a5ef074de6f0cd127e65ef3a6399c7cba16115aedf70b8e1", size = 414490, upload-time = "2026-01-08T03:14:18.24Z" }, +] + [[package]] name = "packaging" version = "26.0" @@ -1809,6 +1857,93 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, ] +[[package]] +name = "pillow" +version = "12.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" }, + { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" }, + { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" }, + { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" }, + { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" }, + { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" }, + { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" }, + { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" }, + { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" }, + { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" }, + { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" }, + { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" }, + { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" }, + { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" }, + { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" }, + { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" }, + { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" }, + { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" }, + { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" }, + { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" }, + { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" }, + { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" }, + { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" }, + { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" }, + { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" }, + { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" }, + { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" }, + { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" }, + { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" }, + { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" }, + { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" }, + { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" }, + { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" }, + { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" }, + { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" }, + { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" }, + { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" }, + { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" }, + { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" }, + { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" }, + { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" }, + { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" }, + { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" }, + { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" }, + { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" }, + { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" }, + { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" }, + { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" }, + { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" }, + { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" }, + { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" }, + { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" }, + { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" }, + { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" }, + { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" }, + { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" }, +] + [[package]] name = "platformdirs" version = "4.5.1" @@ -1839,6 +1974,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/ad/45312df6b63ba64ea35b8d8f5f0c577aac16e6b416eafe8e1cb34e03f9a7/plumbum-1.10.0-py3-none-any.whl", hash = "sha256:9583d737ac901c474d99d030e4d5eec4c4e6d2d7417b1cf49728cf3be34f6dc8", size = 127383, upload-time = "2025-10-31T05:02:47.002Z" }, ] +[[package]] +name = "ply" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130, upload-time = "2018-02-15T19:01:31.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" }, +] + [[package]] name = "posix-ipc" version = "1.3.2"