p2a 0.1.0__py3-none-any.whl

p2a/__init__.py

@@ -0,0 +1,3 @@
+from .model import *
+
+__version__ = "0.1.0"

p2a/model.py

@@ -0,0 +1,527 @@
+import sys
+from argparse import ArgumentParser
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Type, Union, get_args, get_origin
+
+from pkn.logging import getSimpleLogger
+
+try:
+    from pydantic import BaseModel, TypeAdapter, ValidationError
+    from pydantic_core import PydanticUndefined
+except ImportError:
+    raise ImportError("pydantic is required to use p2a")
+
+__all__ = (
+    "create_model_parser",
+    "parse_extra_args_model",
+)
+
+_log = None
+
+
+def _initlog(level: str = "WARNING"):
+    global _log
+    _log = getSimpleLogger("p2a")
+    _log.setLevel(level)
+
+
+_initlog()
+
+
+def _add_argument(parser: ArgumentParser, name: str, arg_type: type, default_value, **kwargs):
+    _log.debug(f"Adding argument: {name:<75} - {str(arg_type):<10} - {str(default_value):<10}")
+    if "action" in kwargs:
+        parser.add_argument(name, default=default_value, action=kwargs["action"])
+    else:
+        parser.add_argument(name, type=arg_type, default=default_value, **kwargs)
+
+
+def parse_extra_args(subparser: Optional[ArgumentParser] = None, argv: List[str] = None) -> List[str]:
+    if subparser is None:
+        subparser = ArgumentParser(prog="p2a", allow_abbrev=False)
+
+    kwargs, extras = subparser.parse_known_args(argv or sys.argv)
+    return vars(kwargs), extras
+
+
+def _is_supported_type(field_type: type) -> bool:
+    if get_origin(field_type) is Optional:
+        field_type = get_args(field_type)[0]
+    elif get_origin(field_type) is Union:
+        non_none_types = [t for t in get_args(field_type) if t is not type(None)]
+        if all(_is_supported_type(t) for t in non_none_types):
+            return True
+        if len(non_none_types) == 1:
+            field_type = non_none_types[0]
+    elif get_origin(field_type) is Literal:
+        return all(isinstance(arg, (str, int, float, bool, Enum)) for arg in get_args(field_type))
+    if not isinstance(field_type, type):
+        return False
+    return field_type in (str, int, float, bool) or issubclass(field_type, Enum)
+
+
+def _recurse_add_fields(parser: ArgumentParser, model: Union["BaseModel", Type["BaseModel"]], prefix: str = ""):
+    # Model is required
+    if model is None:
+        raise ValueError("Model instance cannot be None")  # coverage: ignore
+
+    # Extract the fields from a model instance or class
+    if isinstance(model, type):
+        model_fields = model.model_fields
+    else:
+        model_fields = model.__class__.model_fields
+
+    # For each available field, add an argument to the parser
+    for field_name, field in model_fields.items():
+        # Grab the annotation to map to type
+        field_type = field.annotation
+        # Build the argument name converting underscores to dashes
+        arg_name = f"--{prefix.replace('_', '-')}{field_name.replace('_', '-')}"
+
+        # If theres an instance, use that so we have concrete values
+        model_instance = model if not isinstance(model, type) else None
+
+        # If we have an instance, grab the field value
+        field_instance = getattr(model_instance, field_name, None) if model_instance else None
+
+        # MARK: Wrappers:
+        #  - Optional[T]
+        #  - Union[T, None]
+        if get_origin(field_type) is Optional:
+            field_type = get_args(field_type)[0]
+        elif get_origin(field_type) is Union:
+            non_none_types = [t for t in get_args(field_type) if t is not type(None)]
+            if len(non_none_types) == 1:
+                field_type = non_none_types[0]
+            else:
+                _log.warning(f"Unsupported Union type for argument '{field_name}': {field_type}")
+                continue
+
+        # Default value, promote PydanticUndefined to None
+        if field.default is PydanticUndefined:
+            default_value = None
+        elif field_instance:
+            default_value = field_instance
+        else:
+            default_value = field.default
+
+        # Handled types
+        # - bool, str, int, float
+        # - Enum
+        # - Path
+        # - Nested BaseModel
+        # - Literal
+        # - List[T]
+        #    - where T is bool, str, int, float, Enum
+        #    - List[BaseModel] where we have an instance to recurse into
+        # - Dict[K, V]
+        #   - where K is bool, str, int, float, Enum
+        #   - where V is bool, str, int, float, Enum, BaseModel
+        #   - Dict[K, BaseModel] where we have an instance to recurse into
+        if field_type is bool:
+            #############
+            # MARK: bool
+            _add_argument(
+                parser=parser, name=arg_name, arg_type=bool, default_value=default_value, action="store_true" if not default_value else "store_false"
+            )
+        elif field_type in (str, int, float):
+            ########################
+            # MARK: str, int, float
+            try:
+                _add_argument(parser=parser, name=arg_name, arg_type=field_type, default_value=default_value)
+            except TypeError:
+                # TODO: handle more complex types if needed
+                _add_argument(parser=parser, name=arg_name, arg_type=str, default_value=default_value)
+        elif isinstance(field_type, type) and issubclass(field_type, Enum):
+            #############
+            # MARK: Enum
+            enum_choices = [e.value for e in field_type]
+            _add_argument(parser=parser, name=arg_name, arg_type=type(enum_choices[0]), default_value=default_value, choices=enum_choices)
+        elif isinstance(field_type, type) and issubclass(field_type, Path):
+            #############
+            # MARK: Path
+            # Promote to/from string
+            _add_argument(parser=parser, name=arg_name, arg_type=str, default_value=str(default_value) if isinstance(default_value, Path) else None)
+        elif isinstance(field_instance, BaseModel):
+            ############################
+            # MARK: instance(BaseModel)
+            # Nested model, add its fields with a prefix
+            _recurse_add_fields(parser, field_instance, prefix=f"{field_name}.")
+        elif isinstance(field_type, Type) and issubclass(field_type, BaseModel):
+            ########################
+            # MARK: type(BaseModel)
+            # Nested model class, add its fields with a prefix
+            _recurse_add_fields(parser, field_type, prefix=f"{field_name}.")
+        elif get_origin(field_type) is Literal:
+            ################
+            # MARK: Literal
+            literal_args = get_args(field_type)
+            if not all(isinstance(arg, (str, int, float, bool, Enum)) for arg in literal_args):
+                # Only support simple literal types for now
+                _log.warning(f"Only Literal types of str, int, float, or bool are supported - field `{field_name}` got {literal_args}")
+                continue
+            ####################################
+            # MARK: Literal[str|int|float|bool]
+            _add_argument(parser=parser, name=arg_name, arg_type=type(literal_args[0]), default_value=default_value)
+        elif get_origin(field_type) in (list, List):
+            ################
+            # MARK: List[T]
+            if get_args(field_type) and not _is_supported_type(get_args(field_type)[0]):
+                # If theres already something here, we can procede by adding the command with a positional indicator
+                if field_instance:
+                    for i, value in enumerate(field_instance):
+                        if isinstance(value, BaseModel):
+                            ########################
+                            # MARK: List[BaseModel]
+                            _recurse_add_fields(parser, value, prefix=f"{field_name}.{i}.")
+                            continue
+                        else:
+                            ########################
+                            # MARK: List[str|int|float|bool]
+                            _add_argument(
+                                parser=parser,
+                                name=f"{arg_name}.{i}",
+                                arg_type=type(value),
+                                default_value=value,
+                            )
+                    continue
+                # If there's nothing here, we don't know how to address them
+                # TODO: we could just prefill e.g. --field.0, --field.1 up to some limit
+                _log.warning(f"Only lists of str, int, float, or bool are supported - field `{field_name}` got {get_args(field_type)[0]}")
+                continue
+            if field_instance:
+                for i, value in enumerate(field_instance):
+                    ########################
+                    # MARK: List[str|int|float|bool]
+                    _add_argument(
+                        parser=parser,
+                        name=f"{arg_name}.{i}",
+                        arg_type=type(value),
+                        default_value=value,
+                    )
+            #################################
+            # MARK: List[str|int|float|bool]
+            _add_argument(
+                parser=parser, name=arg_name, arg_type=str, default_value=",".join(map(str, default_value)) if isinstance(field, str) else None
+            )
+        elif get_origin(field_type) in (dict, Dict):
+            ######################
+            # MARK: Dict[str, T]
+            key_type, value_type = get_args(field_type)
+
+            if not _is_supported_type(key_type):
+                # Check Key type, must be str, int, float, bool, enum
+                _log.warning(f"Only dicts with str, int, float, bool, or enum keys are supported - field `{field_name}` got key type {key_type}")
+                continue
+
+            if isinstance(key_type, type) and issubclass(key_type, Enum):
+                # If key is enum, we can fully enumerate
+
+                if not _is_supported_type(value_type) and not (isinstance(value_type, type) and issubclass(value_type, BaseModel)):
+                    # Unsupported value type
+                    _log.warning(
+                        f"Only dicts with str, int, float, bool, enum, or BaseModel values are supported - field `{field_name}` got value type {value_type}"
+                    )
+                    continue
+
+                if isinstance(value_type, type) and issubclass(value_type, BaseModel):
+                    # Add each submodel recursively, if it exists on the instance
+                    #############################
+                    # MARK: Dict[Enum, BaseModel]
+                    for enum_key in key_type:
+                        if not field_instance or enum_key not in field_instance:
+                            continue
+                        _recurse_add_fields(parser, (field_instance or {}).get(enum_key, value_type), prefix=f"{field_name}.{enum_key.name}.")
+                        _recurse_add_fields(parser, (field_instance or {}).get(enum_key, value_type), prefix=f"{field_name}.{enum_key.value}.")
+
+                elif _is_supported_type(value_type):
+                    # Add directly
+                    ###################
+                    # MARK: Dict[Enum, str|int|float|bool]
+
+                    for enum_key in key_type:
+                        value = (field_instance or {}).get(enum_key, default_value.get(enum_key) if default_value else None)
+                        _add_argument(
+                            parser=parser,
+                            name=f"{arg_name}.{enum_key.name}",
+                            arg_type=value_type,
+                            default_value=value,
+                        )
+                        _add_argument(
+                            parser=parser,
+                            name=f"{arg_name}.{enum_key.value}",
+                            arg_type=value_type,
+                            default_value=value,
+                        )
+
+            if not _is_supported_type(value_type) and not field_instance:
+                # Check Value type, must be str, int, float, bool if an instance isnt provided
+                _log.warning(
+                    f"Only dicts with str, int, float, bool, or enum values are supported - field `{field_name}` got value type {value_type}"
+                )
+                continue
+
+            # If theres already something here, we can procede by adding the command by keyword
+            if field_instance:
+                if all(isinstance(v, BaseModel) for v in field_instance.values()):
+                    #############################
+                    # MARK: Dict[str, BaseModel]
+                    for key, value in field_instance.items():
+                        if isinstance(key, Enum):
+                            # Already handled above
+                            continue
+                        _recurse_add_fields(parser, value, prefix=f"{field_name}.{key}.")
+                    continue
+
+                # If we have mixed, we don't support
+                elif any(isinstance(v, BaseModel) for v in field_instance.values()):
+                    _log.warning(f"Mixed dict value types are not supported - field `{field_name}` has mixed BaseModel and non-BaseModel values")
+                    continue
+
+                # If we have non BaseModel values, we can still add a parser by route
+                if all(isinstance(v, (str, int, float, bool, Enum)) for v in field_instance.values()):
+                    # We can set "known" values here
+                    for key, value in field_instance.items():
+                        if isinstance(key, Enum):
+                            # Already handled above
+                            continue
+                        if isinstance(value, Enum):
+                            value = value.name
+                        ##########################################
+                        # MARK: Dict[str, str|int|float|bool]
+                        _add_argument(
+                            parser=parser,
+                            name=f"{arg_name}.{key}",
+                            arg_type=type(value),
+                            default_value=value,
+                        )
+                        # NOTE: don't continue to allow adding the full setter below
+
+            # Finally add the full setter for unknown values
+            ##########################################
+            # MARK: Dict[str, str|int|float|bool|str|Enum]
+            defaults = []
+            for k, v in (default_value or {}).items():
+                if isinstance(k, Enum):
+                    defaults.append(f"{k.name}={v}")
+                    defaults.append(f"{k.value}={v}")
+                else:
+                    defaults.append(f"{k}={v}")
+            _add_argument(parser=parser, name=arg_name, arg_type=str, default_value=",".join(defaults) if defaults else None)
+        else:
+            _log.warning(f"Unsupported field type for argument '{field_name}': {field_type}")
+    return parser
+
+
+def create_model_parser(model: "BaseModel") -> ArgumentParser:
+    # Recursively parse fields from a pydantic model and its sub-models
+    # and create an argument parser to parse extra args
+    parser = ArgumentParser(prog="hatch-build-extras-model", allow_abbrev=False)
+    parser = _recurse_add_fields(parser, model)
+    return parser
+
+
+def parse_extra_args_model(model: "BaseModel"):
+    # Parse the extra args and update the model
+    args, kwargs = parse_extra_args(create_model_parser(model))
+
+    for key, value in args.items():
+        # Handle nested fields
+        if "." in key:
+            # We're going to walk down the model tree to get to the right sub-model
+            parts = key.split(".")
+
+            # Accounting
+            sub_model = model
+            parent_model = None
+
+            for i, part in enumerate(parts[:-1]):
+                if part.isdigit() and isinstance(sub_model, list):
+                    # List index
+                    index = int(part)
+
+                    # Should never be out of bounds, but check to be sure
+                    if index >= len(sub_model):
+                        raise IndexError(
+                            f"Index {index} out of range for field '{parts[i - 1]}' on model '{parent_model.__class__.__name__}'"
+                        )  # coverage: ignore
+
+                    # Grab the model instance from the list
+                    model_to_set = sub_model[index]
+                elif isinstance(sub_model, dict):
+                    # Dict key
+
+                    # If its an enum, we may need to match by name or value
+                    for k in sub_model.keys():
+                        if isinstance(k, Enum):
+                            if k.name == part or k.value == part:
+                                part = k
+                                break
+
+                    # Should always exist, but check to be sure
+                    if part not in sub_model:
+                        raise KeyError(
+                            f"Key '{part}' not found for field '{parts[i - 1]}' on model '{parent_model.__class__.__name__}'"
+                        )  # coverage: ignore
+
+                    # Grab the model instance from the dict
+                    model_to_set = sub_model[part]
+                else:
+                    model_to_set = getattr(sub_model, part)
+
+                if model_to_set is None:
+                    # Create a new instance of model
+                    field = sub_model.__class__.model_fields[part]
+
+                    # if field annotation is an optional or union with none, extract type
+                    if get_origin(field.annotation) is Optional:
+                        model_to_instance = get_args(field.annotation)[0]
+                    elif get_origin(field.annotation) is Union:
+                        non_none_types = [t for t in get_args(field.annotation) if t is not type(None)]
+                        if len(non_none_types) == 1:
+                            model_to_instance = non_none_types[0]
+
+                    else:
+                        model_to_instance = field.annotation
+                    if not isinstance(model_to_instance, type) or not issubclass(model_to_instance, BaseModel):
+                        raise ValueError(
+                            f"Cannot create sub-model for field '{part}' on model '{sub_model.__class__.__name__}': - type is {model_to_instance}"
+                        )
+                    model_to_set = model_to_instance()
+                    setattr(sub_model, part, model_to_set)
+
+                parent_model = sub_model
+                sub_model = model_to_set
+
+            key = parts[-1]
+        else:
+            # Accounting
+            sub_model = model
+            parent_model = model
+            model_to_set = model
+
+        if not isinstance(model_to_set, BaseModel):
+            if isinstance(model_to_set, dict):
+                if value is None:
+                    continue
+
+                # We allow setting dict values directly
+                # Grab the dict from the parent model, set the value, and continue
+                if key in model_to_set:
+                    model_to_set[key] = value
+                elif key.replace("_", "-") in model_to_set:
+                    # Argparse converts dashes back to underscores, so undo
+                    model_to_set[key.replace("_", "-")] = value
+                elif key in [k.name for k in model_to_set.keys() if isinstance(k, Enum)]:
+                    enum_key = [k for k in model_to_set.keys() if isinstance(k, Enum) and k.name == key][0]
+                    model_to_set[enum_key] = value
+                elif key in [k.value for k in model_to_set.keys() if isinstance(k, Enum)]:
+                    enum_key = [k for k in model_to_set.keys() if isinstance(k, Enum) and k.value == key][0]
+                    model_to_set[enum_key] = value
+                elif (
+                    get_args(parent_model.__class__.model_fields[part].annotation)
+                    and isinstance(get_args(parent_model.__class__.model_fields[part].annotation)[0], type)
+                    and issubclass(get_args(parent_model.__class__.model_fields[part].annotation)[0], Enum)
+                ):
+                    enum_type = get_args(parent_model.__class__.model_fields[part].annotation)[0]
+                    for enum_key in enum_type:
+                        if enum_key.name == key or enum_key.value == key:
+                            key = enum_key
+                            break
+                    else:
+                        raise KeyError(f"Key '{key}' not found for dict field on model '{parent_model.__class__.__name__}'")  # coverage: ignore
+                    model_to_set[key] = value
+                else:
+                    raise KeyError(f"Key '{key}' not found for dict field on model '{parent_model.__class__.__name__}'")  # coverage: ignore
+
+                _log.debug(f"Set dict key '{key}' on parent model '{parent_model.__class__.__name__}' with value '{value}'")
+
+                # Now adjust our variable accounting to set the whole dict back on the parent model,
+                # allowing us to trigger any validation
+                key = part
+                value = model_to_set
+                model_to_set = parent_model
+            elif isinstance(model_to_set, list):
+                if value is None:
+                    continue
+
+                # We allow setting list values directly
+                # Grab the list from the parent model, set the value, and continue
+                model_to_set[int(key)] = value
+
+                _log.debug(f"Set list index '{key}' on parent model '{parent_model.__class__.__name__}' with value '{value}'")
+
+                # Now adjust our variable accounting to set the whole dict back on the parent model,
+                # allowing us to trigger any validation
+                key = part
+                value = model_to_set
+                model_to_set = parent_model
+            else:
+                _log.warning(f"Cannot set field '{key}' on non-BaseModel instance of type '{type(model_to_set).__name__}'. value: `{value}`")
+                continue
+
+        # Grab the field from the model class and make a type adapter
+        field = model_to_set.__class__.model_fields[key]
+        adapter = TypeAdapter(field.annotation)
+
+        if value is not None:
+            _log.debug(f"Setting field '{key}' on model '{model_to_set.__class__.__name__}' with raw value '{value}'")
+
+            # Convert the value using the type adapter
+            if get_origin(field.annotation) in (list, List):
+                if isinstance(value, list):
+                    # Already a list, use as is
+                    pass
+                elif isinstance(value, str):
+                    # Convert from comma-separated values
+                    value = value.split(",")
+                else:
+                    # Unknown, raise
+                    raise ValueError(f"Cannot convert value '{value}' to list for field '{key}'")
+            elif get_origin(field.annotation) in (dict, Dict):
+                if isinstance(value, dict):
+                    # Already a dict, use as is
+                    pass
+                elif isinstance(value, str):
+                    # Convert from comma-separated key=value pairs
+                    dict_items = value.split(",")
+                    dict_value = {}
+                    for item in dict_items:
+                        if item:
+                            k, v = item.split("=", 1)
+                            # If the key type is an enum, convert
+                            dict_value[k] = v
+
+                    # Grab any previously existing dict to preserve other keys
+                    existing_dict = getattr(model_to_set, key, {}) or {}
+                    _log.debug(f"Existing dict for field '{key}': {existing_dict}")
+                    _log.debug(f"New dict items for field '{key}': {dict_value}")
+                    dict_value.update(existing_dict)
+                    value = dict_value
+                else:
+                    # Unknown, raise
+                    raise ValueError(f"Cannot convert value '{value}' to dict for field '{key}'")
+            try:
+                # Post process and convert keys if needed
+                # pydantic shouldve done this automatically, but alas
+                if isinstance(value, dict) and get_args(field.annotation):
+                    key_type = get_args(field.annotation)[0]
+                    if isinstance(key_type, type) and issubclass(key_type, Enum):
+                        for enum_key in key_type:
+                            if enum_key.name in value:
+                                v = value.pop(enum_key.name)
+                                if value.get(enum_key) is None:
+                                    value[enum_key] = v
+
+                value = adapter.validate_python(value)
+
+                # Set the value on the model
+                setattr(model_to_set, key, value)
+            except ValidationError:
+                _log.warning(f"Failed to validate field '{key}' with value '{value}' for model '{model_to_set.__class__.__name__}'")
+                continue
+        else:
+            _log.debug(f"Skipping setting field '{key}' on model '{model_to_set.__class__.__name__}' with None value")
+
+    return model, kwargs

p2a/tests/test_model.py

@@ -0,0 +1,189 @@
+import sys
+from enum import Enum
+from io import StringIO
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Union
+from unittest.mock import patch
+
+from pydantic import BaseModel
+
+from p2a import parse_extra_args_model
+from p2a.model import _initlog
+
+
+class MyEnum(Enum):
+    OPTION_A = "option_a"
+    OPTION_B = "option_b"
+    OPTION_C = "option_c"
+
+
+class SubModel(BaseModel, validate_assignment=True):
+    sub_arg: int = 42
+    sub_arg_with_value: str = "sub_default"
+    sub_arg_enum: MyEnum = MyEnum.OPTION_A
+    sub_arg_literal: Literal["x", "y", "z"] = "x"
+
+
+class MyTopLevelModel(BaseModel, validate_assignment=True):
+    extra_arg: bool = False
+    extra_arg_with_value: str = "default"
+    extra_arg_with_value_equals: Optional[str] = "default_equals"
+    extra_arg_literal: Literal["a", "b", "c"] = "a"
+
+    enum_arg: MyEnum = MyEnum.OPTION_A
+    list_arg: List[int] = [1, 2, 3]
+    dict_arg: Dict[str, str] = {}
+    dict_arg_default_values: Dict[str, str] = {"existing-key": "existing-value"}
+    path_arg: Path = Path(".")
+
+    list_literal: List[Literal["a", "b", "c"]] = ["a"]
+    dict_literal_key: Dict[Literal["a", "b", "c"], str] = {"a": "first"}
+    dict_literal_value: Dict[str, Literal["a", "b", "c"]] = {"first": "a"}
+
+    list_enum: List[MyEnum] = [MyEnum.OPTION_A]
+    dict_enum: Dict[str, MyEnum] = {"first": MyEnum.OPTION_A}
+    dict_enum_key: Dict[MyEnum, str] = {MyEnum.OPTION_A: "first"}
+    dict_enum_key_model_value: Dict[MyEnum, SubModel] = {MyEnum.OPTION_A: SubModel()}
+
+    submodel: SubModel
+    submodel2: SubModel = SubModel(sub_args=84, sub_arg_with_value="predefined", sub_arg_enum=MyEnum.OPTION_B, sub_arg_literal="z")
+    submodel3: Optional[SubModel] = None
+
+    submodel_list_instanced: List[SubModel] = [SubModel()]
+    submodel_dict_instanced: Dict[str, SubModel] = {"a": SubModel()}
+
+    unsupported_literal: Literal[b"test"] = b"test"
+    unsupported_dict: Dict[SubModel, str] = {}
+    unsupported_dict_mixed_types: Dict[str, Union[str, SubModel]] = {}
+    unsupported_random_type: Optional[set] = None
+
+    unsupported_submodel_list: List[SubModel] = []
+    unsupported_submodel_dict: Dict[str, SubModel] = {}
+
+
+class TestCLIMdel:
+    def test_get_arg_from_model(self):
+        with (
+            patch.object(
+                sys,
+                "argv",
+                [
+                    "--extra-arg",
+                    "--extra-arg-with-value",
+                    "value",
+                    "--extra-arg-with-value-equals=value2",
+                    "--extra-arg-not-in-parser",
+                    "--extra-arg-literal",
+                    "b",
+                    "--enum-arg",
+                    "option_b",
+                    "--list-arg",
+                    "1,2,3",
+                    "--dict-arg",
+                    "key1=value1,key2=value2",
+                    "--dict-arg-default-values.existing-key",
+                    "new-value",
+                    "--path-arg",
+                    "/some/path",
+                    "--list-literal",
+                    "a,b",
+                    "--dict-literal-key.a",
+                    "first",
+                    "--dict-literal-value.first",
+                    "a",
+                    "--list-enum",
+                    "option_a,option_b",
+                    "--dict-enum.first",
+                    "option_b",
+                    "--dict-enum-key.option_b",
+                    "second",
+                    "--dict-enum-key.OPTION_C",
+                    "third",
+                    "--dict-enum-key-model-value.option-a.sub-arg",
+                    "600",
+                    "--submodel.sub-arg",
+                    "100",
+                    "--submodel.sub-arg-with-value",
+                    "sub_value",
+                    "--submodel.sub-arg-enum",
+                    "option_a",
+                    "--submodel.sub-arg-literal",
+                    "y",
+                    "--submodel2.sub-arg",
+                    "200",
+                    "--submodel2.sub-arg-with-value",
+                    "sub_value2",
+                    "--submodel3.sub-arg",
+                    "300",
+                    "--submodel-list-instanced.0.sub-arg",
+                    "400",
+                    "--submodel-list-instanced.0.sub-arg-with-value",
+                    "list_value",
+                    "--submodel-list-instanced.0.sub-arg-enum",
+                    "option_b",
+                    "--submodel-list-instanced.0.sub-arg-literal",
+                    "z",
+                    "--submodel-dict-instanced.a.sub-arg",
+                    "500",
+                ],
+            ),
+            patch("sys.stderr", new_callable=StringIO) as mock_stderr,
+        ):
+            _initlog("DEBUG")
+            model, extras = parse_extra_args_model(MyTopLevelModel(submodel=SubModel()))
+
+        assert len(extras) == 1
+        assert "--extra-arg-not-in-parser" in extras
+
+        assert model.extra_arg is True
+        assert model.extra_arg_with_value == "value"
+        assert model.extra_arg_with_value_equals == "value2"
+        assert model.extra_arg_literal == "b"
+
+        assert model.enum_arg == MyEnum.OPTION_B
+        assert model.list_arg == [1, 2, 3]
+        assert model.dict_arg == {"key1": "value1", "key2": "value2"}
+        assert model.dict_arg_default_values == {"existing-key": "new-value"}
+        assert model.path_arg == Path("/some/path")
+
+        assert model.list_literal == ["a", "b"]
+        assert model.dict_literal_key == {"a": "first"}
+        assert model.dict_literal_value == {"first": "a"}
+
+        assert model.list_enum == [MyEnum.OPTION_A, MyEnum.OPTION_B]
+        assert model.dict_enum == {"first": MyEnum.OPTION_B}
+        assert model.dict_enum_key == {MyEnum.OPTION_A: "first", MyEnum.OPTION_B: "second", MyEnum.OPTION_C: "third"}
+        assert model.dict_enum_key_model_value[MyEnum.OPTION_A].sub_arg == 600
+
+        assert model.submodel.sub_arg == 100
+        assert model.submodel.sub_arg_with_value == "sub_value"
+        assert model.submodel.sub_arg_enum == MyEnum.OPTION_A
+        assert model.submodel.sub_arg_literal == "y"
+        assert model.submodel2.sub_arg == 200
+        assert model.submodel2.sub_arg_with_value == "sub_value2"
+        assert model.submodel2.sub_arg_enum == MyEnum.OPTION_B
+        assert model.submodel2.sub_arg_literal == "z"
+
+        assert model.submodel3.sub_arg == 300
+        assert model.submodel_list_instanced[0].sub_arg == 400
+        assert model.submodel_list_instanced[0].sub_arg_with_value == "list_value"
+        assert model.submodel_list_instanced[0].sub_arg_enum == MyEnum.OPTION_B
+        assert model.submodel_list_instanced[0].sub_arg_literal == "z"
+        assert model.submodel_dict_instanced["a"].sub_arg == 500
+
+        stderr = mock_stderr.getvalue()
+        for text in (
+            "[p2a][WARNING]: Only lists of str, int, float, or bool are supported - field `unsupported_submodel_list` got <class 'test_model.SubModel'>",
+            "[p2a][WARNING]: Only dicts with str, int, float, bool, or enum values are supported - field `unsupported_submodel_dict` got value type <class 'test_model.SubModel'>",
+            "[p2a][WARNING]: Only Literal types of str, int, float, or bool are supported - field `unsupported_literal` got (b'test',)",
+            "[p2a][WARNING]: Only dicts with str, int, float, bool, or enum keys are supported - field `unsupported_dict` got key type <class 'test_model.SubModel'>",
+            "[p2a][WARNING]: Only dicts with str, int, float, bool, or enum values are supported - field `unsupported_dict_mixed_types` got value type typing.Union[str, test_model.SubModel]",
+            "[p2a][WARNING]: Unsupported field type for argument 'unsupported_random_type': <class 'set'>",
+        ):
+            assert text in stderr
+            stderr = stderr.replace(text, "")
+        if "[p2a][WARNING]" in stderr.strip():
+            for line in stderr.strip().splitlines():
+                if "[p2a][WARNING]" in line:
+                    print("UNEXPECTED WARNING:", line)
+            assert False

p2a-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: p2a
+Version: 0.1.0
+Summary: pydantic models to argparse CLIs
+Project-URL: Repository, https://github.com/1kbgz/p2a
+Project-URL: Homepage, https://github.com/1kbgz/p2a
+Author-email: the p2a authors <dev@1kbgz.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: argparse,cli,command-line,models,pydantic,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: pkn<0.4,>=0.3
+Provides-Extra: develop
+Requires-Dist: build; extra == 'develop'
+Requires-Dist: bump-my-version; extra == 'develop'
+Requires-Dist: check-manifest; extra == 'develop'
+Requires-Dist: codespell<2.5,>=2.4; extra == 'develop'
+Requires-Dist: hatchling; extra == 'develop'
+Requires-Dist: mdformat-tables>=1; extra == 'develop'
+Requires-Dist: mdformat<1.1,>=0.7.22; extra == 'develop'
+Requires-Dist: pytest; extra == 'develop'
+Requires-Dist: pytest-cov; extra == 'develop'
+Requires-Dist: ruff<0.15,>=0.9; extra == 'develop'
+Requires-Dist: twine; extra == 'develop'
+Requires-Dist: uv; extra == 'develop'
+Requires-Dist: wheel; extra == 'develop'
+Description-Content-Type: text/markdown
+
+# p2a
+
+pydantic models to argparse CLIs
+
+[![Build Status](https://github.com/1kbgz/p2a/actions/workflows/build.yaml/badge.svg?branch=main&event=push)](https://github.com/1kbgz/p2a/actions/workflows/build.yaml)
+[![codecov](https://codecov.io/gh/1kbgz/p2a/branch/main/graph/badge.svg)](https://codecov.io/gh/1kbgz/p2a)
+[![License](https://img.shields.io/github/license/1kbgz/p2a)](https://github.com/1kbgz/p2a)
+[![PyPI](https://img.shields.io/pypi/v/p2a.svg)](https://pypi.python.org/pypi/p2a)
+
+## Overview
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

p2a-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+p2a/__init__.py,sha256=Kb2nTSWltXbkvfawx7upoVZ3jNoAsZUODr66rGTugPs,44
+p2a/model.py,sha256=ccvFAsuWQJdaOd_0S26HUKlD2xIRWwzN4leiwzrH3tA,25314
+p2a/tests/test_model.py,sha256=QLwmPaEEmKSeDqRLohFrR5dLcLae3snaqsUSb2vX05o,8103
+p2a-0.1.0.dist-info/METADATA,sha256=okGLOybHRpPskZkgyeQ5JmMNPoZJRva85a6dx88LY3o,2311
+p2a-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+p2a-0.1.0.dist-info/licenses/LICENSE,sha256=BMaxAInGUDRuCHdrrtfkh4FemQFYkYRqxnhOhRYaliA,11345
+p2a-0.1.0.dist-info/RECORD,,

p2a-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

p2a-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 the p2a authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.