Skip to content

🗂 datacls: take the edge off dataclass 🗂

datacls is a tiny, thin wrapper around dataclass.dataclasses making it a bit more self-contained, reflective, and saving a bit of typing.

datacls is exactly like dataclass, except:

  • Adds three new instance methods: asdict(), astuple(), replace(), and one new class method, fields(), all taken from the dataclasses module

  • xmod-ed for less cruft (so datacls is the same as datacls.dataclass)

  • The default class is datacls.immutable where frozen=True.

Example

import datacls

@datacls
class One:
    one: str = 'one'
    two: int = 2
    three: dict = datacls.field(dict)

# `One` has three instance methods: asdict(), astuple(), replace()

o = One()
assert o.asdict() == {'one': 'one', 'two': 2, 'three': {}}

import dataclasses
assert dataclasses.asdict(o) == o.asdict()

assert o.astuple() == ('one', 2, {})

o2 = o.replace(one='seven', three={'nine': 9})
assert o2 == One('seven', 2, {'nine': 9})

# `One` has one new class method: fields()

assert [f.name for f in One.fields()] == ['one', 'two', 'three']

# @datacls is immutable.

try:
    o.one = 'three'
except AttributeError:
    pass
else:
    raise AttributeError('Was mutable!')

# Usec @datacls.mutable or @datacls(frozen=False)
# for mutable classes

@datacls.mutable
class OneMutable:
    one: str = 'one'
    two: int = 2
    three: Dict = datacls.field(dict)

om = OneMutable()
om.one = 'three'
assert str(om) == "OneMutable(one='three', two=2, three={})"

# These four new methods won't break your old dataclass by mistake:
@datacls
class Overloads:
    one: str = 'one'
    asdict: int = 1
    astuple: int = 1
    fields: int = 1
    replace: int = 1

o = Overloads()

assert ov.one == 'one'
assert ov.asdict == 1
assert ov.astuple == 1
assert ov.fields == 1
assert ov.replace == 1

# You can still access the methods as functions on `datacls`:
assert (
    datacls.asdict(ov) ==
    {'asdict': 1, 'astuple': 1, 'fields': 1, 'one': 'one', 'replace': 1}
)

add_methods(dcls)

Adds dataclasses functions as methods to a dataclass.

Adds three new instance methods: asdict(), astuple(), replace() and one new class method, fields()

Source code in datacls/datacls.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
 
def add_methods(dcls):
    """Adds dataclasses functions as methods to a dataclass.

      Adds three new instance methods: `asdict()`, `astuple()`, `replace()`
      and one new class method, `fields()`
    """
    methods = (m for m in _METHODS if not hasattr(dcls, m))
    for m in methods:
        method = globals()[m]
        if m in _CLASS_METHODS:
            method = classmethod(method)
        setattr(dcls, m, method)
    return dcls

About this project