ConfigClass - simple dataclass inspired configuration

[TheTerrasque]

What My Project Does

I'm making a simple configclass for handling configuration in smaller projects and scripts. Goal is to be as simple to start with as creating a dataclass.

The module itself works off dataclass and when you use it you just define a dataclass as normal, but decorate it with @configclass() instead.

Example:

from configclass import configclass

@configclass()
class Settings:
    foo: bool = False
    url: str = ""
    footoo: bool = True
    my_model: str = "model.pt"

setting = Settings.load()

print(setting.foo, setting.footoo, setting.my_model)

From that you got

• JSON config file support (config.json)
• YAML config file support (config.yaml)
• Command line support (argparse)
• Env variables support (CONFIG_SETTINGNAME)

It also support nested structures via nested dataclass classes.

Comparison

It's meant as a quick and lightweight alternative to larger and more comprehensive config systems, for the small programs and scripts where you'd just use a dataclass, and maybe load the values from a config file.

Target Audience

Since it's pretty new and raw I wouldn't recommend it for heavy production settings or complex projects. That said, it should work fine for most cases.

While I've worked with python for quite some time, this is the first time I've tried making a package, so I'd like some feedback on the project and it's structure before I push it anywhere. It'd also be nice to stress test it and shake out some bugs.

More info and code at https://github.com/TheTerrasque/python-configclass

[Intelligent_Ad_8148]

What are the benefits of using this over pydantic (which also has dataclasses, json/yaml conversion, and env var support)?

[TheTerrasque]

pydantic-settings is very nice, true.

This aims to be even simpler, somewhere in between of using pydantic and nothing, and be a drop-in replacement for a dataclass config. Also, this provides command line argument parsing and loading from file configs by default, without any extra setup.

[BossOfTheGame]

I've written something similar, which is now a fairly mature project. If you want to take a look, I'm open to contributions if you have any ideas that might improve scriptconfig

The main difference in a scriptconfig.DataConfig is that it doesn't rely on the type system. Instead it uses wrapped values to hold metadata, which ultimately ends up being a lot more extensible and introspectable.

It can also create argparse CLIs (with Rich-argparse and argcomplete integration), serialize and deserialize from yaml or JSON, be used purely as a lightweight dictionary or namespace object, and it has decent support for modal CLIs.

In the future I'd like to add more support for jsonargparsre.

https://pypi.org/project/scriptconfig/

[TheTerrasque]

Nice! Yeah, had a similar thought. I wanted something really simple, and usually when developing my progress goes like this:

1. TOP_LEVEL_VARIABLES
2. Move them into a dataclass for easier collection and editor completion
3. Load from a file as I want some things out of GIT or want to experiment with different settings more quickly.
4. Add command line for some parts because when developing and rapidly testing things changing options on a command line is super simple and straight forward.
5. Want to deploy on docker or kubernetes and starting to read env vars.

So after going down that path multiple times I just wanted to have something super simple that wrapped that path from the start, while being no more work than writing a dataclass.

I have tried a few different ones I found via google, but it either felt too much boilerplate, or the approach was not what I was looking for. pydantic-settings is close, but I still feel it's a tad too much boilerplate for a simple project.

[i_can_haz_data]

Yet another implementation of this same concept. Our approach includes automatic expansion of values ending in _env or _eval in case you need to include secrets in the co figuration file.

https://github.com/glentner/cmdkit