pythonwrench 0.6.4__py3-none-any.whl

pythonwrench/abc.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Any, ClassVar, Dict, Type
+
+
+class Singleton(type):
+    """Singleton metaclass.
+
+    To use it, just inherit from metaclass.
+
+    Example
+    -------
+    >>> class MyClass(metaclass=Singleton):
+    >>>     pass
+    >>> a1 = MyClass()
+    >>> a2 = MyClass()
+    >>> # a1 and a2 are exactly the same instance, i.e. id(a1) == id(a2)
+    """
+
+    _instances: ClassVar[Dict[Type, Any]] = {}
+
+    def __call__(cls, *args, **kwargs) -> Any:
+        """Call the instance."""
+        if cls not in cls._instances:
+            instance = super().__call__(*args, **kwargs)
+            cls._instances[cls] = instance
+        else:
+            instance = cls._instances[cls]
+        return instance

pythonwrench/argparse/__init__.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import TYPE_CHECKING
+
+try:
+    import lazy_loader as lazy  # type: ignore
+except ImportError:
+    lazy = None
+
+
+if TYPE_CHECKING or lazy is None:
+    from . import dataclass_ as dataclass_
+    from . import parsers as parsers
+    from .dataclass_ import (
+        add_dataclass_fields_to_parser,
+        new_parser_from_dataclass,
+        parse_args_using_dataclass,
+    )
+    from .parsers import (
+        get_parse_fn,
+        parse_to,
+        parse_to_bool,
+        parse_to_float,
+        parse_to_int,
+        parse_to_none,
+        parse_to_optional_bool,
+        parse_to_optional_float,
+        parse_to_optional_int,
+        parse_to_optional_str,
+        parse_to_type,
+        register_parser_fn,
+        str_to_bool,
+        str_to_float,
+        str_to_int,
+        str_to_none,
+        str_to_optional_bool,
+        str_to_optional_float,
+        str_to_optional_int,
+        str_to_optional_str,
+        str_to_type,
+    )
+
+else:
+    __getattr__, __dir__, __all__ = lazy.attach(
+        __name__,
+        submodules=["dataclass_", "parsers"],
+        submod_attrs={
+            "dataclass_": [
+                "add_dataclass_fields_to_parser",
+                "new_parser_from_dataclass",
+                "parse_args_using_dataclass",
+            ],
+            "parsers": [
+                "get_parse_fn",
+                "parse_to",
+                "parse_to_bool",
+                "parse_to_float",
+                "parse_to_int",
+                "parse_to_none",
+                "parse_to_optional_bool",
+                "parse_to_optional_float",
+                "parse_to_optional_int",
+                "parse_to_optional_str",
+                "parse_to_type",
+                "register_parser_fn",
+                "str_to_bool",
+                "str_to_float",
+                "str_to_int",
+                "str_to_none",
+                "str_to_optional_bool",
+                "str_to_optional_float",
+                "str_to_optional_int",
+                "str_to_optional_str",
+                "str_to_type",
+            ],
+        },
+    )
+
+
+del TYPE_CHECKING, lazy

pythonwrench/argparse/dataclass_.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from argparse import ArgumentParser
+from dataclasses import MISSING, fields
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+    overload,
+)
+
+from pythonwrench.argparse.parsers import (
+    ListParsing,
+    _is_iterable_type_like,
+    _is_literal_type,
+    _search_parse_fn,
+)
+from pythonwrench.functools import filter_and_call
+from pythonwrench.typing.classes import (
+    Dataclass,
+    DataclassInstance,
+)
+from pythonwrench.warnings import deprecated_alias
+
+try:
+    from argparse import BooleanOptionalAction  # type: ignore
+except ImportError:
+
+    class BooleanOptionalAction: ...
+
+
+T_Dataclass = TypeVar("T_Dataclass", bound=Dataclass)
+T_DataclassInstance = TypeVar("T_DataclassInstance", bound=DataclassInstance)
+T_DataclassInstance_2 = TypeVar("T_DataclassInstance_2", bound=DataclassInstance)
+T_DataclassInstance_3 = TypeVar("T_DataclassInstance_3", bound=DataclassInstance)
+T_DataclassInstance_4 = TypeVar("T_DataclassInstance_4", bound=DataclassInstance)
+T_DataclassInstance_5 = TypeVar("T_DataclassInstance_5", bound=DataclassInstance)
+
+_BoolActionName = Literal["store", "store_true", "store_false", "bool_optional"]
+BoolAction = Union[_BoolActionName, Type[BooleanOptionalAction]]
+
+
+@overload
+def parse_args_using_dataclass(
+    dataclass_type: Type[T_DataclassInstance],
+    *,
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> T_DataclassInstance: ...
+
+
+@overload
+def parse_args_using_dataclass(
+    dataclass_type: Type[T_DataclassInstance],
+    dataclass_type_2: Type[T_DataclassInstance_2],
+    /,
+    *,
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> Tuple[
+    T_DataclassInstance,
+    T_DataclassInstance_2,
+]: ...
+
+
+@overload
+def parse_args_using_dataclass(
+    dataclass_type: Type[T_DataclassInstance],
+    dataclass_type_2: Type[T_DataclassInstance_2],
+    dataclass_type_3: Type[T_DataclassInstance_3],
+    /,
+    *,
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> Tuple[
+    T_DataclassInstance,
+    T_DataclassInstance_2,
+    T_DataclassInstance_3,
+]: ...
+
+
+@overload
+def parse_args_using_dataclass(
+    dataclass_type: Type[T_DataclassInstance],
+    dataclass_type_2: Type[T_DataclassInstance_2],
+    dataclass_type_3: Type[T_DataclassInstance_3],
+    dataclass_type_4: Type[T_DataclassInstance_4],
+    /,
+    *,
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> Tuple[
+    T_DataclassInstance,
+    T_DataclassInstance_2,
+    T_DataclassInstance_3,
+    T_DataclassInstance_4,
+]: ...
+
+
+@overload
+def parse_args_using_dataclass(
+    dataclass_type: Type[T_DataclassInstance],
+    dataclass_type_2: Type[T_DataclassInstance_2],
+    dataclass_type_3: Type[T_DataclassInstance_3],
+    dataclass_type_4: Type[T_DataclassInstance_4],
+    dataclass_type_5: Type[T_DataclassInstance_5],
+    /,
+    *,
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> Tuple[
+    T_DataclassInstance,
+    T_DataclassInstance_2,
+    T_DataclassInstance_3,
+    T_DataclassInstance_4,
+    T_DataclassInstance_5,
+]: ...
+
+
+def parse_args_using_dataclass(
+    dataclass_type: Type[DataclassInstance],
+    *dataclass_types: Type[DataclassInstance],
+    args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> Union[
+    DataclassInstance,
+    Tuple[DataclassInstance, ...],
+]:
+    """Converts prog args to a typed dataclass using argparse.
+
+    Currently only supports dataclasses that contains only builtin scalars: str, int, float, None, bool OR list of builtin scalars.
+    """
+    init_parser = parser
+    dataclass_types = (dataclass_type,) + dataclass_types
+    del dataclass_type
+
+    for dataclass_type_i in dataclass_types:
+        parser = add_dataclass_fields_to_parser(
+            dataclass_type_i,
+            parser=parser,
+            list_parsing=list_parsing,
+            bool_action=bool_action,
+            add_dashed_arg=add_dashed_arg,
+        )
+    assert parser is not None
+
+    parsed, argv = parser.parse_known_args(args)
+    if len(argv) > 0:
+        msg = f"Found {len(argv)} unknown arguments: {argv}."
+        raise ValueError(msg)
+
+    dataclass_insts = []
+    for dataclass_type_i in dataclass_types:
+        if init_parser is None and len(dataclass_types) == 1:
+            instance = dataclass_type_i(**parsed.__dict__)
+        else:
+            instance = filter_and_call(
+                dataclass_type_i,
+                _fill_all_arguments=True,
+                **parsed.__dict__,
+            )
+        dataclass_insts.append(instance)
+
+    if len(dataclass_insts) == 1:
+        return dataclass_insts[0]
+    else:
+        return tuple(dataclass_insts)
+
+
+def add_dataclass_fields_to_parser(
+    dataclass_type: Type[T_DataclassInstance],
+    *,
+    parser: Optional[ArgumentParser],
+    list_parsing: ListParsing = "argparse",
+    bool_action: BoolAction = "store",
+    add_dashed_arg: bool = True,
+) -> ArgumentParser:
+    """Perform the add dataclass fields to parser operation."""
+    if parser is None:
+        parser = ArgumentParser()
+
+    for field in fields(dataclass_type):
+        kwds = {}
+        posargs = [f"--{field.name}"]
+        if add_dashed_arg and "_" in field.name:
+            dashed_arg_name = field.name.replace("_", "-")
+            posargs.append(f"--{dashed_arg_name}")
+
+        if field.default is MISSING and field.default_factory is MISSING:
+            if bool_action != "store" and field.type is bool:
+                msg = f"Invalid arguments: boolean '{field.name}' without default value is incompatible with {bool_action=}."
+                raise RuntimeError(msg)
+            kwds["required"] = True
+
+        elif field.default is not MISSING:
+            kwds["default"] = field.default
+        elif field.default_factory is not MISSING:
+            kwds["default"] = field.default_factory()  # type: ignore
+        else:
+            msg = f"Invalid field {field.name}: found values for default and default_factory."
+            raise ValueError(msg)
+
+        try:
+            inner_kwds = _get_kwds_for_type(field.type, list_parsing, bool_action)
+        except (ValueError, TypeError, RuntimeError) as err:
+            msg = f"Invalid field {field.name}: field type '{field.type}' is not supported."
+            raise type(err)(msg) from err
+
+        kwds.update(inner_kwds)
+        parser.add_argument(*posargs, **kwds)
+
+    return parser
+
+
+def _get_kwds_for_type(
+    field_type: Any,
+    list_parsing: Optional[ListParsing],
+    bool_action: BoolAction,
+) -> Dict[str, Any]:
+    """Perform the get kwds for type operation."""
+    if bool_action == "bool_optional":
+        bool_action = BooleanOptionalAction
+    kwds = {}
+
+    if bool_action != "store" and field_type is bool:
+        kwds["action"] = bool_action
+        return kwds
+
+    elif list_parsing == "argparse" and _is_iterable_type_like(field_type):
+        type_args = get_args(field_type)
+        if isinstance(type_args, tuple) and len(type_args) == 1:
+            item_type = type_args[0]
+            kwds = _get_kwds_for_type(
+                item_type, list_parsing=None, bool_action=bool_action
+            )
+        kwds["nargs"] = "*"
+        return kwds
+
+    parse_fn = _search_parse_fn(field_type, list_parsing=list_parsing)
+
+    if parse_fn is not None:
+        kwds["type"] = parse_fn
+        if _is_literal_type(field_type):
+            kwds["choices"] = get_args(field_type)
+        return kwds
+
+    else:
+        msg = (
+            f"Unsupported type {field_type}. (with {list_parsing=} and {bool_action=})"
+        )
+        raise TypeError(msg)
+
+
+# ALIASES
+@deprecated_alias(add_dataclass_fields_to_parser)
+def new_parser_from_dataclass(*args, **kwargs):
+    """Perform the new parser from dataclass operation."""
+    ...