bluenote10
commented
1 year ago Thanks for the idea!
Actually I'd like to switch from a parsing __init__ constructor (i.e., one which gets an argparse.Namespace instance) to a non-parsing / fully typed __init__. This has the benefit that the classes can be used like regular dataclass like classes, which simply forward all its arguments in the __init__ (if the __init__ is type safe there is no need for validation there thanks to type checking). I need to revisit the dataclass transform specs and how all this could play together.
Note that using conflicting type annotations like is done for e is probably not such a good idea. Does the type annotation now basically lie about the actual type?
HeinrichAD
Thanks for the great project 👍
As far as I can see, the
TypedArgsclass usestyping.dataclass_transform, which seems to work differently thandataclasses.dataclass.I would like to propose to add the feature to use
InitVar(init-only field/attribute).It would be great to be able to be able to do something like this:
A quick and dirty version (for testing) could be something like this
`typed_argparse/type_utils.py` ```diff import sys +from dataclasses import InitVar from enum import Enum [...] class TypeAnnotation: def __init__(self, raw_type: RawTypeAnnotation): - self.raw_type: RawTypeAnnotation = raw_type + self.raw_type: RawTypeAnnotation = raw_type.type if isinstance(raw_type, InitVar) else raw_type self.origin = _get_origin(raw_type) self.args = _get_args(raw_type) ``` After these little changes we are able to work with the following code snippet which is unfortunately not working perfect. ```python #!/usr/bin/env python3 from dataclasses import dataclass, InitVar import typed_argparse as tap @dataclass class Args(tap.TypedArgs): a: int b: int = tap.arg(default=42, help="help b") c: InitVar[int] = tap.arg(default=4711, help="help c") # init-only field/attribute e: int = tap.arg(default=42, help="help e") def __init__(self, **kwargs): super().__init__(**kwargs) print("init:", kwargs) # ✔ init: {'a': 5, 'b': 42, 'c': 4711, 'e': 42} self.d: int = self.a + self.b + kwargs["c"] # new attribute self.e: str = str(self.e) # change attribute type def run_test(args: Args) -> None: print("Running test:") print(args) # ✘ Args(a=5, b=42, e='42') # ^^^^^^^^^^^^^^^^^ d=4758 should be present print(args.d) # ✔ 4758 (5 + 42 + 4711) print(type(args.d)) # ✔ int print(type(args.e)) # ✔ str print(args.__dict__) # ✘ {'a': 5, 'b': 42, 'c': 4711, 'e': '42', 'd': 4758} # ^^^^^^^^^^ this should not be present here if __name__ == "__main__": tap.Parser(Args).bind(run_test).run(["--a", "5"]) ``` The problems are: ```python print(args) # ✘ Args(a=5, b=42, e='42') # ^^^^^^^^^^^^^^^^^ d=4758 should be present print(args.__dict__) # ✘ {'a': 5, 'b': 42, 'c': 4711, 'e': '42', 'd': 4758} # ^^^^^^^^^^ this should not be present here ``` But at least the IntelliSense/code completion is working (setup: vscode+mypy): - `c` is not shown - `d` is visible - `e` has the correct type 