liblaf-conf 0.1.0__tar.gz

liblaf_conf-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# ref: <https://github.com/github/gitignore/blob/main/Python.gitignore>
+
+# Globally Useful gitignores
+*.log
+*.log.*
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+# Distribution / packaging
+dist/
+
+# Unit test / coverage reports
+.nox/
+.cache/
+.coverage
+.coverage.*
+.hypothesis/
+.pytest_cache/
+
+# pixi
+.pixi/
+
+# Environments
+.venv/
+
+# mkdocs documentation
+/site/
+
+# Ruff stuff:
+.ruff_cache/
+
+# [Codecov](https://docs.codecov.com/docs/test-analytics#1-output-a-junit-xml-file-in-your-ci)
+junit.xml
+
+# [CodSpeed](https://codspeed.io/)
+.codspeed/
+
+# [hatch-vcs](https://github.com/ofek/hatch-vcs)
+_version.py

liblaf_conf-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 liblaf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

liblaf_conf-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: liblaf-conf
+Version: 0.1.0
+Project-URL: Changelog, https://github.com/liblaf/conf/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://liblaf.github.io/conf/
+Project-URL: Funding, https://github.com/liblaf/conf?sponsor=1
+Project-URL: Homepage, https://github.com/liblaf/conf
+Project-URL: Issue Tracker, https://github.com/liblaf/conf/issues
+Project-URL: Release Notes, https://github.com/liblaf/conf/releases
+Project-URL: Source Code, https://github.com/liblaf/conf
+Author-email: liblaf <30631553+liblaf@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: lazy-loader>=0.1
+Requires-Dist: pydantic-extra-types[pendulum]>=2.11
+Requires-Dist: pydantic>=2.12
+Description-Content-Type: text/markdown
+
+# conf

liblaf_conf-0.1.0/README.md

@@ -0,0 +1 @@
+# conf

liblaf_conf-0.1.0/pyproject.toml

@@ -0,0 +1,99 @@
+#:schema https://json.schemastore.org/pyproject.json
+# ref: <https://packaging.python.org/en/latest/specifications/pyproject-toml/>
+
+[project]
+name = "liblaf-conf"
+description = ""
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [
+  { name = "liblaf", email = "30631553+liblaf@users.noreply.github.com" }
+]
+keywords = []
+classifiers = [
+  # ref: <https://pypi.org/classifiers/>
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed"
+]
+dependencies = [
+  "lazy-loader>=0.1",
+  "pydantic>=2.12",
+  "pydantic-extra-types[pendulum]>=2.11"
+]
+dynamic = ["version"]
+
+[project.urls]
+# ref: <https://packaging.python.org/en/latest/specifications/well-known-project-urls/#well-known-labels>
+"Changelog" = "https://github.com/liblaf/conf/blob/main/CHANGELOG.md"
+"Documentation" = "https://liblaf.github.io/conf/"
+"Funding" = "https://github.com/liblaf/conf?sponsor=1"
+"Homepage" = "https://github.com/liblaf/conf"
+"Issue Tracker" = "https://github.com/liblaf/conf/issues"
+"Release Notes" = "https://github.com/liblaf/conf/releases"
+"Source Code" = "https://github.com/liblaf/conf"
+
+[dependency-groups]
+dev = []
+build = ["check-wheel-contents>=0.6", "hatch>=1", "twine>=6"]
+docs = ["liblaf-mkdocs-preset>=0.3", "mkdocs>=1,<2"]
+nox = ["liblaf-nox-recipes>=0.1", "nox>=2026"]
+test = [
+  "pytest>=9",
+  "pytest-cov>=7",
+  "pytest-randomly>=4",
+  "pytest-xdist>=3",
+  { include-group = "nox" }
+]
+
+[build-system]
+requires = ["hatch-vcs", "hatchling"]
+build-backend = "hatchling.build"
+
+[tool.check-wheel-contents]
+ignore = ["W002"]
+
+[tool.coverage.run]
+branch = true
+source = ["src"]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/liblaf/conf/_version.py"
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/liblaf"]
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.pytest]
+addopts = [
+  "--doctest-modules",
+  "--import-mode=importlib",
+  "--numprocesses=auto",
+  "--showlocals"
+]
+consider_namespace_packages = true
+strict = true
+testpaths = ["benches", "src", "tests"]
+
+[tool.ruff]
+extend = ".config/linters/.ruff.toml"
+
+[tool.ty.environment]
+python = ".venv"  # ty-vscode does not work without this
+
+[tool.uv]
+default-groups = "all"

liblaf_conf-0.1.0/src/liblaf/conf/__init__.py

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

liblaf_conf-0.1.0/src/liblaf/conf/__init__.pyi

@@ -0,0 +1,45 @@
+from ._config import BaseConfig, ConfigMeta
+from ._field import Converter, Factory, Field
+from ._field_specifiers import (
+    field_bool,
+    field_date,
+    field_datetime,
+    field_decimal,
+    field_float,
+    field_int,
+    field_json,
+    field_list_str,
+    field_path,
+    field_str,
+    field_time,
+    field_timedelta,
+)
+from ._group import Group, group
+from ._var import Var
+from ._version import __commit_id__, __version__, __version_tuple__
+
+__all__ = [
+    "BaseConfig",
+    "ConfigMeta",
+    "Converter",
+    "Factory",
+    "Field",
+    "Group",
+    "Var",
+    "__commit_id__",
+    "__version__",
+    "__version_tuple__",
+    "field_bool",
+    "field_date",
+    "field_datetime",
+    "field_decimal",
+    "field_float",
+    "field_int",
+    "field_json",
+    "field_list_str",
+    "field_path",
+    "field_str",
+    "field_time",
+    "field_timedelta",
+    "group",
+]

liblaf_conf-0.1.0/src/liblaf/conf/_config.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import contextlib
+import types
+from collections.abc import Generator, Mapping
+from typing import TYPE_CHECKING, Any, ClassVar, Self, cast
+
+from pydantic import alias_generators
+
+from ._field import Field
+from ._group import Group
+
+if TYPE_CHECKING:
+    from ._var import Var
+
+
+class ConfigMeta(type):
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        /,
+        **_kwargs: Any,
+    ) -> type:
+        if "name" not in namespace:
+            namespace["name"] = alias_generators.to_snake(name).removesuffix("_config")
+        if "env_prefix" not in namespace:
+            namespace["env_prefix"] = namespace["name"].upper() + "_"
+        cls: type[BaseConfig] = cast(
+            "type[BaseConfig]", super().__new__(mcs, name, bases, namespace)
+        )
+        fields: dict[str, Field[Any]] = {}
+        groups: dict[str, Group[Any]] = {}
+        for base in reversed(cls.__mro__[1:]):
+            fields.update(getattr(base, "_fields", {}))
+            groups.update(getattr(base, "_groups", {}))
+        for key, value in namespace.items():
+            match value:
+                case Field():
+                    groups.pop(key, None)
+                    fields[key] = value
+                case Group():
+                    fields.pop(key, None)
+                    groups[key] = value
+                case _:
+                    fields.pop(key, None)
+                    groups.pop(key, None)
+        cls._fields = fields
+        cls._groups = groups
+        return cls
+
+    def __call__[T: BaseConfig](cls: type[T], *args, **kwargs) -> T:
+        instance: T | None = cls.__dict__.get("_instance")
+        if instance is None:
+            instance = super().__call__(*args, **kwargs)  # ty:ignore[invalid-super-argument]
+            cls._instance = instance
+        return instance
+
+
+class BaseConfig(metaclass=ConfigMeta):
+    name: ClassVar[str]
+    env_prefix: ClassVar[str]
+    _fields: ClassVar[dict[str, Field[Any]]]
+    _groups: ClassVar[dict[str, Group[Any]]]
+    _instance: ClassVar[Self | None] = None
+
+    def load_env(self) -> None:
+        for name in self._fields:
+            var: Var[Any] = self._get_field(name)
+            var.load_env()
+        for name in self._groups:
+            group: BaseConfig = self._get_group(name)
+            group.load_env()
+
+    def set(self, changes: Mapping[str, Any] | None = None, /, **kwargs: Any) -> None:
+        if changes is not None:
+            kwargs.update(changes)
+        for name, value in kwargs.items():
+            var: BaseConfig | Var[Any] = self._get_field_or_group(name)
+            var.set(value)
+
+    @contextlib.contextmanager
+    def override(
+        self, changes: Mapping[str, Any] | None = None, /, **kwargs: Any
+    ) -> Generator[None]:
+        if changes is not None:
+            kwargs.update(changes)
+        with contextlib.ExitStack() as stack:
+            for name, value in kwargs.items():
+                var: BaseConfig | Var[Any] = self._get_field_or_group(name)
+                stack.enter_context(var.override(value))
+            yield
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        for name in self._fields:
+            result[name] = self._get_field(name).get()
+        for name in self._groups:
+            result[name] = self._get_group(name).to_dict()
+        return result
+
+    def to_namespace(self) -> types.SimpleNamespace:
+        result: types.SimpleNamespace = types.SimpleNamespace()
+        for name in self._fields:
+            setattr(result, name, self._get_field(name).get())
+        for name in self._groups:
+            setattr(result, name, self._get_group(name).to_namespace())
+        return result
+
+    def _get_field(self, name: str) -> Var[Any]:
+        return getattr(self, name)
+
+    def _get_field_or_group(self, name: str) -> BaseConfig | Var[Any]:
+        return getattr(self, name)
+
+    def _get_group(self, name: str) -> BaseConfig:
+        return getattr(self, name)

liblaf_conf-0.1.0/src/liblaf/conf/_field.py

@@ -0,0 +1,43 @@
+import dataclasses
+from typing import Self, overload
+
+from . import converters
+from ._sentinel import MISSING, MissingType
+from ._types import ConfigProtocol, Converter, Factory
+from ._var import Var
+
+
+@dataclasses.dataclass(frozen=True, slots=True, weakref_slot=True)
+class Field[T]:
+    env: str | None = None
+    default: T | MissingType = MISSING
+    factory: Factory[T] | None = None
+    converter: Converter[T] = converters.identity
+    name: str = dataclasses.field(init=False)
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None = None) -> Var[T]: ...
+    def __get__(
+        self, instance: ConfigProtocol | None, owner: type | None = None
+    ) -> Self | Var[T]:
+        if instance is None:
+            return self
+        if self.name not in instance.__dict__:
+            instance.__dict__[self.name] = self._bind(instance)
+        return instance.__dict__[self.name]
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        object.__setattr__(self, "name", name)
+
+    def _bind(self, instance: ConfigProtocol) -> Var[T]:
+        name: str = instance.name + "." + self.name
+        env: str = self.env or instance.env_prefix + self.name.upper()
+        return Var(
+            name,
+            default=self.default,
+            factory=self.factory,
+            env=env,
+            converter=self.converter,
+        )

liblaf_conf-0.1.0/src/liblaf/conf/_field_specifiers.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import datetime
+import json
+from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from pydantic_extra_types.pendulum_dt import Date, DateTime, Duration, Time
+
+from . import converters
+from ._field import Field
+from ._sentinel import MISSING, MissingType
+from ._types import Converter, Factory
+
+if TYPE_CHECKING:
+    from _typeshed import StrPath
+
+
+def field_bool(
+    env: str | None = None,
+    default: bool | MissingType = MISSING,  # noqa: FBT001
+    factory: Factory[bool] | None = None,
+    converter: Converter[bool] | None = None,
+) -> Field[bool]:
+    if converter is None:
+        converter: Converter[bool] = converters.pydantic_type_adapter_validate_strings(
+            bool
+        )
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_date(
+    env: str | None = None,
+    default: Any | MissingType = MISSING,
+    factory: Factory[Any] | None = None,
+    converter: Converter[Any] | None = None,
+) -> Field[Any]:
+    if converter is None:
+        converter: Converter[datetime.date] = (
+            converters.pydantic_type_adapter_validate_strings(Date)
+        )
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_datetime(
+    env: str | None = None,
+    default: datetime.datetime | MissingType = MISSING,
+    factory: Factory[datetime.datetime] | None = None,
+    converter: Converter[datetime.datetime] | None = None,
+) -> Field[datetime.datetime]:
+    if converter is None:
+        converter: Converter[datetime.datetime] = (
+            converters.pydantic_type_adapter_validate_strings(DateTime)
+        )
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_decimal(
+    env: str | None = None,
+    default: Decimal | MissingType = MISSING,
+    factory: Factory[Decimal] | None = None,
+    converter: Converter[Decimal] | None = None,
+) -> Field[Decimal]:
+    if converter is None:
+        converter: Converter[Decimal] = Decimal
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_float(
+    env: str | None = None,
+    default: float | MissingType = MISSING,
+    factory: Factory[float] | None = None,
+    converter: Converter[float] | None = None,
+) -> Field[float]:
+    if converter is None:
+        converter: Converter[float] = float
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_int(
+    env: str | None = None,
+    default: int | MissingType = MISSING,
+    factory: Factory[int] | None = None,
+    converter: Converter[int] | None = None,
+) -> Field[int]:
+    if converter is None:
+        converter: Converter[int] = int
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_json(
+    env: str | None = None,
+    default: Any | MissingType = MISSING,
+    factory: Factory[Any] | None = None,
+    converter: Converter[Any] | None = None,
+) -> Field[Any]:
+    if converter is None:
+        converter: Converter[Any] = json.loads
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_list_str(
+    env: str | None = None,
+    default: list[str] | MissingType = MISSING,
+    factory: Factory[list[str]] | None = None,
+    converter: Converter[list[str]] | None = None,
+    delimiter: str = ",",
+) -> Field[list[str]]:
+    if converter is None:
+
+        def converter(value: str) -> list[str]:
+            return [item.strip() for item in value.split(delimiter)]
+
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_path(
+    env: str | None = None,
+    default: StrPath | MissingType = MISSING,
+    factory: Factory[StrPath] | None = None,
+    converter: Converter[Path] | None = None,
+) -> Field[Path]:
+    if converter is None:
+        converter: Converter[Path] = Path
+    if default is not MISSING:
+        default = Path(default)
+    if factory is not None:
+        wrapped: Factory[StrPath] = factory
+
+        def factory() -> Path:
+            return Path(wrapped())
+
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_str(
+    env: str | None = None,
+    default: str | MissingType = MISSING,
+    factory: Factory[str] | None = None,
+    converter: Converter[str] | None = None,
+) -> Field[str]:
+    if converter is None:
+        converter: Converter[str] = converters.identity
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_time(
+    env: str | None = None,
+    default: datetime.time | MissingType = MISSING,
+    factory: Factory[datetime.time] | None = None,
+    converter: Converter[datetime.time] | None = None,
+) -> Field[datetime.time]:
+    if converter is None:
+        converter: Converter[datetime.time] = (
+            converters.pydantic_type_adapter_validate_strings(Time)
+        )
+    return Field(env=env, default=default, factory=factory, converter=converter)
+
+
+def field_timedelta(
+    env: str | None = None,
+    default: datetime.timedelta | MissingType = MISSING,
+    factory: Factory[datetime.timedelta] | None = None,
+    converter: Converter[datetime.timedelta] | None = None,
+) -> Field[datetime.timedelta]:
+    if converter is None:
+        converter: Converter[datetime.timedelta] = (
+            converters.pydantic_type_adapter_validate_strings(Duration)
+        )
+    return Field(env=env, default=default, factory=factory, converter=converter)

liblaf_conf-0.1.0/src/liblaf/conf/_group.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Callable
+from typing import Self, overload
+
+
+@dataclasses.dataclass(frozen=True, slots=True, weakref_slot=True)
+class Group[T]:
+    factory: Callable[[], T]
+    name: str = dataclasses.field(init=False)
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None = None) -> T: ...
+    def __get__(self, instance: object | None, owner: type | None = None) -> Self | T:
+        if instance is None:
+            return self
+        if self.name not in instance.__dict__:
+            instance.__dict__[self.name] = self.factory()
+        return instance.__dict__[self.name]
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        object.__setattr__(self, "name", name)
+
+
+@overload
+def group[T](factory: type[T]) -> Group[T]: ...
+@overload
+def group[T](factory: Callable[[], T]) -> Group[T]: ...
+def group[T](factory: Callable[[], T]) -> Group[T]:
+    return Group(factory)

liblaf_conf-0.1.0/src/liblaf/conf/_sentinel.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class MissingType(enum.Enum):
+    MISSING = enum.auto()
+
+
+MISSING: MissingType = MissingType.MISSING

liblaf_conf-0.1.0/src/liblaf/conf/_types.py

@@ -0,0 +1,11 @@
+from collections.abc import Callable
+from typing import ClassVar, Protocol
+
+
+class ConfigProtocol(Protocol):
+    name: ClassVar[str]
+    env_prefix: ClassVar[str]
+
+
+type Converter[T] = Callable[[str], T]
+type Factory[T] = Callable[[], T]

liblaf_conf-0.1.0/src/liblaf/conf/_var.py

@@ -0,0 +1,86 @@
+import contextlib
+import contextvars
+import dataclasses
+import os
+from collections.abc import Generator
+from typing import Any, cast, overload
+
+from . import converters
+from ._sentinel import MISSING, MissingType
+from ._types import Converter, Factory
+
+
+@dataclasses.dataclass(init=False, frozen=True, slots=True, weakref_slot=True)
+class Var[T]:
+    env: str | None
+    converter: Converter[T]
+    _var: contextvars.ContextVar[T]
+
+    def __init__(
+        self,
+        name: str,
+        default: T | MissingType = MISSING,
+        factory: Factory[T] | None = None,
+        env: str | None = None,
+        converter: Converter[T] | None = None,
+    ) -> None:
+        if converter is None:
+            converter: Converter[T] = converters.identity
+        if env is not None:
+            value: str | None = os.getenv(env)
+            if value is not None:
+                default: T = cast("T", converter(value))
+        if default is MISSING and factory is not None:
+            default: T = factory()
+        if default is MISSING:
+            var: contextvars.ContextVar[T] = contextvars.ContextVar(name)
+        else:
+            var: contextvars.ContextVar[T] = contextvars.ContextVar(
+                name, default=default
+            )
+        object.__setattr__(self, "_var", var)
+        object.__setattr__(self, "env", env)
+        object.__setattr__(self, "converter", converter)
+
+    def __hash__(self) -> int:
+        return hash(self._var)
+
+    @property
+    def name(self) -> str:
+        return self._var.name
+
+    @overload
+    def get(self) -> T: ...
+    @overload
+    def get(self, default: T, /) -> T: ...
+    @overload
+    def get[D](self, default: D, /) -> D | T: ...
+    def get(self, default: Any = MISSING) -> T:
+        if default is MISSING:
+            return self._var.get()
+        return self._var.get(default)
+
+    def set(self, value: T) -> contextvars.Token[T]:
+        return self._var.set(value)
+
+    def reset(self, token: contextvars.Token[T]) -> None:
+        self._var.reset(token)
+
+    def load_env(self) -> None:
+        if self.env is None:
+            return
+        value: str | None = os.getenv(self.env)
+        if value is None:
+            return
+        if self.converter is None:
+            self.set(cast("T", value))
+        else:
+            self.set(self.converter(value))
+
+    @contextlib.contextmanager
+    def override(self, value: T) -> Generator[None]:
+        token: contextvars.Token[T] = self._var.set(value)
+        try:
+            yield
+        finally:
+            self._var.reset(token)

liblaf_conf-0.1.0/src/liblaf/conf/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

liblaf_conf-0.1.0/src/liblaf/conf/_version.pyi

@@ -0,0 +1,8 @@
+# ref: <https://github.com/ofek/hatch-vcs>
+# ref: <https://github.com/pypa/setuptools-scm/blob/58ed7d5dec0e3bc80190f73543cf4d8a6876ba8e/src/setuptools_scm/_integration/dump_version.py#L16-L51>
+__commit_id__: str | None
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+commit_id: str | None
+version_tuple: tuple[int | str, ...]
+version: str

liblaf_conf-0.1.0/src/liblaf/conf/converters/__init__.py

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

liblaf_conf-0.1.0/src/liblaf/conf/converters/__init__.pyi

@@ -0,0 +1,19 @@
+from ._misc import identity
+from ._pydantic import (
+    pydantic_model_validate,
+    pydantic_model_validate_json,
+    pydantic_model_validate_strings,
+    pydantic_type_adapter_validate_json,
+    pydantic_type_adapter_validate_python,
+    pydantic_type_adapter_validate_strings,
+)
+
+__all__ = [
+    "identity",
+    "pydantic_model_validate",
+    "pydantic_model_validate_json",
+    "pydantic_model_validate_strings",
+    "pydantic_type_adapter_validate_json",
+    "pydantic_type_adapter_validate_python",
+    "pydantic_type_adapter_validate_strings",
+]

liblaf_conf-0.1.0/src/liblaf/conf/converters/_misc.py

@@ -0,0 +1,2 @@
+def identity[T](x: T) -> T:
+    return x

liblaf_conf-0.1.0/src/liblaf/conf/converters/_pydantic.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pydantic
+
+if TYPE_CHECKING:
+    from liblaf.conf._field import Converter
+
+
+def pydantic_model_validate[T: pydantic.BaseModel](model: type[T]) -> Converter[T]:
+    return model.model_validate
+
+
+def pydantic_model_validate_json[T: pydantic.BaseModel](model: type[T]) -> Converter[T]:
+    return model.model_validate_json
+
+
+def pydantic_model_validate_strings[T: pydantic.BaseModel](
+    model: type[T],
+) -> Converter[T]:
+    return model.model_validate_strings
+
+
+def pydantic_type_adapter_validate_json[T](type_: type[T]) -> Converter[T]:
+    return pydantic.TypeAdapter(type_).validate_json
+
+
+def pydantic_type_adapter_validate_python[T](type_: type[T]) -> Converter[T]:
+    return pydantic.TypeAdapter(type_).validate_python
+
+
+def pydantic_type_adapter_validate_strings[T](type_: type[T]) -> Converter[T]:
+    return pydantic.TypeAdapter(type_).validate_strings