Version 1.1.0

.github/workflows/pytest.yml

@@ -0,0 +1,25 @@
+name: Run Python Tests
+
+on:
+  push:
+    branches: [ "main", "staging"]
+  pull_request:
+    branches: [ "main", "staging" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - name: Install the latest version of uv
+      uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57
+      with:
+        enable-cache: true
+
+    - name: run tests
+      run: uv run pytest

.github/workflows/test_publish.yml

@@ -0,0 +1,36 @@
+name: "Test Publish"
+
+on:
+  push:
+    branches: [ "main", "staging"]
+  pull_request:
+    branches: [ "main", "staging" ]
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Install Python 3.13
+        run: uv python install 3.13
+      - name: Build
+        run: |
+          uv version --bump patch --bump dev=$RANDOM # random version id
+          uv build
+      # Check that basic features work and we didn't miss to include crucial files
+      - name: Smoke test (wheel)
+        run: uv run --isolated --no-project --with dist/*.whl testing.py
+      - name: Smoke test (source distribution)
+        run: uv run --isolated --no-project --with dist/*.tar.gz testing.py
+      - name: Publish
+        env:
+          TEST_PYPI_SECRET_KEY: ${{ secrets.TEST_PYPI_SECRET_KEY }}
+        run: uv publish --index testpypi --token $TEST_PYPI_SECRET_KEY

.gitignore

@@ -2,6 +2,7 @@ env/
 **/__pycache__/
 dist/
 comprehensiveconfig.egg-info/
+docs/build/
 
 # Testing files
 test.json

.readthedocs.yaml

@@ -0,0 +1,22 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version, and other tools you might need
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.13"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+# Optionally, but recommended,
+# declare the Python requirements required to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+   install:
+   - requirements: docs/requirements.txt

comprehensiveconfig/__init__.py

@@ -48,11 +48,11 @@ def __getattribute__(self, name):
 
         return super().__getattribute__(name)
 
-    def __setattribute__(self, name, value):
+    def __setattr__(self, name, value):
         """set attributes from active instance if available"""
         inst = object.__getattribute__(self, "_INST")
         if inst is not None and name in inst._ALL_FIELDS.keys():
-            return inst.__setattribute__(name, value)
+            return inst.__setattr__(name, value)
 
         return super().__setattr__(name, value)
 

comprehensiveconfig/configio.py

@@ -27,8 +27,8 @@ def dump(cls, file, node: spec.AnyConfigField):
 
     @classmethod
     @abstractmethod
-    def loads(cls, file) -> dict[str, Any]:
-        """load a file by name"""
+    def loads(cls, data: str) -> dict[str, Any]:
+        """load configuration string"""
         pass
 
     @classmethod

comprehensiveconfig/json.py

@@ -1,4 +1,6 @@
+from datetime import datetime
 import json
+from typing import Any
 from . import configio
 from . import spec
 
@@ -7,31 +9,50 @@ class JsonWriter(configio.ConfigurationWriter):
     @classmethod
     def dump_section(cls, node: spec.Section):
         return {
-            node._FIELD_VAR_MAP[name]: (
-                cls.dump_value(node.get_field(name), value)
-            )
+            node._FIELD_VAR_MAP[name]: (cls.dump_value(node.get_field(name), value))
             for name, value in node._value.items()
         }
-    
+
     @classmethod
     def dump_value(cls, node: spec.AnyConfigField, value):
+        """convert value into json_serializable object that can be used as a key or value"""
         match node:
-            case type() | spec.Section():
+            case spec.ConfigurationFieldABCMeta() | spec.Section():
                 return cls.dump_section(value)
-            case spec.Table(_, type() | spec.Section() | spec.ConfigUnion()):
-                return {cls.dump_value(key, key): cls.dump_value(val, val) for key, val in value.items()}
+            case spec.Table(
+                _,
+                spec.ConfigurationFieldABCMeta() | spec.Section() | spec.ConfigUnion(),
+            ):
+                return {
+                    cls.dump_value(key, key): cls.dump_value(val, val)
+                    for key, val in value.items()
+                }
             case spec.ConfigEnum(_, True):
                 return value.name
             case spec.ConfigEnum(_, False):
                 return value.value
-            case _:
+            case str() | int() | float() | datetime() | dict() | None:
                 return value
+            case _:
+                # magic method to make writing new field types possible
+                if hasattr(node, "__write_json_value__"):
+                    return value.__write_json_value__(
+                        node, value
+                    )  # return a json serializable object
 
     @classmethod
     def dumps(cls, node) -> str:
         match node:
             case spec.Section():
                 return json.dumps(cls.dump_section(node), indent=4)
+            case spec.ConfigurationField():
+                if not node._has_default:
+                    raise ValueError("Field has no default value")
+
+                dumped_value = cls.dump_value(node, node._default_value)
+                if isinstance(dumped_value, dict):
+                    return json.dumps(dumped_value)
+                return str(dumped_value)
             case _:
                 raise ValueError(node)
 
@@ -46,5 +67,6 @@ def load(cls, file):
                 return json.load(f)
         return json.load(file)
 
-    # just alias the name
-    loads = json.loads
+    @classmethod
+    def loads(cls, data: str) -> dict[str, Any]:
+        return json.loads(data)