pydantic-parse 0.1.0__tar.gz

pydantic_parse-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mariia Redchuk
+
+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.

pydantic_parse-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pydantic-parse
+Version: 0.1.0
+Summary: Pydantic adaptor for argparse
+License-File: LICENSE
+Author: sagitta42
+Author-email: mariia.redchuk@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pydantic (>=2.13.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# pydantic-parse
+
+Pydantic adaptor for argparse
+
+Example
+```python
+
+def main():
+
+    class TestChoices(enum.StrEnum):
+        alice = "Alice"
+        bob = "Bob"
+
+    class TestModel(ArgModel):
+        name: TestChoices = ArgField(description="Name")
+        some_value: Optional[str] = ArgField(
+            description="value",
+            optional=True,
+            default=None,
+            flag=True
+        )
+        flag: bool = ArgField(description="flag", default=False, flag=True)
+
+    parser = PydanticArgParser()
+    parser.add_arguments_from_model(TestModel)
+    args = parser.parse_args()
+```
+
+CLI
+```bash
+my-package Alice --some-value 42
+```
+
+Results in `vars(args)`:
+
+```python
+{
+  'name': <TestChoices.alice: 'Alice'>,
+  'some_value': '42',
+  'flag': False
+}
+```
+
+Or of course
+```python
+model = TestModel(**vars(args))
+```
+
+gives
+```python
+TestModel
+name=<TestChoices.alice: 'Alice'> some_value='42' flag=False
+```
+
+-----
+*Made with [poetiq](https://pypi.org/project/poetiq)*
+

pydantic_parse-0.1.0/README.md

@@ -0,0 +1,56 @@
+# pydantic-parse
+
+Pydantic adaptor for argparse
+
+Example
+```python
+
+def main():
+
+    class TestChoices(enum.StrEnum):
+        alice = "Alice"
+        bob = "Bob"
+
+    class TestModel(ArgModel):
+        name: TestChoices = ArgField(description="Name")
+        some_value: Optional[str] = ArgField(
+            description="value",
+            optional=True,
+            default=None,
+            flag=True
+        )
+        flag: bool = ArgField(description="flag", default=False, flag=True)
+
+    parser = PydanticArgParser()
+    parser.add_arguments_from_model(TestModel)
+    args = parser.parse_args()
+```
+
+CLI
+```bash
+my-package Alice --some-value 42
+```
+
+Results in `vars(args)`:
+
+```python
+{
+  'name': <TestChoices.alice: 'Alice'>,
+  'some_value': '42',
+  'flag': False
+}
+```
+
+Or of course
+```python
+model = TestModel(**vars(args))
+```
+
+gives
+```python
+TestModel
+name=<TestChoices.alice: 'Alice'> some_value='42' flag=False
+```
+
+-----
+*Made with [poetiq](https://pypi.org/project/poetiq)*

pydantic_parse-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "pydantic-parse"
+version = "0.1.0"
+description = "Pydantic adaptor for argparse"
+authors = [
+    {name = "sagitta42",email = "mariia.redchuk@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic (>=2.13.5,<3.0.0)"
+]
+
+[project.scripts]
+pydantic-parse = "pydantic_parse.__main__:main"
+
+[tool.poetry]
+packages = [{include = "pydantic_parse", from = "src"}]
+
+[tool.poetiq]
+type = "package"
+settings = false
+progressbar = false
+my_base_model = false
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.1.1,<10.0.0)"
+]

pydantic_parse-0.1.0/src/pydantic_parse/__init__.py

@@ -0,0 +1,2 @@
+from pydantic_parse.__version__ import __version__
+from pydantic_parse.foo import is_answer as is_answer

pydantic_parse-0.1.0/src/pydantic_parse/__main__.py

@@ -0,0 +1,51 @@
+import argparse
+import enum
+import sys
+from typing import Optional
+
+from pydantic_parse.argparse.argument_parser import PydanticArgParser
+from pydantic_parse.argparse_model.field import ArgField
+from pydantic_parse.argparse_model.model import ArgModel
+from pydantic_parse.foo import is_answer
+from pydantic_parse.logger import logg
+
+
+def main():
+
+    class TestChoices(enum.StrEnum):
+        alice = "Alice"
+        bob = "Bob"
+
+    class TestModel(ArgModel):
+        name: TestChoices = ArgField(description="Name")
+        some_value: Optional[str] = ArgField(
+            description="value",
+            optional=True,
+            default=None,
+            flag=True
+        )
+        flag: bool = ArgField(description="flag", default=False, flag=True)
+
+    parser = PydanticArgParser()
+
+    parser.add_arguments_from_model(TestModel)
+
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(0)
+
+    args = parser.parse_args()
+
+    # subparsers = parser.add_subparsers(dest="command")
+    # foo_subparser = subparsers.add_parser("foo", help="foo functionalities")
+    # foo_subparser.add_argument("answer", type=int, help="Answer to check")
+
+    # output = is_answer(args.answer)
+    logg.info(vars(args))
+
+    model = TestModel(**vars(args))
+    logg.info(model)
+
+
+if __name__ == "__main__":
+    main()

pydantic_parse-0.1.0/src/pydantic_parse/__version__.py

@@ -0,0 +1,2 @@
+from importlib.metadata import version
+__version__ = version("pydantic-parse")

pydantic_parse-0.1.0/src/pydantic_parse/argparse/argument_parser.py

@@ -0,0 +1,46 @@
+import argparse
+from typing import Type
+
+from pydantic_parse.argparse_model.field import ArgFieldInfo
+from pydantic_parse.argparse_model.model import ArgModel
+
+
+class PydanticArgParser(argparse.ArgumentParser):
+    def add_arguments_from_model(self, model: Type[ArgModel]):
+        for arg_name, arg_info in model.arg_fields().items():
+            self.add_argument_from_field(arg_name, arg_info)
+
+    def add_argument_from_field(
+        self, name: str, arg_info: ArgFieldInfo, **kwargs
+    ) -> argparse.Action:
+        arg_name = name.replace("_", "-")
+        if arg_info.flag:
+            arg_name = f"--{arg_name}"
+
+        if arg_info.flag and arg_info.arg_type is bool:
+            return self.add_argument(
+                arg_name,
+                action="store_true",
+                default=False if arg_info.is_required() else arg_info.default,
+                help=arg_info.description,
+            )
+
+        # FIXME: currently for bool
+        # if default was set but is not optional,
+        # ends up giving None in default but allows to be not given
+        # in theory, no non-optional flags --> unify, currently quickfix
+        return super().add_argument(
+            arg_name,
+            type=arg_info.arg_type,
+            choices=arg_info.choices,
+            default=arg_info.default if arg_info.optional else None,
+            nargs=(
+                "?"
+                if (arg_info.flag and arg_info.informative)
+                or (not arg_info.flag and arg_info.optional)
+                else None
+            ),
+            const=arg_info.const if arg_info.flag and arg_info.informative else None,
+            help=arg_info.description,
+            **kwargs,
+        )

pydantic_parse-0.1.0/src/pydantic_parse/argparse_model/field.py

@@ -0,0 +1,105 @@
+import enum
+from typing import Any, Union, get_args, get_origin
+
+from pydantic import Field
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+# from pydantic.fields import _FieldInfoInputs,  _FieldInfoAsDict
+
+
+class ArgFieldInfo(FieldInfo):  # type: ignore[misc]
+    __slots__ = ("flag", "optional", "informative", "const")
+
+    def __init__(
+        self, flag: bool, optional: bool, informative: bool, const: Any, **kwargs: Any
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self.flag: bool = flag
+        self.optional: bool = optional
+        self.informative: bool = informative
+        self.const: Any = const
+
+    def as_dict(self) -> dict[str, Any]:
+        """
+        Serialize argument properties as dict.
+
+        Get FieldInfo serialization and extract annotation and attributes.
+        Add custom argument field info slots.
+        Ignore pydantic undefined properties.
+        """
+
+        ret = dict(self.asdict())
+        ret.pop("metadata")
+
+        attr: dict[str, Any] = ret.pop("attributes")
+        slots = {name: getattr(self, name) for name in self.__class__.__slots__}
+        full_attr = attr | slots
+        defined_attr = {
+            name: value
+            for name, value in full_attr.items()
+            if value is not PydanticUndefined
+        }
+
+        ret |= defined_attr
+
+        return ret
+
+    @property
+    def choices(self) -> list | None:
+        assert self.arg_type is not None
+        if issubclass(self.arg_type, enum.Enum):
+            ret = [item.value for item in self.arg_type]
+            return ret
+        return None
+
+    @classmethod
+    def from_field_info(
+        cls,
+        field_info: FieldInfo,
+        *,
+        flag: bool,
+        optional: bool,
+        informative: bool,
+        const: Any,
+    ) -> "ArgFieldInfo":
+        new = cls.__new__(cls)
+        for slot in FieldInfo.__slots__:
+            setattr(new, slot, getattr(field_info, slot))
+        new.flag = flag
+        new.optional = optional
+        new.informative = informative
+        new.const = const
+        return new
+
+    @property
+    def arg_type(self) -> type:
+        """
+        Get argument type from annotation.
+
+        Extract real type from type union to cover Optional[type] case.
+        """
+        # TODO: validator
+        assert self.annotation is not None
+        if get_origin(self.annotation) is Union:
+            types = get_args(self.annotation)
+            real_types = [tp for tp in types if not tp is type(None)]
+            # TODO: validator
+            assert len(real_types) == 1
+            return real_types[0]
+        return self.annotation
+
+
+def ArgField(
+    *,
+    flag: bool = False,
+    optional: bool = False,
+    informative: bool = False,
+    const: Any = None,
+    **kwargs: Any,
+) -> Any:
+    field_info = Field(**kwargs)
+    return ArgFieldInfo.from_field_info(
+        field_info, flag=flag, optional=optional, informative=informative, const=const
+    )

pydantic_parse-0.1.0/src/pydantic_parse/argparse_model/internal_attr.py

@@ -0,0 +1,17 @@
+import enum
+
+
+class InternalAttr(enum.StrEnum):
+    subparser = "subparser__"
+
+    @classmethod
+    def values(cls) -> list[str]:
+        return [c.value for c in cls]
+
+
+class AttrDescription(enum.StrEnum):
+    subparser = "Subparser"
+
+    @classmethod
+    def from_attr(cls, attr: InternalAttr) -> str:
+        return cls[attr.name].value

pydantic_parse-0.1.0/src/pydantic_parse/argparse_model/meta.py

@@ -0,0 +1,78 @@
+from typing import Any, Type
+
+from pydantic import BaseModel, Field
+
+from pydantic_parse.argparse_model.field import ArgField, ArgFieldInfo
+from pydantic_parse.argparse_model.internal_attr import AttrDescription, InternalAttr
+from pydantic_parse.exceptions import PydanticParseTypeError
+
+
+def nested_merge(first: dict, second: dict) -> dict:
+    for key, b_val in second.items():
+        if key in first and isinstance(first[key], dict) and isinstance(b_val, dict):
+            nested_merge(first[key], b_val)
+        else:
+            first[key] = b_val
+    return first
+
+
+class ArgModelMeta(type(BaseModel)):
+    """
+    Metaclass for ArgModel creation.
+
+    Takes care of fields hidden to user.
+    Requires model fields to be defined via ArgField rather than standard Field.
+    """
+
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[Type, ...],
+        namespace: dict[str, Any],
+        /,
+        # subparser: str | None = None,
+        **kwds: Any,
+    ):
+        namespace.setdefault("__annotations__", {})
+
+        # mcs._add_field_namespace_info(namespace, InternalAttr.subparser, subparser)
+
+        cls = super().__new__(mcs, name, bases, namespace, **kwds)
+
+        for field_name, field_info in getattr(cls, "__pydantic_fields__", {}).items():
+            if field_name in InternalAttr.values():
+                continue
+
+            if not isinstance(field_info, ArgFieldInfo):
+                raise PydanticParseTypeError(
+                    f"{cls.__name__}.{field_name} must be declared with {ArgField.__name__}(...), "
+                    f"not Field() or a bare default (got {type(field_info).__name__})"
+                )
+        return cls
+
+    @classmethod
+    def _add_field_namespace_info(
+        mcs, namespace: dict, field_name: InternalAttr, parameter: Any
+    ):
+        nested_merge(namespace, mcs._get_field_namespace_info(field_name, parameter))
+
+    @classmethod
+    def _get_field_namespace_info(
+        mcs, field_name: InternalAttr, parameter: Any
+    ) -> dict:
+        """
+        Create information to add to namespace to create field.
+
+        parameter: parameter to be added - defines annotation and default value.
+        name: field name
+
+        The default value is crucial to set fixed argument model parameters once during
+            child class definition.
+        """
+        ret = {
+            "__annotations__": {field_name: type(parameter)},
+            field_name: Field(
+                default=parameter, description=AttrDescription.from_attr(field_name)
+            ),
+        }
+        return ret

pydantic_parse-0.1.0/src/pydantic_parse/argparse_model/model.py

@@ -0,0 +1,72 @@
+from typing import Any, Self, Type
+
+from pydantic import BaseModel, model_validator
+
+from pydantic_parse.argparse_model.field import ArgFieldInfo
+from pydantic_parse.argparse_model.internal_attr import InternalAttr
+from pydantic_parse.argparse_model.meta import ArgModelMeta
+
+
+class ArgModel(BaseModel, metaclass=ArgModelMeta):
+    """
+    Argument model.
+
+    Defines a set of arguments, their type and description.
+    """
+
+    def arg_dump(self, **kwargs) -> dict[str, Any]:
+        """
+        Argument dump.
+
+        Model dump of arguments present in ArgModel instance.
+        Exclude internal attributes (non-arguments)
+
+        Arguments can be further excluded via exclude={name: True} in **kwargs.
+        Internal arguments however are always excluded.
+        User standard model_dump()
+        """
+        exclude_args = {key: True for key in InternalAttr}
+
+        if not "exclude" in kwargs:
+            kwargs["exclude"] = {}
+
+        kwargs["exclude"] |= exclude_args
+
+        return self.model_dump(**kwargs)
+
+    # @classmethod
+    # def subparser(cls) -> str:
+    #     """
+    #     Subparser.
+
+    #     Default value of internal field is set at child class definition.
+    #     """
+    #     ret = cls.model_fields[InternalAttr.subparser].default
+    #     return ret
+
+    # TODO: property like model_fields
+    @classmethod
+    def arg_fields(cls) -> dict[str, ArgFieldInfo]:
+        """
+        Model info that represent arguments.
+
+        Non-argument (internal) attribuges are skipped.
+        """
+        ret = {
+            field_name: field_info
+            for field_name, field_info in cls.model_fields.items()
+            if not field_name in InternalAttr
+        }
+
+        return ret
+
+    # @model_validator(mode="before")
+    # def check_hidden(self) -> Self:
+    #     # TODO: check that hidden fields have not been given in input; raise error that they are reserved
+    #     # raise ValueError("Provide subparser in your ArgModel class definition!")
+    #     return self
+
+    @model_validator(mode="before")
+    def check_field_info(self) -> Self:
+        # TODO: mode-before model validator that all fields have a description and annotation
+        return self

pydantic_parse-0.1.0/src/pydantic_parse/exceptions.py

@@ -0,0 +1,2 @@
+class PydanticParseTypeError(TypeError):
+    pass

pydantic_parse-0.1.0/src/pydantic_parse/foo.py

@@ -0,0 +1,5 @@
+def is_answer(x: int) -> bool:
+    """
+    Checks if input is answer to the question of life, universe, and everything.
+    """
+    return x == 42

pydantic_parse-0.1.0/src/pydantic_parse/logger.py

@@ -0,0 +1,154 @@
+import enum
+import inspect
+import logging
+from pathlib import Path
+from typing import Any
+from dotenv import dotenv_values
+
+
+class AnsiStyle(enum.StrEnum):
+    normal = "0"
+    bold = "1"
+    start = "\033["
+    end = "\033[0m"
+    fg8bit = "38;5"
+
+
+class AnsiColor(enum.StrEnum):
+    green = "32"
+    grey = "90"
+    red = "31"
+    yellow = "33"
+    white = "37"
+    lila = "91"
+
+    def apply(self, message: Any, bold: bool = False) -> str:
+        """
+        To be used with color based.
+
+        Bold not implemented for 8 bit colors.
+        """
+        if self.is_8bit:
+            style = AnsiStyle.fg8bit
+        else:
+            style = AnsiStyle.bold if bold else AnsiStyle.normal
+
+        ret = f"{AnsiStyle.start}{style};{self}m{message}{AnsiStyle.end}"
+        return ret
+
+    def bold(self, message: Any) -> str:
+        """
+        Shortcut for bold colored text
+        """
+        ret = self.apply(message, bold=True)
+        return ret
+
+    @property
+    def is_8bit(self) -> bool:
+        return self == AnsiColor.lila
+
+
+class LevelFormatter(logging.Formatter):
+    def __init__(self, formats, default_fmt=None, datefmt=None):
+        super().__init__(datefmt=datefmt)
+        self.formats = {
+            level: logging.Formatter(fmt, datefmt=datefmt)
+            for level, fmt in formats.items()
+        }
+        self.default_formatter = logging.Formatter(
+            default_fmt or "%(message)s", datefmt=datefmt
+        )
+
+    def format(self, record):
+        formatter = self.formats.get(record.levelno, self.default_formatter)
+        return formatter.format(record)
+
+
+class Logger:
+    def __init__(self, log_level=logging.INFO):
+        self.log_level = log_level
+
+        self._logger = logging.getLogger(__name__)
+
+        full_format = "%(asctime)s [%(levelname)s] %(classname)s.%(funcName)s:%(lineno)d - %(message)s"
+        short_format = "[%(levelname)s] %(classname)s - %(message)s"
+        no_format = ""
+        level_format = full_format if log_level == logging.DEBUG else no_format
+        formatter = LevelFormatter(
+            {
+                logging.DEBUG: full_format,
+                logging.ERROR: level_format,
+                logging.INFO: level_format,
+                logging.WARNING: level_format,
+            }
+        )
+
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        handler.setLevel(log_level)
+        self._logger.addHandler(handler)
+
+        self._logger.setLevel(log_level)
+        self._logger.propagate = False
+
+    def info(self, message: Any, header: bool = False, poetiq: bool = False):
+        if poetiq:
+            color = AnsiColor.lila
+        elif header:
+            color = AnsiColor.green
+        else:
+            color = AnsiColor.white
+
+        return self._log(logging.INFO, color.apply(message, header))
+
+    def error(self, message: Any):
+        return self._log(logging.ERROR, AnsiColor.red.apply(message))
+
+    def warning(self, message: Any, important: bool = False):
+        if important:
+            message = f"! WARNING ! {message}"
+        return self._log(logging.WARNING, AnsiColor.yellow.apply(message, important))
+
+    def debug(self, message: Any):
+        return self._log(logging.DEBUG, AnsiColor.grey.apply(message))
+
+    @property
+    def is_debug(self) -> bool:
+        return self.log_level == logging.DEBUG
+
+    def _log(self, level, message: Any):
+        """
+        Common log interface for info/error/warning/debug.
+
+        Auto-detect class name of caller.
+        Account for stack level to display correct funcName and lineno.
+            Skip 2 stack levels including this method,
+            the info/error/warning/debug method calling it,
+        """
+        self._logger.log(
+            level,
+            message,
+            extra={"classname": self._get_caller_class_name()},
+            stacklevel=3,
+        )
+
+    def _get_caller_class_name(self):
+        """
+        Determine class name of where logger is called from.
+
+        Obtain frame index 3 corresponding to actual caller
+            (0 = this method, 1 = _log internal method, 2 = info/warning/error/debug logger call).
+        Return class or module name of that frame.
+        """
+        frame = inspect.stack()[3].frame
+        if "self" in frame.f_locals:
+            return type(frame.f_locals["self"]).__name__
+        elif "cls" in frame.f_locals:
+            return frame.f_locals["cls"].__name__
+        return frame.f_globals.get("__name__", "-")
+
+
+# NOTE: dotenv_values() in some cases yielded empty .env for unexplained reason
+env_config = dotenv_values(Path.cwd() / ".env")
+is_debug = env_config.get("DEBUG_PYDANTIC_PARSE", "").lower() in ("true", "1")
+logg = Logger(log_level=logging.DEBUG if is_debug else logging.INFO)