Metadata-Version: 2.1
Name: pyderive3
Version: 0.0.6
Summary: Python3 Custom Data Class Helpers
Home-page: https://github.com/imgurbot12/pyderive
Author: Andrew Scott
Author-email: imgurbot12@gmail.com
License: MIT
Description: pyderive
        ---------
        
        Python3 Custom Dataclass Helpers
        
        ### Installation
        
        ```bash
        pip install pyderive3
        ```
        
        ### Features
        
        Additional Features availalbe via [Extensions](./pyderive/extensions/README.md).
        
        ##### Expanded Reimplementation of Dataclasses
        
        ###### Default Standards Implemented
        
        _'slots' kwarg now supported in older versions of python such as 3.8_
        
        ```python
        from pyderive import *
        
        @dataclass
        class Foo:
            bar: int
        
        @dataclass(slots=True, order=True)
        class Bar(Foo):
            foo: str
        
        bar = Bar(foo='foo', bar=100)
        print(asdict(bar))
        ```
        
        ###### Recursive Field Compilation
        
        ```python
        from pyderive import *
        from typing import Optional
        
        class Foo:
            bar: int
        
        @dataclass(recurse=True)
        class Bar(Foo):
            foo: Optional[str] = None
        
        bar = Bar(foo='foo', bar=100)
        print(bar)
        ```
        
        ###### Allow for Custom Field Definitions
        
        ```python
        from pyderive import *
        from typing import Any
        
        @dataclass
        class NewField(BaseField):
            custom_attr: bool = False
        
        def field(*_, **kwargs) -> Any:
            return NewField(**kwargs)
        
        @dataclass(field=NewField)
        class Foo:
            a: int
            b: str = field(default='b', repr=False, custom_attr=True)
        
        foo = Foo(1, 'boo')
        print(foo)
        
        for f in fields(foo):
            print(f.name, f.custom_attr)
        ```
        
        ###### Backwards Compatibility
        ```python
        import pyderive
        import dataclasses
        
        @dataclasses.dataclass
        class Foo:
            a: int
            b: int = dataclasses.field(repr=False)
        
        @pyderive.dataclass
        class Bar(Foo):
            c: int = pyderive.field(frozen=True)
        
        f = Bar(1, 2, 3)
        print(f)
        ```
        
        ###### Monkey Patching
        
        ```python
        from pyderive import compat
        compat.monkey_patch()
        
        from dataclasses import dataclass, field
        
        @dataclass
        class Foo:
            a: int
            b: int = field(frozen=True)
        
        f = Foo(1, 2)
        print(f)
        ```
        
        ##### Low Level Dataclass Compilation Tools
        
        ```python
        from pyderive import *
        
        class Foo:
            foo: int
        
        class Bar(Foo):
            bar: int = 100
        
        # parse class-structure into raw unordered heigharhcy
        struct = parse_fields(Bar, recurse=True)
        print('struct', struct)
        
        # order and structure fields into organized list following dataclass standard
        fields = flatten_fields(struct)
        print('final_fields', fields)
        
        # build and assign `init` and `repr` functions to `Bar` class
        assign_func(Bar, create_init(fields))
        assign_func(Bar, create_repr(fields))
        
        # assign slots for field definitions onto `Bar` class
        Bar = add_slots(Bar, fields)
        print(Bar.__slots__)
        
        # initialize foo w/ compiled `init` func and print w/ added `repr`
        bar = Bar(foo=1, bar=2)
        print(bar)
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.8
Description-Content-Type: text/markdown
