some random stuff. caelestia incoming

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/__init__.py

@@ -0,0 +1,6 @@
+from .basic import BasicDecoder, BasicEncoder
+
+__all__ = [
+    "BasicDecoder",
+    "BasicEncoder",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/_builder.py

@@ -0,0 +1,106 @@
+import re
+from collections.abc import Callable
+from typing import Any, Optional, Type
+
+from mashumaro.core.meta.code.builder import CodeBuilder
+from mashumaro.core.meta.helpers import is_optional, is_type_var_any
+from mashumaro.core.meta.types.common import (
+    AttrsHolder,
+    FieldContext,
+    ValueSpec,
+)
+from mashumaro.core.meta.types.pack import PackerRegistry
+from mashumaro.core.meta.types.unpack import UnpackerRegistry
+
+CALL_EXPR = re.compile(r"^([^ ]+)\(value\)$")
+
+
+class CodecCodeBuilder(CodeBuilder):
+    @classmethod
+    def new(cls, **kwargs: Any) -> "CodecCodeBuilder":
+        if "attrs" not in kwargs:
+            kwargs["attrs"] = AttrsHolder()
+        return cls(AttrsHolder("__root__"), **kwargs)  # type: ignore
+
+    def add_decode_method(
+        self,
+        shape_type: Type,
+        decoder_obj: Any,
+        pre_decoder_func: Optional[Callable[[Any], Any]] = None,
+    ) -> None:
+        self.reset()
+        with self.indent("def decode(value):"):
+            if pre_decoder_func:
+                self.ensure_object_imported(pre_decoder_func, "decoder")
+                self.add_line("value = decoder(value)")
+            could_be_none = (
+                shape_type in (Any, type(None), None)
+                or is_type_var_any(self.get_real_type("", shape_type))
+                or is_optional(
+                    shape_type, self.get_field_resolved_type_params("")
+                )
+            )
+            unpacked_value = UnpackerRegistry.get(
+                ValueSpec(
+                    type=shape_type,
+                    expression="value",
+                    builder=self,
+                    field_ctx=FieldContext(name="", metadata={}),
+                    could_be_none=could_be_none,
+                )
+            )
+            self.add_line(f"return {unpacked_value}")
+        self.add_line("setattr(decoder_obj, 'decode', decode)")
+        if pre_decoder_func is None:
+            m = CALL_EXPR.match(unpacked_value)
+            if m:
+                method_name = m.group(1)
+                self.lines.reset()
+                self.add_line(f"setattr(decoder_obj, 'decode', {method_name})")
+        self.ensure_object_imported(decoder_obj, "decoder_obj")
+        self.ensure_object_imported(self.cls, "cls")
+        self.compile()
+
+    def add_encode_method(
+        self,
+        shape_type: Type,
+        encoder_obj: Any,
+        post_encoder_func: Optional[Callable[[Any], Any]] = None,
+    ) -> None:
+        self.reset()
+        with self.indent("def encode(value):"):
+            could_be_none = (
+                shape_type in (Any, type(None), None)
+                or is_type_var_any(self.get_real_type("", shape_type))
+                or is_optional(
+                    shape_type, self.get_field_resolved_type_params("")
+                )
+            )
+            packed_value = PackerRegistry.get(
+                ValueSpec(
+                    type=shape_type,
+                    expression="value",
+                    builder=self,
+                    field_ctx=FieldContext(name="", metadata={}),
+                    could_be_none=could_be_none,
+                    no_copy_collections=self.get_dialect_or_config_option(
+                        "no_copy_collections", ()
+                    ),
+                )
+            )
+            if post_encoder_func:
+                self.ensure_object_imported(post_encoder_func, "encoder")
+                self.add_line(f"return encoder({packed_value})")
+            else:
+                self.add_line(f"return {packed_value}")
+        self.add_line("setattr(encoder_obj, 'encode', encode)")
+        if post_encoder_func is None:
+            m = CALL_EXPR.match(packed_value)
+            if m:
+                method_name = m.group(1)
+                self.lines.reset()
+                self.add_line(f"setattr(encoder_obj, 'encode', {method_name})")
+        self.ensure_object_imported(encoder_obj, "encoder_obj")
+        self.ensure_object_imported(self.cls, "cls")
+        self.ensure_object_imported(self.cls, "self")
+        self.compile()

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/basic.py

@@ -0,0 +1,103 @@
+from collections.abc import Callable
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+
+T = TypeVar("T")
+
+
+class BasicDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[Callable[[Any], Any]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[Callable[[Any], Any]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[Callable[[Any], Any]] = None,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, pre_decoder_func)
+
+    @final
+    def decode(self, data: Any) -> T: ...
+
+
+class BasicEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[Callable[[Any], Any]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[Callable[[Any], Any]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[Callable[[Any], Any]] = None,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, post_encoder_func)
+
+    @final
+    def encode(self, obj: T) -> Any: ...
+
+
+def decode(data: Any, shape_type: Union[Type[T], Any]) -> T:
+    return BasicDecoder(shape_type).decode(data)
+
+
+def encode(obj: T, shape_type: Union[Type[T], Any]) -> Any:
+    return BasicEncoder(shape_type).encode(obj)
+
+
+__all__ = [
+    "BasicDecoder",
+    "BasicEncoder",
+    "decode",
+    "encode",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/json.py

@@ -0,0 +1,123 @@
+import json
+from collections.abc import Callable
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+
+T = TypeVar("T")
+EncodedData = Union[str, bytes, bytearray]
+
+
+class JSONDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Callable[[EncodedData], Any] = json.loads,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Callable[[EncodedData], Any] = json.loads,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Callable[[EncodedData], Any] = json.loads,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, pre_decoder_func)
+
+    @final
+    def decode(self, data: EncodedData) -> T: ...
+
+
+class JSONEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Callable[[Any], str] = json.dumps,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Callable[[Any], str] = json.dumps,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Callable[[Any], str] = json.dumps,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, post_encoder_func)
+
+    @final
+    def encode(self, obj: T) -> str: ...
+
+
+def json_decode(
+    data: EncodedData,
+    shape_type: Union[Type[T], Any],
+    pre_decoder_func: Callable[[EncodedData], Any] = json.loads,
+) -> T:
+    return JSONDecoder(shape_type, pre_decoder_func=pre_decoder_func).decode(
+        data
+    )
+
+
+def json_encode(
+    obj: T,
+    shape_type: Union[Type[T], Any],
+    post_encoder_func: Callable[[Any], str] = json.dumps,
+) -> str:
+    return JSONEncoder(shape_type, post_encoder_func=post_encoder_func).encode(
+        obj
+    )
+
+
+decode = json_decode
+encode = json_encode
+
+
+__all__ = [
+    "JSONDecoder",
+    "JSONEncoder",
+    "json_decode",
+    "json_encode",
+    "decode",
+    "encode",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/msgpack.py

@@ -0,0 +1,132 @@
+from collections.abc import Callable
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+import msgpack
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+from mashumaro.mixins.msgpack import MessagePackDialect
+
+T = TypeVar("T")
+
+EncodedData = bytes
+PostEncoderFunc = Callable[[Any], EncodedData]
+PreDecoderFunc = Callable[[EncodedData], Any]
+
+
+def _default_decoder(data: EncodedData) -> Any:
+    return msgpack.unpackb(data, raw=False)
+
+
+def _default_encoder(data: Any) -> EncodedData:
+    return msgpack.packb(data, use_bin_type=True)
+
+
+class MessagePackDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ):
+        if default_dialect is not None:
+            default_dialect = MessagePackDialect.merge(default_dialect)
+        else:
+            default_dialect = MessagePackDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, pre_decoder_func)
+
+    @final
+    def decode(self, data: EncodedData) -> T: ...
+
+
+class MessagePackEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ):
+        if default_dialect is not None:
+            default_dialect = MessagePackDialect.merge(default_dialect)
+        else:
+            default_dialect = MessagePackDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, post_encoder_func)
+
+    @final
+    def encode(self, obj: T) -> EncodedData: ...
+
+
+def msgpack_decode(data: EncodedData, shape_type: Union[Type[T], Any]) -> T:
+    return MessagePackDecoder(shape_type).decode(data)
+
+
+def msgpack_encode(obj: T, shape_type: Union[Type[T], Any]) -> EncodedData:
+    return MessagePackEncoder(shape_type).encode(obj)
+
+
+decode = msgpack_decode
+encode = msgpack_encode
+
+
+__all__ = [
+    "MessagePackDecoder",
+    "MessagePackEncoder",
+    "msgpack_decode",
+    "msgpack_encode",
+    "decode",
+    "encode",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/orjson.py

@@ -0,0 +1,114 @@
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+import orjson
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+from mashumaro.mixins.orjson import OrjsonDialect
+
+T = TypeVar("T")
+EncodedData = Union[str, bytes, bytearray]
+
+
+class ORJSONDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ):
+        if default_dialect is not None:
+            default_dialect = OrjsonDialect.merge(default_dialect)
+        else:
+            default_dialect = OrjsonDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, orjson.loads)
+
+    @final
+    def decode(self, data: EncodedData) -> T: ...
+
+
+class ORJSONEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ):
+        if default_dialect is not None:
+            default_dialect = OrjsonDialect.merge(default_dialect)
+        else:
+            default_dialect = OrjsonDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, orjson.dumps)
+
+    @final
+    def encode(self, obj: T) -> bytes: ...
+
+
+def json_decode(data: EncodedData, shape_type: Type[T]) -> T:
+    return ORJSONDecoder(shape_type).decode(data)
+
+
+def json_encode(obj: T, shape_type: Union[Type[T], Any]) -> bytes:
+    return ORJSONEncoder(shape_type).encode(obj)
+
+
+decode = json_decode
+encode = json_encode
+
+
+__all__ = [
+    "ORJSONDecoder",
+    "ORJSONEncoder",
+    "json_decode",
+    "json_encode",
+    "decode",
+    "encode",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/toml.py

@@ -0,0 +1,119 @@
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+import tomli_w
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+from mashumaro.mixins.toml import TOMLDialect
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore
+
+T = TypeVar("T")
+EncodedData = str
+
+
+class TOMLDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ):
+        if default_dialect is not None:
+            default_dialect = TOMLDialect.merge(default_dialect)
+        else:
+            default_dialect = TOMLDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, tomllib.loads)
+
+    @final
+    def decode(self, data: EncodedData) -> T: ...
+
+
+class TOMLEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+    ):
+        if default_dialect is not None:
+            default_dialect = TOMLDialect.merge(default_dialect)
+        else:
+            default_dialect = TOMLDialect
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, tomli_w.dumps)
+
+    @final
+    def encode(self, obj: T) -> bytes: ...
+
+
+def toml_decode(data: EncodedData, shape_type: Type[T]) -> T:
+    return TOMLDecoder(shape_type).decode(data)
+
+
+def toml_encode(obj: T, shape_type: Union[Type[T], Any]) -> bytes:
+    return TOMLEncoder(shape_type).encode(obj)
+
+
+decode = toml_decode
+encode = toml_encode
+
+
+__all__ = [
+    "TOMLDecoder",
+    "TOMLEncoder",
+    "toml_decode",
+    "toml_encode",
+    "decode",
+    "encode",
+]

.config/scripts/.venv/lib/python3.12/site-packages/mashumaro/codecs/yaml.py

@@ -0,0 +1,128 @@
+from collections.abc import Callable
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+import yaml
+
+from mashumaro.codecs._builder import CodecCodeBuilder
+from mashumaro.core.meta.helpers import get_args
+from mashumaro.dialect import Dialect
+
+T = TypeVar("T")
+
+
+EncodedData = Union[str, bytes]
+PostEncoderFunc = Callable[[Any], EncodedData]
+PreDecoderFunc = Callable[[EncodedData], Any]
+
+
+DefaultLoader = getattr(yaml, "CSafeLoader", yaml.SafeLoader)
+DefaultDumper = getattr(yaml, "CDumper", yaml.Dumper)
+
+
+def _default_encoder(data: Any) -> EncodedData:
+    return yaml.dump(data, Dumper=DefaultDumper)
+
+
+def _default_decoder(data: EncodedData) -> Any:
+    return yaml.load(data, DefaultLoader)
+
+
+class YAMLDecoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        pre_decoder_func: Optional[PreDecoderFunc] = _default_decoder,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_decode_method(shape_type, self, pre_decoder_func)
+
+    @final
+    def decode(self, data: EncodedData) -> T: ...
+
+
+class YAMLEncoder(Generic[T]):
+    @overload
+    def __init__(
+        self,
+        shape_type: Type[T],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        shape_type: Any,
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ): ...
+
+    def __init__(
+        self,
+        shape_type: Union[Type[T], Any],
+        *,
+        default_dialect: Optional[Type[Dialect]] = None,
+        post_encoder_func: Optional[PostEncoderFunc] = _default_encoder,
+    ):
+        code_builder = CodecCodeBuilder.new(
+            type_args=get_args(shape_type), default_dialect=default_dialect
+        )
+        code_builder.add_encode_method(shape_type, self, post_encoder_func)
+
+    @final
+    def encode(self, obj: T) -> EncodedData: ...
+
+
+def yaml_decode(data: EncodedData, shape_type: Union[Type[T], Any]) -> T:
+    return YAMLDecoder(shape_type).decode(data)
+
+
+def yaml_encode(obj: T, shape_type: Union[Type[T], Any]) -> EncodedData:
+    return YAMLEncoder(shape_type).encode(obj)
+
+
+decode = yaml_decode
+encode = yaml_encode
+
+
+__all__ = [
+    "YAMLDecoder",
+    "YAMLEncoder",
+    "yaml_decode",
+    "yaml_encode",
+    "decode",
+    "encode",
+]