PyPI - typedparser - Versions diffs - 0.6.4__tar.gz → 0.20.3__tar.gz - Mend

typedparser 0.6.4tar.gz → 0.20.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

{typedparser-0.6.4 → typedparser-0.20.3}/LICENSE RENAMED Viewed

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
-   Copyright 2023 gingsi
+   Copyright 2023 simon-ging
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{typedparser-0.6.4 → typedparser-0.20.3}/PKG-INFO RENAMED Viewed

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: typedparser
-Version: 0.6.4
+Version: 0.20.3
 Summary: Extension for python argparse with typehints and typechecks.
-Author: gingsi
+Author: simon-ging
 License: Apache-2.0
-Project-URL: Project-URL, https://github.com/gingsi/typedparser
+Project-URL: Project-URL, https://github.com/simon-ging/typedparser
 Keywords: attrs,typing,dict,attr
 Platform: any
 Classifier: Development Status :: 3 - Alpha
@@ -14,24 +14,48 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs
-Requires-Dist: numpy
+Requires-Dist: importlib_metadata; python_version < "3.8"
+Requires-Dist: typing_extensions; python_version < "3.8"
+Provides-Extra: full
+Requires-Dist: numpy; extra == "full"
 # typedparser
 <p align="center">
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py37.yml">
-  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py37.yml?branch=main&label=build%203.7" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37.yml">
+  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37.yml?branch=main&label=python%203.7" />
 </a>
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py310.yml">
-  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py310.yml?branch=main&label=build%203.10" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py38.yml">
+  <img alt="build 3.8 status" title="build 3.8 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py38.yml?branch=main&label=python%203.8" />
 </a>
-<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/gingsi/typedparser/main/docs/coverage.svg" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py39.yml">
+  <img alt="build 3.9 status" title="build 3.9 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py39.yml?branch=main&label=python%203.9" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py310.yml">
+  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py310.yml?branch=main&label=python%203.10" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py311.yml">
+  <img alt="build 3.11 status" title="build 3.11 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py311.yml?branch=main&label=python%203.11" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312.yml">
+  <img alt="build 3.12 status" title="build 3.12 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312.yml?branch=main&label=python%203.12" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37-full.yml">
+  <img alt="build 3.7 full status" title="build 3.7 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37-full.yml?branch=main&label=python%203.7%20full" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312-full.yml">
+  <img alt="build 3.12 full status" title="build 3.12 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312-full.yml?branch=main&label=python%203.12%20full" />
+</a>
+<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/simon-ging/typedparser/main/docs/coverage.svg" />
 <a href="https://pypi.org/project/typedparser/">
   <img alt="version" title="version" src="https://img.shields.io/pypi/v/typedparser?color=success" />
 </a>
@@ -41,22 +65,6 @@ Typing extension for python argparse using [attrs](https://www.attrs.org/en/stab
 Includes typechecking and conversion utilities to parse a dictionary into an attrs instance.
-## Features
-* Create commandline arguments with type hints and checks while
-staying very close to the syntax of the standard library's argparse.
-* Utilities for typechecking and converting nested objects:
-  * Nested checking and conversion of python standard types
-  * Supports old and new style typing (e.g. `typing.List` and `list`)
-  * Supports positional and keyword arguments in classes
-  * Can also typecheck existing attrs instances
-  * Allows custom conversions, by default converts source type `str` to target type `Path` and
-    `int` to `float`
-  * Allows to redefine which objects will be recursed into, by default recurses into standard
-    containers (list, dict, etc.)
-  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
-* Some object utilities in `typedparser.objects` required for everything else
 ## Install
 Requires `python>=3.7`
@@ -65,11 +73,11 @@ Requires `python>=3.7`
 pip install typedparser
 ```
-## Usage of the parser
+## Basic usage
-1. Create an attrs class (decorate with `@attr.define`)
-2. Define the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
-3. Parse the args with `TypedParser`, now the args are typechecked and there are typehints available.
+1. Create an attrs class (decorate with `@attr.define`). Note that optional arguments must also be typed as optional.
+2. Define and type the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
+3. Parse the args with `TypedParser` and enjoy args with type hints. Disable typechecking by setting `strict=False`.
 ~~~python
 from typing import Optional
@@ -78,21 +86,21 @@ from typedparser import add_argument, TypedParser
 @define
-class Args:
-    foo: int = add_argument("foo", type=int)
-    bar: int = add_argument("-b", "--bar", type=int, default=0)
-    # Syntax extensions:
+class Args:
+    # omit the argument name to have it inferred from the field name
+    foo: str = add_argument(positional=True)
+    bar: int = add_argument(shortcut="-b", type=int, default=0)
+    opt: Optional[str] = add_argument()
+    # # in case you prefer the regular argparse syntax:
+    # foo: str = add_argument("foo")
+    # bar: int = add_argument("-b", "--bar", type=int, default=0)
+    # opt: Optional[str] = add_argument("--opt")
-    # Omit argument name to create an optional argument --opt
-    opt: Optional[int] = add_argument(type=int)
-    # Use shortcut to create an optional argument -s / --short
-    short: Optional[int] = add_argument(shortcut="-s", type=int)
 def main():
-    parser = TypedParser.create_parser(Args)
+    parser = TypedParser.create_parser(Args, strict=True)
     args: Args = parser.parse_args()
     print(args)
@@ -102,14 +110,31 @@ if __name__ == "__main__":
 ~~~
-### Advanced usage
+## Features
+* Create commandline arguments with type hints and checks while
+staying close to the syntax of the standard library's argparse.
+* Utilities for typechecking and converting nested objects:
+  * Nested checking and conversion of python standard types
+  * Supports old and new style typing (e.g. `typing.List` and `list`)
+  * Supports positional and keyword arguments in classes
+  * Can also typecheck existing attrs instances
+  * Allows custom conversions, by default converts source type `str` to target type `Path` and
+    `int` to `float`
+  * Allows to redefine which objects will be recursed into, by default recurses into standard
+    containers (list, dict, etc.)
+  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
+* Some object utilities in `typedparser.objects` required for everything else
+## Advanced usage
 * Use `TypedParser.from_parser(parser, Args)` to add typing to an existing parser. This is useful
 to cover usecases like subparsers or argument groups.
 * Snippet for argument lists `xarg: List[int] = add_argument(shortcut="-x", type=int, action="append", help="Xarg", default=[])`,
 use as `-x 1 -x 2` to get `[1, 2]` in the args instance.
-## Usage of attr utilities
+### Usage of attr utilities
 Define the class hierarchy and parse the input using `attrs_from_dict`.
 Use `@define(slots=False)` to allow multiple inheritance and setting attributes later.
@@ -143,6 +168,7 @@ print(attrs_from_dict(CfgNested, {"sub_cfg": {"foo": 1, "bar": 2}}))
   the output will be a tuple
 * Raise errors if types cannot be matched, there are unknown fields in the input or
   abstract annotation types are used (e.g. Sequence)
+* Set `_allow_extra_keys = True` in the class definition to allow unknown fields in the input
 ### Non-strict mode
@@ -174,7 +200,7 @@ Note: Some tests are skipped for python 3.7.
 ~~~bash
 pip install -e .
-pip install pytest pytest-cov pylint pytest-lazy-fixture
+pip install pytest pytest-cov pylint
 pylint typedparser
 # run tests

{typedparser-0.6.4 → typedparser-0.20.3}/README.md RENAMED Viewed

@@ -1,13 +1,31 @@
 # typedparser
 <p align="center">
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py37.yml">
-  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py37.yml?branch=main&label=build%203.7" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37.yml">
+  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37.yml?branch=main&label=python%203.7" />
 </a>
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py310.yml">
-  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py310.yml?branch=main&label=build%203.10" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py38.yml">
+  <img alt="build 3.8 status" title="build 3.8 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py38.yml?branch=main&label=python%203.8" />
 </a>
-<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/gingsi/typedparser/main/docs/coverage.svg" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py39.yml">
+  <img alt="build 3.9 status" title="build 3.9 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py39.yml?branch=main&label=python%203.9" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py310.yml">
+  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py310.yml?branch=main&label=python%203.10" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py311.yml">
+  <img alt="build 3.11 status" title="build 3.11 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py311.yml?branch=main&label=python%203.11" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312.yml">
+  <img alt="build 3.12 status" title="build 3.12 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312.yml?branch=main&label=python%203.12" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37-full.yml">
+  <img alt="build 3.7 full status" title="build 3.7 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37-full.yml?branch=main&label=python%203.7%20full" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312-full.yml">
+  <img alt="build 3.12 full status" title="build 3.12 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312-full.yml?branch=main&label=python%203.12%20full" />
+</a>
+<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/simon-ging/typedparser/main/docs/coverage.svg" />
 <a href="https://pypi.org/project/typedparser/">
   <img alt="version" title="version" src="https://img.shields.io/pypi/v/typedparser?color=success" />
 </a>
@@ -17,22 +35,6 @@ Typing extension for python argparse using [attrs](https://www.attrs.org/en/stab
 Includes typechecking and conversion utilities to parse a dictionary into an attrs instance.
-## Features
-* Create commandline arguments with type hints and checks while
-staying very close to the syntax of the standard library's argparse.
-* Utilities for typechecking and converting nested objects:
-  * Nested checking and conversion of python standard types
-  * Supports old and new style typing (e.g. `typing.List` and `list`)
-  * Supports positional and keyword arguments in classes
-  * Can also typecheck existing attrs instances
-  * Allows custom conversions, by default converts source type `str` to target type `Path` and
-    `int` to `float`
-  * Allows to redefine which objects will be recursed into, by default recurses into standard
-    containers (list, dict, etc.)
-  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
-* Some object utilities in `typedparser.objects` required for everything else
 ## Install
 Requires `python>=3.7`
@@ -41,11 +43,11 @@ Requires `python>=3.7`
 pip install typedparser
 ```
-## Usage of the parser
+## Basic usage
-1. Create an attrs class (decorate with `@attr.define`)
-2. Define the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
-3. Parse the args with `TypedParser`, now the args are typechecked and there are typehints available.
+1. Create an attrs class (decorate with `@attr.define`). Note that optional arguments must also be typed as optional.
+2. Define and type the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
+3. Parse the args with `TypedParser` and enjoy args with type hints. Disable typechecking by setting `strict=False`.
 ~~~python
 from typing import Optional
@@ -54,21 +56,21 @@ from typedparser import add_argument, TypedParser
 @define
-class Args:
-    foo: int = add_argument("foo", type=int)
-    bar: int = add_argument("-b", "--bar", type=int, default=0)
-    # Syntax extensions:
+class Args:
+    # omit the argument name to have it inferred from the field name
+    foo: str = add_argument(positional=True)
+    bar: int = add_argument(shortcut="-b", type=int, default=0)
+    opt: Optional[str] = add_argument()
+    # # in case you prefer the regular argparse syntax:
+    # foo: str = add_argument("foo")
+    # bar: int = add_argument("-b", "--bar", type=int, default=0)
+    # opt: Optional[str] = add_argument("--opt")
-    # Omit argument name to create an optional argument --opt
-    opt: Optional[int] = add_argument(type=int)
-    # Use shortcut to create an optional argument -s / --short
-    short: Optional[int] = add_argument(shortcut="-s", type=int)
 def main():
-    parser = TypedParser.create_parser(Args)
+    parser = TypedParser.create_parser(Args, strict=True)
     args: Args = parser.parse_args()
     print(args)
@@ -78,14 +80,31 @@ if __name__ == "__main__":
 ~~~
-### Advanced usage
+## Features
+* Create commandline arguments with type hints and checks while
+staying close to the syntax of the standard library's argparse.
+* Utilities for typechecking and converting nested objects:
+  * Nested checking and conversion of python standard types
+  * Supports old and new style typing (e.g. `typing.List` and `list`)
+  * Supports positional and keyword arguments in classes
+  * Can also typecheck existing attrs instances
+  * Allows custom conversions, by default converts source type `str` to target type `Path` and
+    `int` to `float`
+  * Allows to redefine which objects will be recursed into, by default recurses into standard
+    containers (list, dict, etc.)
+  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
+* Some object utilities in `typedparser.objects` required for everything else
+## Advanced usage
 * Use `TypedParser.from_parser(parser, Args)` to add typing to an existing parser. This is useful
 to cover usecases like subparsers or argument groups.
 * Snippet for argument lists `xarg: List[int] = add_argument(shortcut="-x", type=int, action="append", help="Xarg", default=[])`,
 use as `-x 1 -x 2` to get `[1, 2]` in the args instance.
-## Usage of attr utilities
+### Usage of attr utilities
 Define the class hierarchy and parse the input using `attrs_from_dict`.
 Use `@define(slots=False)` to allow multiple inheritance and setting attributes later.
@@ -119,6 +138,7 @@ print(attrs_from_dict(CfgNested, {"sub_cfg": {"foo": 1, "bar": 2}}))
   the output will be a tuple
 * Raise errors if types cannot be matched, there are unknown fields in the input or
   abstract annotation types are used (e.g. Sequence)
+* Set `_allow_extra_keys = True` in the class definition to allow unknown fields in the input
 ### Non-strict mode
@@ -150,7 +170,7 @@ Note: Some tests are skipped for python 3.7.
 ~~~bash
 pip install -e .
-pip install pytest pytest-cov pylint pytest-lazy-fixture
+pip install pytest pytest-cov pylint
 pylint typedparser
 # run tests

{typedparser-0.6.4 → typedparser-0.20.3}/pyproject.toml RENAMED Viewed

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "typedparser"
 description = "Extension for python argparse with typehints and typechecks."
 readme = "README.md"
-authors = [{ "name" = "gingsi" }]
+authors = [{ "name" = "simon-ging" }]
 requires-python = ">=3.7"
 license = { text = "Apache-2.0" }
 keywords = ["attrs", "typing", "dict", "attr"]
@@ -18,13 +18,19 @@ classifiers = [
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Version Control :: Git"
 ]
 dynamic = ["version", "dependencies"]
+[project.optional-dependencies]
+full = ["numpy"]
 [project.urls]
-Project-URL = "https://github.com/gingsi/typedparser"
+Project-URL = "https://github.com/simon-ging/typedparser"
 [tool.setuptools]
 zip-safe = true

typedparser-0.20.3/requirements.txt ADDED Viewed

@@ -0,0 +1,4 @@
+attrs
+importlib_metadata;python_version<'3.8'
+typing_extensions;python_version<'3.8'

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser/__init__.py RENAMED Viewed

@@ -1,5 +1,12 @@
 from ._typedattr import definenumpy, attrs_from_dict, NamedTupleMixin
-from ._typedparser import add_argument, TypedParser, define, VerboseQuietArgs
+from ._typedparser import (
+    add_argument,
+    TypedParser,
+    VerboseQuietArgs,
+    TaskSplitterArgs,
+    split_list_given_task_splitter_args,
+    split_list_for_processing,
+)
 from .custom_format import CustomArgparseFmt
 from .objects import get_attr_names
@@ -9,9 +16,13 @@ __all__ = [
     "NamedTupleMixin",
     "add_argument",
     "TypedParser",
-    "define",
     "VerboseQuietArgs",
     "CustomArgparseFmt",
     "get_attr_names",
+    "TaskSplitterArgs",
+    "split_list_given_task_splitter_args",
+    "split_list_for_processing",
 ]
-__version__ = "0.6.4"
+__version__ = "0.20.3"

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser/_typedattr.py RENAMED Viewed

@@ -1,3 +1,5 @@
+from __future__ import annotations
 import collections
 from functools import partial
 from inspect import isclass
@@ -15,6 +17,7 @@ from typing import (
     List,
     Optional,
     get_type_hints,
+    Callable,
 )
 import attrs
@@ -23,19 +26,28 @@ from attrs import define, fields_dict, fields, Attribute
 from .objects import check_object_equality, RecursorInterface, StrictRecursor, AttrsClass
+try:
+    from types import UnionType
+except ImportError:
+    UnionType = None
 try:
     # python>=3.8
     from typing import get_origin, get_args
 except ImportError:
     # python<3.8
+    # note that attrs automatically installs this and importlib-metadata for old python versions
     from typing_extensions import get_origin, get_args
 # default conversions allow to convert instead of raising errors in case of matching types
 # e.g. create Path given str, or create float given int
-conversion_type = List[Tuple[Tuple[Type, ...], Type]]
+# syntax: ((source_type1, source_type2, ...), target_type, conversion_function)
+# if conversion_function is none, use target_type as conversion function
+conversion_type = List[Tuple[Tuple[Type, ...], Type, Optional[Callable]]]
 default_conversions: conversion_type = [
-    ((str,), Path),
-    ((int,), float),
+    ((str,), Path, None),
+    ((int,), float, None),
+    ((Path,), str, Path.as_posix),
 ]
@@ -129,7 +141,16 @@ def _attrs_from_dict(
     skip_unknowns: bool = False,
     conversions: Optional[conversion_type] = None,
     more_error_info: str = "",
+    current_position: Optional[List] = None,
 ):
+    if current_position is None:
+        current_position = []
+    if isinstance(input_dict_or_attrs, str):
+        raise TypeError(
+            f"Expected a dictionary or attrs instance, got type '{type(input_dict_or_attrs)}' "
+            f"value '{input_dict_or_attrs}' at position '{'.'.join(current_position)}' (root "
+            f"if empty).\n\nError context: {more_error_info}."
+        )
     _print_fn(f"Parsing {cls} from {input_dict_or_attrs}")
     input_cls = type(input_dict_or_attrs)
     if has(input_cls):
@@ -169,7 +190,7 @@ def _attrs_from_dict(
     for field_name, field_value in matching_input.items():
         field_att = cls_fields_dict[field_name]
         try:
-            is_positional = bool(field_att.default == attrs.NOTHING)
+            is_positional = bool(field_att.default == attrs.NOTHING) and not field_att.kw_only
         except ValueError:
             # some field defaults, e.g. numpy arrays do not have comparison defined here
             # but that means that the default is set and the field is not positional
@@ -181,10 +202,30 @@ def _attrs_from_dict(
     # create an attrs instance from the dict
     # the instance will be flat (nested dicts are not resolved yet) and not typechecked.
-    attrs_inst = attrs.evolve(cls(*in_args), **in_kwargs)  # noqa
+    try:
+        cls_inst = cls(*in_args, **in_kwargs)  # noqa
+        attrs_inst = cls_inst
+        # # not sure why evolve was used before
+        # attrs_inst = attrs.evolve(cls_inst, **in_kwargs)  # noqa
+    except TypeError as e:
+        raise TypeError(
+            f"Failed creating instance of {cls} from input {input_dict} "
+            f"with args {in_args} and kwargs {in_kwargs}. Error occurred at: "
+            f"{'.'.join(current_position)}. {e}\n\nError context: {more_error_info}."
+        ) from e
     # typecheck and unfold nested values in the attrs instance
-    type_hints = get_type_hints(cls)
+    try:
+        type_hints = get_type_hints(cls)
+    except TypeError as e:
+        raise TypeError(
+            f"Failed getting type hints for {cls} with input '{input_dict}'. Error occurred at: "
+            f"{'.'.join(current_position)}. {e}\n\nError context: {more_error_info}."
+            "Potential reasons: You used an old python version <=3.8, used from __future__ "
+            "import annotations, and annotated something as dict[str, int]. "
+            "This does not work together with get_type_hints. Solution: "
+            "Annotate with typing.Dict[str, int] instead of dict[str, int], or upgrade python."
+        ) from e
     for att in all_atts:
         name = att.name
         value = getattr(attrs_inst, name)
@@ -201,12 +242,13 @@ def _attrs_from_dict(
             skip_unknowns=skip_unknowns,
             conversions=conversions,
             more_error_info=more_error_info,
+            current_position=current_position + [name],
         )
         setattr(attrs_inst, name, new_value)
     # handle unknown fields
     if len(nonmatching_input) > 0 and not skip_unknowns:
-        if strict:
+        if strict and not getattr(cls, "_allow_extra_keys", False):
             raise TypeError(
                 f"Keys in input {list(nonmatching_input.keys())} not defined "
                 f"for class {cls} with attributes {sorted(all_att_names)}"
@@ -238,14 +280,17 @@ def _parse_nested(
     conversions: conversion_type = None,
     depth: int = 0,
     more_error_info: str = "",
+    current_position: Optional[List] = None,
 ):
     conversions = default_conversions if conversions is None else conversions
     parse_recursive = partial(
         _parse_nested,
         recursor,
-        depth=depth + 1,
         skip_unknowns=skip_unknowns,
+        conversions=conversions,
+        depth=depth + 1,
         more_error_info=more_error_info,
+        current_position=current_position,
     )
     if isinstance(typ, str):
@@ -265,11 +310,11 @@ def _parse_nested(
     value_type_name = value_type.__name__ if hasattr(value_type, "__name__") else str(value_type)
     err_msg = (
         f"Could not parse {name}={value} (type {value_type_name}) as type "
-        f"{target_type_name} with strict={strict} "
-        # f"depth={depth} type annotation origin={origin} args={args}"
+        f"{target_type_name} with strict={strict}"
+        # f" depth={depth} type annotation origin={origin} args={args}"
     )
-    def maybe_raise_typeerorr(full_err_msg):
+    def maybe_raise_typeerror(full_err_msg):
         if strict:
             raise TypeError(full_err_msg)
         _print_fn(f"Caught: {full_err_msg}. Returning as is.")
@@ -284,22 +329,29 @@ def _parse_nested(
             strict=strict,
             skip_unknowns=skip_unknowns,
             conversions=conversions,
+            more_error_info=more_error_info,
+            current_position=current_position,
         )
     # resolve any
-    if typ == Any:
+    if typ in [Any, any]:
         return value
     # resolve unions (mostly "optional")
-    if origin == Union:
+    if origin == Union or (UnionType is not None and isinstance(typ, UnionType)):
+        collected_errors = []
         for new_typ in args:
             try:
                 # force strict parsing and catch errors to try all different types
                 return parse_recursive(name, value, new_typ, strict=True)
-            except TypeError:
-                pass
+            except TypeError as e:
+                collected_errors.append(f"{e}")
         # if we get here, none of the types worked
-        return maybe_raise_typeerorr(f"{err_msg}. No type in Union matches.")
+        collected_error_str = "\n".join(collected_errors)
+        return maybe_raise_typeerror(
+            f"No type in Union matches. Errors per type:\n{collected_error_str}\n"
+            f"Final error: {err_msg}"
+        )
     final_list_type = None
@@ -308,9 +360,9 @@ def _parse_nested(
         if not (len(args) == 2 and args[1] == Ellipsis):
             # resolve fixed tuple
             if not recursor.is_iterable_fn(value):
-                return maybe_raise_typeerorr(f"{err_msg}. Expect a sequence, got {type(value)}")
+                return maybe_raise_typeerror(f"{err_msg}. Expect a sequence, got {type(value)}")
             if len(value) != len(args):
-                return maybe_raise_typeerorr(
+                return maybe_raise_typeerror(
                     f"{err_msg}. Expect a sequence with length {len(args)}, got length {len(value)}"
                 )
             new_tuple = []
@@ -324,7 +376,7 @@ def _parse_nested(
     # check dict
     if origin in (dict, collections.defaultdict):
         if not recursor.is_mapping_fn(value):
-            return maybe_raise_typeerorr(f"{err_msg}. Expect a mapping, got {type(value)}")
+            return maybe_raise_typeerror(f"{err_msg}. Expect a mapping, got {type(value)}")
         if len(args) == 0:
             args = [Any, Any]
         dict_keytype, dict_valuetype = args
@@ -336,9 +388,9 @@ def _parse_nested(
             dict_output = {}
         for key, val in value.items():
-            dict_output[parse_recursive(name, key, dict_keytype, strict=strict)] = parse_recursive(
-                name, val, dict_valuetype, strict=strict
-            )
+            parsed_key = parse_recursive(f"{name}/dict_key_type", key, dict_keytype, strict=strict)
+            parsed_value = parse_recursive(f"{name}/{key}", val, dict_valuetype, strict=strict)
+            dict_output[parsed_key] = parsed_value
         return dict_output
@@ -352,7 +404,7 @@ def _parse_nested(
     # resolve list
     if origin == list:
         if not recursor.is_iterable_fn(value):
-            return maybe_raise_typeerorr(f"{err_msg}. Expect iterable, got {type(value)}")
+            return maybe_raise_typeerror(f"{err_msg}. Expect iterable, got {type(value)}")
         list_arg_type = args[0]
         list_output = []
         for item in value:
@@ -381,19 +433,25 @@ def _parse_nested(
     except TypeError:
         is_sc = False
     if is_sc:
-        return maybe_raise_typeerorr(f"{err_msg}. Abstract collections are not supported.")
+        return maybe_raise_typeerror(f"{err_msg}. Abstract collections are not supported.")
     # add explicit conversions
-    for convert_source, convert_target in conversions:
+    for convert_source, convert_target, convert_callable in conversions:
         if not isclass(typ):
             continue
         if issubclass(typ, convert_target) and isinstance(value, convert_source):
-            return convert_target(value)
+            if convert_callable is None:
+                convert_callable = convert_target
+            return convert_callable(value)
     if strict:
         add_info = ""
         if typ is None:
-            add_info = "Untyped fields not allowed in strict mode. "
+            add_info = (
+                "Untyped fields not allowed in strict mode. "
+                "Add type annotations or set strict=False. "
+            )
         raise TypeError(f"{add_info}{err_msg}. Wrong type or type not supported.")
     _print_fn(f"{err_msg}. Returning value {value} as-is")
     return value

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser/_typedparser.py RENAMED Viewed

@@ -1,11 +1,10 @@
 # from __future__ import annotations  # do not use here, it breaks everything
 import argparse
+from attr import field, define
 from dataclasses import dataclass
 from typing import Optional, Type, Any
-from attr import field, define
 from ._typedattr import AttrsClass
 from .custom_format import CustomArgparseFmt
 from .funcs import parse_typed_args, add_typed_args
@@ -55,7 +54,9 @@ class TypedParser:
         return typed_args
-def add_argument(*name_or_flags: str, shortcut: Optional[str] = None, **kwargs):
+def add_argument(
+    *name_or_flags: str, shortcut: Optional[str] = None, positional: bool = False, **kwargs
+):
     """
     Interface matches ArgumentParser.add_argument:
     https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser.add_argument
@@ -66,6 +67,7 @@ def add_argument(*name_or_flags: str, shortcut: Optional[str] = None, **kwargs):
         shortcut: Shortcut for the argument including leading single dash.
             If given, will be added as a shortcut to the argument.
             Cannot be used if name_or_flags are given.
+        positional: If True, will be added as a positional argument.
         **kwargs: will be passed to argparse parser.add_argument
     """
     assert "name_or_flags" not in kwargs, "Pass name_or_flags as positional arguments"
@@ -86,7 +88,12 @@ def add_argument(*name_or_flags: str, shortcut: Optional[str] = None, **kwargs):
             # other actions are assumed to have default None output in argparse
     return field(
-        metadata={"name_or_flags": name_or_flags, "shortcut": shortcut, **kwargs},
+        metadata={
+            "name_or_flags": name_or_flags,
+            "shortcut": shortcut,
+            "positional": positional,
+            **kwargs,
+        },
         kw_only=True,
         default=default,
     )
@@ -96,3 +103,30 @@ def add_argument(*name_or_flags: str, shortcut: Optional[str] = None, **kwargs):
 class VerboseQuietArgs:
     verbose: bool = add_argument(shortcut="-v", help="Increase verbosity", action="store_true")
     quiet: bool = add_argument(shortcut="-q", help="Reduce verbosity", action="store_true")
+@define(slots=False)  # slots false to allow multi inheritance
+class TaskSplitterArgs:
+    start: int = add_argument(shortcut="-s", type=int, default=0, help="Where to start processing")
+    num: Optional[int] = add_argument(shortcut="-n", type=int, help="Number of tasks to process.")
+def split_list_given_task_splitter_args(
+    in_list, task_splitter_args: TaskSplitterArgs, print_fn=None
+):
+    start, num = task_splitter_args.start, task_splitter_args.num
+    return split_list_for_processing(in_list, start, num, print_fn=print_fn)
+def split_list_for_processing(in_list, start: int = 0, num: Optional[int] = None, print_fn=None):
+    len_in_list = len(in_list)
+    if start > 0:
+        in_list = in_list[start:]
+    if num is not None:
+        in_list = in_list[:num]
+    if print_fn is not None:
+        print_fn(
+            f"Split list for processing, input length {len_in_list}, starting at {start}, "
+            f"processing max {num} reduced to {len(in_list)}"
+        )
+    return in_list

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser/funcs.py RENAMED Viewed

@@ -2,7 +2,7 @@ import argparse
 from typing import Any, Dict
 from attr import AttrsInstance
-from attrs import has, fields_dict
+from attrs import has, fields_dict, asdict
 from ._typedattr import attrs_from_dict
 from .objects import get_attr_names
@@ -47,11 +47,36 @@ def add_typed_args(parser: argparse.ArgumentParser, typed_args_class) -> None:
             continue
         shortcut = field_metadata.pop("shortcut", None)
+        if shortcut is not None and len(name_or_flags) > 0:
+            raise ValueError(
+                f"Argument '{field_name}' invalid. With shortcut='{shortcut}' "
+                f"the argument name will be inferred from the field name and therefore the "
+                f"positional arguments must be empty, but got {name_or_flags}."
+            )
+        positional = field_metadata.pop("positional", False)
+        if positional and len(name_or_flags) > 0:
+            raise ValueError(
+                f"Argument '{field_name}' invalid. With positional='{positional} "
+                f"the argument name will be inferred from the field name and therefore the "
+                f"positional arguments must be empty, but got {name_or_flags}."
+            )
+        if shortcut is not None and positional:
+            raise ValueError(
+                f"Argument '{field_name}' invalid. Cannot use positional and shortcut at the same "
+                f"time but got positional='{positional}' and shortcut='{shortcut}'."
+            )
         if len(name_or_flags) == 0:
             name_or_flags = []
-            if shortcut is not None:
-                name_or_flags.append(shortcut)
-            name_or_flags.append(f"--{field_name}")
+            if positional:
+                name_or_flags.append(field_name)
+            else:
+                if shortcut is not None:
+                    name_or_flags.append(shortcut)
+                name_or_flags.append(f"--{field_name}")
         try:
             parser.add_argument(*name_or_flags, **field_metadata)
         except TypeError as e:
@@ -92,8 +117,11 @@ def parse_typed_args(
     if len(missing_args) > 0:
         args_desc = {k: args_dict[k] for k in sorted(missing_args)}
         missing_err = (
-            f"Argument(s) {args_desc} missing from configuration "
-            f"'{typed_args_class.__name__}' with keys {fields_keys}."
+            f"Arguments received from argparse {args_desc} "
+            f"are missing from argument definition '{typed_args_class.__name__}'. "
+            f"This probably means there is a mismatch between the call to add_argument() "
+            f"and the attribute name. "
+            f"Available keys in '{typed_args_class.__name__}': {fields_keys}."
         )
         if strict:
             raise KeyError(missing_err)
@@ -113,7 +141,7 @@ def parse_typed_args(
             raise AttributeError(
                 f"Arguments are missing from configuration and cannot be added. "
                 f"Either add it to the configuration or decorate with @attrs.define(slots=False) "
-                f"to allow adding unknown fields. Missing: {missing_err}"
+                f"to allow adding unknown fields. Missing: {missing_args}"
             ) from e  # noqa
     return out_args

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser/objects.py RENAMED Viewed

@@ -4,17 +4,20 @@ Generic utilities for python objects
 from __future__ import annotations
 from abc import ABCMeta, abstractmethod
+from attr import has, AttrsInstance
+from attrs import fields
 from collections.abc import Mapping, Iterable
 from copy import deepcopy
 from functools import partial
 from typing import Any, Callable, Type, List
-import numpy as np
-from attr import has, AttrsInstance
-from attrs import fields
 AttrsClass = Type[AttrsInstance]
+try:
+    import numpy as np
+except ImportError:
+    np = None
 def get_attr_names(cls: AttrsClass) -> List[str]:
     """Get all attribute names of an attrs class."""
@@ -270,7 +273,7 @@ def _compare_leaf(
     d1: Any, d2: Any, _depth: int, rtol=1.0e-5, atol=1.0e-8, equal_nan=False, prefix=""
 ) -> List[str]:
     # at this point the 2 leaves are guaranteed to be the same type
-    if isinstance(d1, np.ndarray):
+    if np is not None and isinstance(d1, np.ndarray):
         comp = np.allclose(d1, d2, rtol=rtol, atol=atol, equal_nan=equal_nan)
     else:
         comp = d1 == d2

{typedparser-0.6.4 → typedparser-0.20.3}/src/typedparser.egg-info/PKG-INFO RENAMED Viewed

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: typedparser
-Version: 0.6.4
+Version: 0.20.3
 Summary: Extension for python argparse with typehints and typechecks.
-Author: gingsi
+Author: simon-ging
 License: Apache-2.0
-Project-URL: Project-URL, https://github.com/gingsi/typedparser
+Project-URL: Project-URL, https://github.com/simon-ging/typedparser
 Keywords: attrs,typing,dict,attr
 Platform: any
 Classifier: Development Status :: 3 - Alpha
@@ -14,24 +14,48 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs
-Requires-Dist: numpy
+Requires-Dist: importlib_metadata; python_version < "3.8"
+Requires-Dist: typing_extensions; python_version < "3.8"
+Provides-Extra: full
+Requires-Dist: numpy; extra == "full"
 # typedparser
 <p align="center">
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py37.yml">
-  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py37.yml?branch=main&label=build%203.7" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37.yml">
+  <img alt="build 3.7 status" title="build 3.7 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37.yml?branch=main&label=python%203.7" />
 </a>
-<a href="https://github.com/gingsi/typedparser/actions/workflows/build-py310.yml">
-  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/gingsi/typedparser/build-py310.yml?branch=main&label=build%203.10" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py38.yml">
+  <img alt="build 3.8 status" title="build 3.8 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py38.yml?branch=main&label=python%203.8" />
 </a>
-<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/gingsi/typedparser/main/docs/coverage.svg" />
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py39.yml">
+  <img alt="build 3.9 status" title="build 3.9 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py39.yml?branch=main&label=python%203.9" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py310.yml">
+  <img alt="build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py310.yml?branch=main&label=python%203.10" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py311.yml">
+  <img alt="build 3.11 status" title="build 3.11 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py311.yml?branch=main&label=python%203.11" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312.yml">
+  <img alt="build 3.12 status" title="build 3.12 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312.yml?branch=main&label=python%203.12" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py37-full.yml">
+  <img alt="build 3.7 full status" title="build 3.7 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py37-full.yml?branch=main&label=python%203.7%20full" />
+</a>
+<a href="https://github.com/simon-ging/typedparser/actions/workflows/build-py312-full.yml">
+  <img alt="build 3.12 full status" title="build 3.12 full status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/typedparser/build-py312-full.yml?branch=main&label=python%203.12%20full" />
+</a>
+<img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/simon-ging/typedparser/main/docs/coverage.svg" />
 <a href="https://pypi.org/project/typedparser/">
   <img alt="version" title="version" src="https://img.shields.io/pypi/v/typedparser?color=success" />
 </a>
@@ -41,22 +65,6 @@ Typing extension for python argparse using [attrs](https://www.attrs.org/en/stab
 Includes typechecking and conversion utilities to parse a dictionary into an attrs instance.
-## Features
-* Create commandline arguments with type hints and checks while
-staying very close to the syntax of the standard library's argparse.
-* Utilities for typechecking and converting nested objects:
-  * Nested checking and conversion of python standard types
-  * Supports old and new style typing (e.g. `typing.List` and `list`)
-  * Supports positional and keyword arguments in classes
-  * Can also typecheck existing attrs instances
-  * Allows custom conversions, by default converts source type `str` to target type `Path` and
-    `int` to `float`
-  * Allows to redefine which objects will be recursed into, by default recurses into standard
-    containers (list, dict, etc.)
-  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
-* Some object utilities in `typedparser.objects` required for everything else
 ## Install
 Requires `python>=3.7`
@@ -65,11 +73,11 @@ Requires `python>=3.7`
 pip install typedparser
 ```
-## Usage of the parser
+## Basic usage
-1. Create an attrs class (decorate with `@attr.define`)
-2. Define the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
-3. Parse the args with `TypedParser`, now the args are typechecked and there are typehints available.
+1. Create an attrs class (decorate with `@attr.define`). Note that optional arguments must also be typed as optional.
+2. Define and type the fields with `typedparser.add_argument` - the syntax extends [add_argument from argparse](https://docs.python.org/3/library/argparse.html#the-add-argument-method).
+3. Parse the args with `TypedParser` and enjoy args with type hints. Disable typechecking by setting `strict=False`.
 ~~~python
 from typing import Optional
@@ -78,21 +86,21 @@ from typedparser import add_argument, TypedParser
 @define
-class Args:
-    foo: int = add_argument("foo", type=int)
-    bar: int = add_argument("-b", "--bar", type=int, default=0)
-    # Syntax extensions:
+class Args:
+    # omit the argument name to have it inferred from the field name
+    foo: str = add_argument(positional=True)
+    bar: int = add_argument(shortcut="-b", type=int, default=0)
+    opt: Optional[str] = add_argument()
+    # # in case you prefer the regular argparse syntax:
+    # foo: str = add_argument("foo")
+    # bar: int = add_argument("-b", "--bar", type=int, default=0)
+    # opt: Optional[str] = add_argument("--opt")
-    # Omit argument name to create an optional argument --opt
-    opt: Optional[int] = add_argument(type=int)
-    # Use shortcut to create an optional argument -s / --short
-    short: Optional[int] = add_argument(shortcut="-s", type=int)
 def main():
-    parser = TypedParser.create_parser(Args)
+    parser = TypedParser.create_parser(Args, strict=True)
     args: Args = parser.parse_args()
     print(args)
@@ -102,14 +110,31 @@ if __name__ == "__main__":
 ~~~
-### Advanced usage
+## Features
+* Create commandline arguments with type hints and checks while
+staying close to the syntax of the standard library's argparse.
+* Utilities for typechecking and converting nested objects:
+  * Nested checking and conversion of python standard types
+  * Supports old and new style typing (e.g. `typing.List` and `list`)
+  * Supports positional and keyword arguments in classes
+  * Can also typecheck existing attrs instances
+  * Allows custom conversions, by default converts source type `str` to target type `Path` and
+    `int` to `float`
+  * Allows to redefine which objects will be recursed into, by default recurses into standard
+    containers (list, dict, etc.)
+  * `@definenumpy` decorator for equality check if the instances contains numpy arrays
+* Some object utilities in `typedparser.objects` required for everything else
+## Advanced usage
 * Use `TypedParser.from_parser(parser, Args)` to add typing to an existing parser. This is useful
 to cover usecases like subparsers or argument groups.
 * Snippet for argument lists `xarg: List[int] = add_argument(shortcut="-x", type=int, action="append", help="Xarg", default=[])`,
 use as `-x 1 -x 2` to get `[1, 2]` in the args instance.
-## Usage of attr utilities
+### Usage of attr utilities
 Define the class hierarchy and parse the input using `attrs_from_dict`.
 Use `@define(slots=False)` to allow multiple inheritance and setting attributes later.
@@ -143,6 +168,7 @@ print(attrs_from_dict(CfgNested, {"sub_cfg": {"foo": 1, "bar": 2}}))
   the output will be a tuple
 * Raise errors if types cannot be matched, there are unknown fields in the input or
   abstract annotation types are used (e.g. Sequence)
+* Set `_allow_extra_keys = True` in the class definition to allow unknown fields in the input
 ### Non-strict mode
@@ -174,7 +200,7 @@ Note: Some tests are skipped for python 3.7.
 ~~~bash
 pip install -e .
-pip install pytest pytest-cov pylint pytest-lazy-fixture
+pip install pytest pytest-cov pylint
 pylint typedparser
 # run tests