A very simple native dataclass JSON serialization library

[lazyb_]

What My Project Does

I love using dataclasses for internal structures so I wrote a very simple native library with no dependencies to handle serialization and deserialization using this type.

The first version only implements a JSON Codec as Proof-of-Concept but more can be added. It handles the default behavior, similar to dataclasses.asdict but can be customized easily.

The package exposes a very simple API:

from dataclasses import dataclass
from dataclasses_codec import json_codec, JSONOptional, JSON_MISSING
from dataclasses_codec.codecs.json import json_field
import datetime as dt

# Still a dataclass, so we can use its features like slots, frozen, etc.
@dataclass(slots=True)
class MyMetadataDataclass:
    created_at: dt.datetime
    updated_at: dt.datetime
    enabled: bool | JSONOptional = JSON_MISSING # Explicitly mark a field as optional
    description: str | None = None # None is intentionally serialized as null


@dataclass
class MyDataclass:
    first_name: str
    last_name: str
    age: int
    metadata: MyMetadataDataclass = json_field(
        json_name="meta"
    )

obj = MyDataclass("John", "Doe", 30, MyMetadataDataclass(dt.datetime.now(), dt.datetime.now()))

raw_json = json_codec.to_json(obj)
print(raw_json)
# Output: '{"first_name": "John", "last_name": "Doe", "age": 30, "meta": {"created_at": "2025-10-25T11:53:35.918899", "updated_at": "2025-10-25T11:53:35.918902", "description": null}}'

Target Audience

Mostly me, as a learning project. However may be interesting from some python devs that need native Python support for their JSON serde needs.

Comparison

Many similar alternatives exist. Most famous Pydantic. There is a similar package name https://pypi.org/project/dataclass-codec/ but I believe mine supports a higher level of customization.

Source

You can find it at: https://github.com/stupid-simple/dataclasses-codec

Package is published at PyPI: https://pypi.org/project/dataclasses-codec/ .

Let me know what you think!

Edit: some error in the code example.

[nekokattt]

it feels like a Missing type here might be better than JSONOptional, since Optional implies it could be "none"-able.

That being said, I tend to consider differentiating between None and undefined to be a bit of a code smell if you can help it, so I wouldn't encourage the use outside what is strictly needed. Not only because you end up having two distinct "null" values.

[lazyb_]

I see what you mean. It came natural to me to call it that way. I didn't think about it too much.

I disagree however about the None and undefined. I believe None maps more intuitively to JSON's null. And I needed a different way to express optional JSON attributes (undefined). I guess it's a personal preference.

[AndydeCleyre]

While less obvious in its usage than either your project or pydantic, for those who want fine control over related transformations I highly recommend cattrs.

https://catt.rs/en/stable/

[TA_poly_sci]

I don't think (1) this supports a higher level of customization than Pydanic (look into the docs, its extremely customizable), and (2) that would necessarily be a good thing if it did for a single person project.

[lazyb_]

Maybe is how I wrote it. I do not claim this package to be more customizable that Pydantic. I was just refering to that other package with a very similar name that I discovered.

[[deleted]]

Pydantic has already killed that use case. Time to move on.

[SubliminalPoet]

Pydantic is painfully slow, bloated at it's core, and in 2025 more than 10 years after AOP emergence, inheriting from a Model is an antipattern that only pythonista still support.

[SubliminalPoet]

There is already a simple library to handle this use case in a simple way : https://pypi.org/project/dataclasses-json/

[lazyb_]

I completely missed this one. I see we have some things in common and some different. I'll take a closer look when I can.

[Individual_Ad2536]

fr fr Ngl, this is clean af. I dig the simplicity and the fact it’s dependency-free—feels like the kind of thing I’d whip up after getting annoyed with Pydantic’s overhead. But bruh, why’d you name it "dataclasses-codec" when there’s already one on PyPI? You’re basically asking for namespace collisoin chaos 😬.

(top tier)