liblaf-melon 0.1.0__py3-none-any.whl

liblaf/melon/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/__init__.pyi

@@ -0,0 +1,103 @@
+from . import cli, io, ops, struct, typing
+from .io import (
+    as_image_data,
+    as_point_set,
+    as_poly_data,
+    as_trimesh,
+    convert,
+    load,
+    load_dicom,
+    load_image_data,
+    load_poly_data,
+    save,
+)
+from .ops import (
+    NearestPointOnSurface,
+    NearestPointOnSurfacePrepared,
+    NearestPointOnSurfaceResult,
+    NearestVertex,
+    NearestVertexPrepared,
+    NearestVertexResult,
+    TransferAlgorithm,
+    TransferAlgorithmPrepared,
+    TransferAuto,
+    TransferAutoPrepared,
+    TransferNearestPointOnSurface,
+    TransferNearestPointOnSurfacePrepared,
+    TransferNearestVertex,
+    TransferNearestVertexPrepared,
+    concat_transforms,
+    contour,
+    extract_points,
+    gaussian_smooth,
+    get_fill_value,
+    nearest_point_on_surface,
+    nearest_vertex,
+    transfer_point_to_point,
+    transform,
+)
+from .struct import (
+    DICOM,
+    Acquisition,
+    AcquisitionMeta,
+    Attachments,
+    DICOMDataset,
+    DICOMDatasetMeta,
+    DICOMMeta,
+    Subject,
+    SubjectMeta,
+    format_date,
+    parse_date,
+)
+
+__all__ = [
+    "DICOM",
+    "Acquisition",
+    "AcquisitionMeta",
+    "Attachments",
+    "DICOMDataset",
+    "DICOMDatasetMeta",
+    "DICOMMeta",
+    "NearestPointOnSurface",
+    "NearestPointOnSurfacePrepared",
+    "NearestPointOnSurfaceResult",
+    "NearestVertex",
+    "NearestVertexPrepared",
+    "NearestVertexResult",
+    "Subject",
+    "SubjectMeta",
+    "TransferAlgorithm",
+    "TransferAlgorithmPrepared",
+    "TransferAuto",
+    "TransferAutoPrepared",
+    "TransferNearestPointOnSurface",
+    "TransferNearestPointOnSurfacePrepared",
+    "TransferNearestVertex",
+    "TransferNearestVertexPrepared",
+    "as_image_data",
+    "as_point_set",
+    "as_poly_data",
+    "as_trimesh",
+    "cli",
+    "concat_transforms",
+    "contour",
+    "convert",
+    "extract_points",
+    "format_date",
+    "gaussian_smooth",
+    "get_fill_value",
+    "io",
+    "load",
+    "load_dicom",
+    "load_image_data",
+    "load_poly_data",
+    "nearest_point_on_surface",
+    "nearest_vertex",
+    "ops",
+    "parse_date",
+    "save",
+    "struct",
+    "transfer_point_to_point",
+    "transform",
+    "typing",
+]

liblaf/melon/cli/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/__init__.pyi

@@ -0,0 +1,61 @@
+from . import dispatcher, melon, pyvista, trimesh
+from ._load import load
+from ._save import save
+from .dispatcher import (
+    AbstractConverter,
+    AbstractReader,
+    AbstractWriter,
+    ConversionDispatcher,
+    ReaderDispatcher,
+    UnsupportedConversionError,
+    WriterDispatcher,
+    conversion_dispatcher,
+    convert,
+    reader_dispatcher,
+    register_converter,
+    register_reader,
+    register_writer,
+    warning_unsupported_association,
+    writer_dispatcher,
+)
+from .melon import load_dicom
+from .pyvista import (
+    as_image_data,
+    as_point_set,
+    as_poly_data,
+    load_image_data,
+    load_poly_data,
+)
+from .trimesh import as_trimesh
+
+__all__ = [
+    "AbstractConverter",
+    "AbstractReader",
+    "AbstractWriter",
+    "ConversionDispatcher",
+    "ReaderDispatcher",
+    "UnsupportedConversionError",
+    "WriterDispatcher",
+    "as_image_data",
+    "as_point_set",
+    "as_poly_data",
+    "as_trimesh",
+    "conversion_dispatcher",
+    "conversion_dispatcher",
+    "convert",
+    "dispatcher",
+    "load",
+    "load_dicom",
+    "load_image_data",
+    "load_poly_data",
+    "melon",
+    "pyvista",
+    "reader_dispatcher",
+    "register_converter",
+    "register_reader",
+    "register_writer",
+    "save",
+    "trimesh",
+    "warning_unsupported_association",
+    "writer_dispatcher",
+]

liblaf/melon/io/_copy.py

@@ -0,0 +1,5 @@
+from liblaf.melon.typing import StrPath
+
+
+def copy(src: StrPath, dst: StrPath) -> None:
+    raise NotImplementedError

liblaf/melon/io/_load.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from liblaf import melon
+from liblaf.melon.typing import StrPath
+
+from . import reader_dispatcher
+
+reader_dispatcher.register(melon.io.melon.DICOMReader())
+reader_dispatcher.register(melon.io.pyvista.PolyDataReader())
+
+
+def load(path: StrPath) -> Any:
+    return reader_dispatcher.load(path)

liblaf/melon/io/_save.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from liblaf import melon
+from liblaf.melon.typing import StrPath
+
+from . import writer_dispatcher
+
+writer_dispatcher.register(melon.io.melon.DICOMWriter())
+writer_dispatcher.register(melon.io.pyvista.PolyDataWriter())
+
+
+def save(path: StrPath, obj: Any) -> None:
+    writer_dispatcher.save(path, obj)

liblaf/melon/io/dispatcher/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/dispatcher/__init__.pyi

@@ -0,0 +1,47 @@
+from . import conversion, reader, writer
+from .conversion import (
+    AbstractConverter,
+    ConversionDispatcher,
+    UnsupportedConversionError,
+    conversion_dispatcher,
+    convert,
+    register_converter,
+    warning_unsupported_association,
+)
+from .reader import (
+    AbstractReader,
+    ReaderDispatcher,
+    load,
+    reader_dispatcher,
+    register_reader,
+)
+from .writer import (
+    AbstractWriter,
+    WriterDispatcher,
+    register_writer,
+    save,
+    writer_dispatcher,
+)
+
+__all__ = [
+    "AbstractConverter",
+    "AbstractReader",
+    "AbstractWriter",
+    "ConversionDispatcher",
+    "ReaderDispatcher",
+    "UnsupportedConversionError",
+    "WriterDispatcher",
+    "conversion",
+    "conversion_dispatcher",
+    "convert",
+    "load",
+    "reader",
+    "reader_dispatcher",
+    "register_converter",
+    "register_reader",
+    "register_writer",
+    "save",
+    "warning_unsupported_association",
+    "writer",
+    "writer_dispatcher",
+]

liblaf/melon/io/dispatcher/conversion/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/dispatcher/conversion/__init__.pyi

@@ -0,0 +1,18 @@
+from ._converter import AbstractConverter
+from ._dispatcher import (
+    ConversionDispatcher,
+    conversion_dispatcher,
+    convert,
+    register_converter,
+)
+from ._utils import UnsupportedConversionError, warning_unsupported_association
+
+__all__ = [
+    "AbstractConverter",
+    "ConversionDispatcher",
+    "UnsupportedConversionError",
+    "conversion_dispatcher",
+    "convert",
+    "register_converter",
+    "warning_unsupported_association",
+]

liblaf/melon/io/dispatcher/conversion/_converter.py

@@ -0,0 +1,17 @@
+import abc
+from typing import Any
+
+
+class AbstractConverter(abc.ABC):
+    priority: int = 0
+    type_from: type
+    type_to: type
+
+    @abc.abstractmethod
+    def convert(self, obj: Any) -> Any: ...
+
+    def match_from(self, obj: Any) -> bool:
+        return isinstance(obj, self.type_from)
+
+    def match_to(self, type_to: type) -> bool:
+        return issubclass(self.type_to, type_to)

liblaf/melon/io/dispatcher/conversion/_dispatcher.py

@@ -0,0 +1,29 @@
+import bisect
+from typing import Any, TypeVar
+
+from . import AbstractConverter, UnsupportedConversionError
+
+_T = TypeVar("_T")
+
+
+class ConversionDispatcher:
+    converters: list[AbstractConverter]
+
+    def __init__(self) -> None:
+        self.converters = []
+
+    def register(self, converter: AbstractConverter) -> None:
+        bisect.insort(self.converters, converter, key=lambda c: c.priority)
+
+    def convert(self, obj: Any, type_to: type[_T]) -> _T:
+        if isinstance(obj, type_to):
+            return obj
+        for converter in self.converters:
+            if converter.match_from(obj) and converter.match_to(type_to):
+                return converter.convert(obj)
+        raise UnsupportedConversionError(obj, type_to)
+
+
+conversion_dispatcher = ConversionDispatcher()
+register_converter = conversion_dispatcher.register
+convert = conversion_dispatcher.convert

liblaf/melon/io/dispatcher/conversion/_utils.py

@@ -0,0 +1,22 @@
+from typing import Any
+
+import pyvista as pv
+from loguru import logger
+
+
+class UnsupportedConversionError(TypeError):
+    obj: Any
+    type_to: type
+
+    def __init__(self, obj: Any, type_to: type) -> None:
+        self.obj = obj
+        self.type_to = type_to
+        super().__init__(f"Cannot convert `{obj}` to `{type_to}`.")
+
+
+def warning_unsupported_association(
+    to: type, association: pv.FieldAssociation, attr: Any | None = None
+) -> None:
+    if attr is None:
+        return
+    logger.warning("{:r} does not support {:r} data", to, association)

liblaf/melon/io/dispatcher/reader/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/dispatcher/reader/__init__.pyi

@@ -0,0 +1,12 @@
+from ._dispatcher import ReaderDispatcher, load, reader_dispatcher, register_reader
+from ._reader import AbstractReader
+from ._utils import UnsupportedReaderError
+
+__all__ = [
+    "AbstractReader",
+    "ReaderDispatcher",
+    "UnsupportedReaderError",
+    "load",
+    "reader_dispatcher",
+    "register_reader",
+]

liblaf/melon/io/dispatcher/reader/_dispatcher.py

@@ -0,0 +1,27 @@
+import bisect
+from typing import Any
+
+from liblaf.melon.typing import StrPath
+
+from . import AbstractReader, UnsupportedReaderError
+
+
+class ReaderDispatcher:
+    readers: list[AbstractReader]
+
+    def __init__(self) -> None:
+        self.readers = []
+
+    def register(self, reader: AbstractReader) -> None:
+        bisect.insort(self.readers, reader, key=lambda r: r.priority)
+
+    def load(self, path: StrPath) -> Any:
+        for reader in self.readers:
+            if reader.match_path(path):
+                return reader.load(path)
+        raise UnsupportedReaderError(path)
+
+
+reader_dispatcher = ReaderDispatcher()
+register_reader = reader_dispatcher.register
+load = reader_dispatcher.load

liblaf/melon/io/dispatcher/reader/_reader.py

@@ -0,0 +1,17 @@
+import abc
+from pathlib import Path
+from typing import Any
+
+from liblaf.melon.typing import StrPath
+
+
+class AbstractReader(abc.ABC):
+    extension: str
+    priority: int = 0
+
+    @abc.abstractmethod
+    def load(self, path: StrPath) -> Any: ...
+
+    def match_path(self, path: StrPath) -> bool:
+        path = Path(path)
+        return path.suffix == self.extension

liblaf/melon/io/dispatcher/reader/_utils.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+from liblaf.melon.typing import StrPath
+
+
+class UnsupportedReaderError(ValueError):
+    path: Path
+
+    def __init__(self, path: StrPath) -> None:
+        self.path = Path(path)
+        super().__init__(f"Cannot load `{self.path}`.")

liblaf/melon/io/dispatcher/writer/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/dispatcher/writer/__init__.pyi

@@ -0,0 +1,12 @@
+from ._dispatcher import WriterDispatcher, register_writer, save, writer_dispatcher
+from ._utils import UnsupportedWriterError
+from ._writer import AbstractWriter
+
+__all__ = [
+    "AbstractWriter",
+    "UnsupportedWriterError",
+    "WriterDispatcher",
+    "register_writer",
+    "save",
+    "writer_dispatcher",
+]

liblaf/melon/io/dispatcher/writer/_dispatcher.py

@@ -0,0 +1,27 @@
+import bisect
+from typing import Any
+
+from liblaf.melon.typing import StrPath
+
+from . import AbstractWriter, UnsupportedWriterError
+
+
+class WriterDispatcher:
+    writers: list[AbstractWriter]
+
+    def __init__(self) -> None:
+        self.writers = []
+
+    def register(self, writer: AbstractWriter) -> None:
+        bisect.insort(self.writers, writer, key=lambda r: r.priority)
+
+    def save(self, path: StrPath, obj: Any) -> None:
+        for writer in self.writers:
+            if writer.match_path(path):
+                return writer.save(path, obj)
+        raise UnsupportedWriterError(path)
+
+
+writer_dispatcher = WriterDispatcher()
+register_writer = writer_dispatcher.register
+save = writer_dispatcher.save

liblaf/melon/io/dispatcher/writer/_utils.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+from liblaf.melon.typing import StrPath
+
+
+class UnsupportedWriterError(ValueError):
+    path: Path
+
+    def __init__(self, path: StrPath) -> None:
+        self.path = Path(path)
+        super().__init__(f"Cannot save `{self.path}`.")

liblaf/melon/io/dispatcher/writer/_writer.py

@@ -0,0 +1,17 @@
+import abc
+from pathlib import Path
+from typing import Any
+
+from liblaf.melon.typing import StrPath
+
+
+class AbstractWriter(abc.ABC):
+    extension: str
+    priority: int = 0
+
+    @abc.abstractmethod
+    def save(self, path: StrPath, obj: Any) -> None: ...
+
+    def match_path(self, path: StrPath) -> bool:
+        path = Path(path)
+        return path.suffix == self.extension

liblaf/melon/io/melon/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/melon/__init__.pyi

@@ -0,0 +1,4 @@
+from . import dicom
+from .dicom import DICOMReader, DICOMWriter, as_dicom, load_dicom
+
+__all__ = ["DICOMReader", "DICOMWriter", "as_dicom", "dicom", "load_dicom"]

liblaf/melon/io/melon/dicom/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/melon/dicom/__init__.pyi

@@ -0,0 +1,12 @@
+from . import conversion
+from ._reader import DICOMReader, load_dicom
+from ._writer import DICOMWriter
+from .conversion import as_dicom
+
+__all__ = [
+    "DICOMReader",
+    "DICOMWriter",
+    "as_dicom",
+    "conversion",
+    "load_dicom",
+]

liblaf/melon/io/melon/dicom/_reader.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+from liblaf import melon
+from liblaf.melon.typing import StrPath
+
+
+def load_dicom(path: StrPath) -> melon.DICOM:
+    return melon.DICOM(path)
+
+
+class DICOMReader(melon.io.AbstractReader):
+    def match_path(self, path: StrPath) -> bool:
+        path = Path(path)
+        if path.is_dir() and (path / "DIRFILE").exists():
+            return True
+        if path.is_file() and path.name == "DIRFILE":  # noqa: SIM103
+            return True
+        return False
+
+    def load(self, path: StrPath) -> melon.DICOM:
+        return load_dicom(path)

liblaf/melon/io/melon/dicom/_writer.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from typing import Any
+
+from liblaf import melon
+from liblaf.melon.typing import StrPath
+
+from . import as_dicom
+
+
+class DICOMWriter(melon.io.AbstractWriter):
+    def match_path(self, path: StrPath) -> bool:
+        path = Path(path)
+        if path.name == "DIRFILE":  # noqa: SIM103
+            return True
+        return False
+
+    def save(self, path: StrPath, obj: Any) -> None:
+        obj: melon.DICOM = as_dicom(obj)
+        obj.save(path)

liblaf/melon/io/melon/dicom/conversion/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/melon/dicom/conversion/__init__.pyi

@@ -0,0 +1,3 @@
+from ._as import as_dicom
+
+__all__ = ["as_dicom"]

liblaf/melon/io/melon/dicom/conversion/_as.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from liblaf import melon
+from liblaf.melon.io import conversion_dispatcher
+
+
+def as_dicom(obj: Any) -> melon.DICOM:
+    return conversion_dispatcher.convert(obj, melon.DICOM)

liblaf/melon/io/pyvista/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/pyvista/__init__.pyi

@@ -0,0 +1,17 @@
+from . import image_data, point_set, poly_data
+from .image_data import as_image_data, load_image_data
+from .point_set import as_point_set
+from .poly_data import PolyDataReader, PolyDataWriter, as_poly_data, load_poly_data
+
+__all__ = [
+    "PolyDataReader",
+    "PolyDataWriter",
+    "as_image_data",
+    "as_point_set",
+    "as_poly_data",
+    "image_data",
+    "load_image_data",
+    "load_poly_data",
+    "point_set",
+    "poly_data",
+]

liblaf/melon/io/pyvista/image_data/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf/melon/io/pyvista/image_data/__init__.pyi

@@ -0,0 +1,5 @@
+from . import conversion
+from ._reader import load_image_data
+from .conversion import as_image_data
+
+__all__ = ["as_image_data", "conversion", "load_image_data"]

liblaf/melon/io/pyvista/image_data/_reader.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+import pyvista as pv
+
+from liblaf.melon.typing import StrPath
+
+
+def load_image_data(path: StrPath) -> pv.ImageData:
+    path = Path(path)
+    if path.is_file() and path.name == "DIRFILE":
+        path = path.parent
+    if path.is_dir() and (path / "DIRFILE").exists():
+        return pv.read(path, force_ext=".dcm")  # pyright: ignore[reportReturnType]
+    return pv.read(path)  # pyright: ignore[reportReturnType]

liblaf/melon/io/pyvista/image_data/conversion/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)