liblaf.melon.io.abc ¶

Bases: Protocol

              flowchart TD
              liblaf.melon.io.abc.AbstractConverter[AbstractConverter]

              

              click liblaf.melon.io.abc.AbstractConverter href "" "liblaf.melon.io.abc.AbstractConverter"
            

Callable that converts one object into another mesh representation.

__call__(obj: F, /, **kwargs) -> T

16

def __call__(self, obj: F, /, **kwargs) -> T: ...

Bases: Protocol

              flowchart TD
              liblaf.melon.io.abc.AbstractReader[AbstractReader]

              

              click liblaf.melon.io.abc.AbstractReader href "" "liblaf.melon.io.abc.AbstractReader"
            

Callable that loads an object from a path.

__call__(path: Path, /, **kwargs) -> T

17

def __call__(self, path: Path, /, **kwargs) -> T: ...

Bases: Protocol

              flowchart TD
              liblaf.melon.io.abc.AbstractWriter[AbstractWriter]

              

              click liblaf.melon.io.abc.AbstractWriter href "" "liblaf.melon.io.abc.AbstractWriter"
            

Callable that writes an object to a path.

__call__(obj: T, path: Path, /, **kwargs) -> None

19

def __call__(self, obj: T, path: Path, /, **kwargs) -> None: ...

Single-dispatch conversion registry with identity conversion built in.

The target type is registered as an identity conversion, so callers can pass through objects that are already in the requested representation.

Examples:

>>> converter = ConverterDispatcher(str)
>>> converter("mesh")
'mesh'
>>> @converter.register(int)
... def _from_int(obj, /, **kwargs):
...     return str(obj)
>>> converter(42)
'42'

Parameters:

• to_type (type[T]) –

  Target type returned unchanged when the input already has that runtime type.

• registry (_SingleDispatchCallable[T], default: <dynamic> ) –

  Underlying functools.singledispatch registry.

registry: _SingleDispatchCallable[T] = field(
    default=Factory(_default_registry, takes_self=True)
)

to_type: type[T]

__call__(obj: Any, /, **kwargs) -> T

60
61

def __call__(self, obj: Any, /, **kwargs) -> T:
    return self.registry(obj, **kwargs)

register[F](
    cls: _RegType, converter: AbstractConverter[F, T]
) -> AbstractConverter[F, T]

register[F](
    cls: _RegType, converter: None = None
) -> Callable[
    [AbstractConverter[F, T]], AbstractConverter[F, T]
]

71
72
73
74
75
76
77

def register[F](
    self, cls: _RegType, converter: AbstractConverter[F, T] | None = None
) -> Callable[..., Any]:
    if converter is None:
        return functools.partial(self.register, cls)
    self.registry.register(cls, converter)
    return converter

Dispatch readers by file suffix with an optional fallback reader.

Raises:

• KeyError –

  If the path suffix is unknown and no fallback reader exists.

Attributes:

Parameters:

• to_type (type[T]) –
• fallback (AbstractReader[T] | None, default: None ) –
• registry (dict[str, AbstractReader[T]], default: <class 'dict'> ) –

  dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

fallback: AbstractReader[T] | None = None

registry: dict[str, AbstractReader[T]] = field(
    factory=dict
)

to_type: type[T]

__call__(path: StrPath, /, **kwargs) -> T

37
38
39
40
41
42

def __call__(self, path: StrPath, /, **kwargs) -> T:
    path: Path = Path(path)
    reader: AbstractReader[T] | None = self.registry.get(path.suffix, self.fallback)
    if reader is None:
        raise KeyError(path.suffix)
    return reader(path, **kwargs)

register(
    suffixes: Iterable[str], reader: AbstractReader[T]
) -> AbstractReader[T]

register(
    suffixes: Iterable[str], reader: None = None
) -> Callable[[AbstractReader[T]], AbstractReader[T]]

52
53
54
55
56
57
58
59

def register(
    self, suffixes: Iterable[str], reader: AbstractReader[T] | None = None
) -> Callable[..., Any]:
    if reader is None:
        return functools.partial(self.register, suffixes)
    for s in suffixes:
        self.registry[s] = reader
    return reader

register_fallback(
    reader: AbstractReader[T],
) -> AbstractReader[T]

61
62
63

def register_fallback(self, reader: AbstractReader[T]) -> AbstractReader[T]:
    self.fallback = reader
    return reader

Dispatch writers first by file suffix and then by object type.

Registered writers receive a pathlib.Path. Parent directories are created before the writer is called, which keeps concrete writer implementations focused on serialization.

Raises:

• KeyError –

  If no writer registry exists for the path suffix.

• NotImplementedError –

  If the suffix exists but the object type is not registered for that suffix.

Parameters:

• registry (dict[str, _SingleDispatchCallable[None]], default: <class 'dict'> ) –

  dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

registry: dict[str, _SingleDispatchCallable[None]] = field(
    factory=dict
)

__call__(obj: T, path: StrPath, /, **kwargs) -> None

42
43
44
45
46

def __call__(self, obj: T, path: StrPath, /, **kwargs) -> None:
    path: Path = Path(path)
    writer: _SingleDispatchCallable[None] = self.registry[path.suffix]
    path.parent.mkdir(parents=True, exist_ok=True)
    return writer(obj, path, **kwargs)

register(
    cls: _RegType,
    suffixes: Iterable[str],
    writer: AbstractWriter[T],
) -> AbstractWriter[T]

register(
    cls: _RegType,
    suffixes: Iterable[str],
    writer: None = None,
) -> Callable[[AbstractWriter[T]], AbstractWriter[T]]

56
57
58
59
60
61
62
63
64
65
66
67
68

def register(
    self,
    cls: _RegType,
    suffixes: Iterable[str],
    writer: AbstractWriter[T] | None = None,
) -> Callable[..., Any]:
    if writer is None:
        return functools.partial(self.register, cls, suffixes)
    for suffix in suffixes:
        if suffix not in self.registry:
            self.registry[suffix] = functools.singledispatch(_default_writer)
        self.registry[suffix].register(cls, writer)
    return writer