Python 3.14 support, pyproject.toml and CI modernization

Author: zigai

.editorconfig

@@ -6,6 +6,7 @@ indent_size = 4
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
+end_of_line = lf
 
-[{*.yaml, *.yml}]
+[*.{yaml,yml}]
 indent_size = 2

.github/workflows/lint.yml

@@ -1,17 +1,23 @@
 name: Lint
 on: [push, pull_request]
+
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v7
+
       - name: Set up Python
         run: uv python install 3.12
+
       - name: Install dependencies
-        run: uv sync --extra dev
-      - name: Run ruff
-        run: uv run ruff check .
-      - name: Run black
-        run: uv run black --check .
+        run: uv sync --extra dev --python 3.12
+
+      - name: Check formatting with Ruff
+        run: uv run --python 3.12 ruff format --check .
+
+      - name: Run Ruff lint
+        run: uv run --python 3.12 ruff check .

.github/workflows/python-publish.yml

@@ -6,9 +6,9 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v7
       - name: Set up Python
         run: uv python install 3.12
       - name: Build and publish

.github/workflows/tests.yml

@@ -1,22 +1,26 @@
 name: Tests
 on: [push, pull_request]
+
 jobs:
   tests:
-    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    runs-on: ${{ matrix.os }}
+
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
-        with:
-          python-version: ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
       - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-           pip install -e .[test]
+        run: uv sync --extra test --python ${{ matrix.python-version }}
+
       - name: Run pytest
-        run: |
-          pytest -v
+        run: uv run --python ${{ matrix.python-version }} pytest -v

.pre-commit-config.yaml

@@ -8,8 +8,8 @@ repos:
       - id: check-toml
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.4
+    rev: v0.14.2
     hooks:
-      - id: ruff
-        args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-check
+        args: [--fix, --exit-zero]
       - id: ruff-format

Justfile

@@ -1,41 +1,62 @@
 @_:
-   just --list
+  just --list
 
 _require-uv:
-   @uv --version > /dev/null || (echo "Please install uv: https://docs.astral.sh/uv/" && exit 1)
+  @uv --version > /dev/null || (echo "Please install uv: https://docs.astral.sh/uv/" && exit 1)
 
 _require-hatch:
   @hatch --version > /dev/null || (echo "Please install hatch: uv tool install hatch" && exit 1)
 
 # check code style and potential issues
 lint:
-   ruff check
-
-# fix automatically fixable linting issues
-fix:
-   ruff check --fix
+  ruff check
 
 # format code
 format:
-   ruff format
+  ruff format
+
+# fix automatically fixable linting issues
+fix:
+  ruff check --fix
 
 # run tests across all supported Python versions
 test: _require-hatch
-   hatch run test:test
-
-# run all quality checks
-check: format lint test
+  hatch run test:test
 
 # build the package
 build: _require-uv
-   uv build
+  uv build
 
-# setup development environment
+# setup or update local dev environment, keeps previously installed extras
 dev: _require-uv
-   uv sync --extra dev
-   uv run pre-commit install
+  uv sync --inexact --extra dev
+  uv run pre-commit install
+
+# run tests with coverage and show a coverage report
+coverage:
+  coverage run -m pytest
+  coverage report
 
 # clean build artifacts and caches
 clean:
-   rm -rf .venv .pytest_cache .mypy_cache .ruff_cache
-   find . -type d -name "__pycache__" -exec rm -r {} +
+  rm -rf .venv .pytest_cache .mypy_cache .ruff_cache
+  find . -type d -name "__pycache__" -exec rm -r {} +
+
+# static type check with mypy
+typecheck: _require-uv
+    uv run mypy
+
+# check code for common misspellings
+spell:
+    codespell
+
+# run all quality checks
+check: format lint coverage typecheck spell
+
+# list available recipes
+help:
+    just --list
+
+alias fmt := format
+alias cov := coverage
+alias mypy := typecheck

confdantic/confdantic.py

@@ -68,30 +68,26 @@ class Confdantic(BaseModel):
 
     def to_commented_yaml(self) -> CommentedMap | CommentedSeq:
         """Converts the Confdantic instance to a CommentedMap or CommentedSeq for YAML serialization."""
-        return self._to_commented_yaml(self)
+        data = self.model_dump()
+        return self._to_commented_yaml(data)
 
     def _to_commented_yaml(self, obj: Any) -> CommentedMap | CommentedSeq | Any:
-        if issubclass(obj.__class__, BaseModel):
+        if isinstance(obj, dict):
             cm = CommentedMap()
-            for field_name, field in obj.model_fields.items():
-                value = getattr(obj, field_name)
-                cm[field_name] = self._to_commented_yaml(value)
-
-                comment = get_comment(field, format="yaml")
-                if comment:
-                    cm.yaml_add_eol_comment(comment, field_name)
+            for key, value in obj.items():
+                cm[key] = self._to_commented_yaml(value)
 
+                if issubclass(self.__class__, BaseModel) and key in self.__class__.model_fields:
+                    field = self.__class__.model_fields[key]
+                    comment = get_comment(field, format="yaml")
+                    if comment:
+                        cm.yaml_add_eol_comment(comment, key)
             return cm
         elif isinstance(obj, list):
             cs = CommentedSeq()
             for item in obj:
                 cs.append(self._to_commented_yaml(item))
             return cs
-        elif isinstance(obj, dict):
-            cm = CommentedMap()
-            for key, value in obj.items():
-                cm[key] = self._to_commented_yaml(value)
-            return cm
         else:
             return obj
 
@@ -126,7 +122,13 @@ def load(cls, filepath: str):
             case _:
                 raise ValueError(f"Unknown file extension: {ext}")
 
-    def save(self, filepath: str, overwrite: bool = True, comments: bool = True):
+    def save(
+        self,
+        filepath: str,
+        overwrite: bool = True,
+        comments: bool = True,
+        serialize_unsupported: bool = False,
+    ):
         """
         Save the configuration to a file.
 
@@ -137,6 +139,7 @@ def save(self, filepath: str, overwrite: bool = True, comments: bool = True):
             filepath (str): The path where the configuration file will be saved.
             overwrite (bool, optional): Whether to overwrite the file if it already exists. Defaults to True.
             comments (bool, optional): Whether to include comments in the saved file. Defaults to True.
+            serialize_unsupported (bool, optional): Whether to serialize unsupported types as strings. Defaults to False.
 
         Raises:
             FileExistsError: If the file already exists and overwrite is False.
@@ -148,11 +151,22 @@ def save(self, filepath: str, overwrite: bool = True, comments: bool = True):
         ext = file_ext(filepath)
         match ext:
             case "toml" | "tml":
-                return self.save_toml(filepath, overwrite=overwrite, comments=comments)
+                return self.save_toml(
+                    filepath,
+                    overwrite=overwrite,
+                    comments=comments,
+                    serialize_unsupported=serialize_unsupported,
+                )
             case "yaml" | "yml":
-                return self.save_yaml(filepath=filepath, overwrite=overwrite)
+                return self.save_yaml(
+                    filepath=filepath,
+                    overwrite=overwrite,
+                    serialize_unsupported=serialize_unsupported,
+                )
             case "json":
-                return self.save_json(filepath, overwrite=overwrite)
+                return self.save_json(
+                    filepath, overwrite=overwrite, serialize_unsupported=serialize_unsupported
+                )
             case _:
                 raise ValueError(f"Unknown file extension: {ext}")
 
@@ -173,14 +187,20 @@ def load_toml(cls, filepath: str):
             return cls.model_validate(toml.load(f))
 
     @classmethod
-    def load_json(cls, filepath: str):
-        with open(filepath) as f:
+    def load_json(cls, filepath: str, encoding: str = "utf-8"):
+        with open(filepath, encoding=encoding) as f:
             return cls.model_validate(json.load(f))
 
-    def save_toml(self, filepath: str, overwrite: bool = True, comments: bool = True) -> None:
+    def save_toml(
+        self,
+        filepath: str,
+        overwrite: bool = True,
+        comments: bool = True,
+        serialize_unsupported: bool = False,
+    ) -> None:
         if os.path.exists(filepath) and not overwrite:
             raise FileExistsError(filepath)
-        data = self.model_dump()
+        data = self.model_dump(mode="json") if serialize_unsupported else self.model_dump()
         toml_string = tomlkit.dumps(data)
         toml_doc = tomlkit.loads(toml_string)
 
@@ -189,7 +209,7 @@ def save_toml(self, filepath: str, overwrite: bool = True, comments: bool = True
                 tomlkit.dump(toml_doc, f)
                 return
 
-        for name, field in self.model_fields.items():
+        for name, field in self.__class__.model_fields.items():
             item = toml_doc.item(name)
             comment = get_comment(field, format="toml")
             if comment:
@@ -214,26 +234,35 @@ def save_toml(self, filepath: str, overwrite: bool = True, comments: bool = True
         with open(filepath, "w") as f:
             tomlkit.dump(toml_doc, f)
 
-    def save_json(self, filepath: str, overwrite: bool = True) -> None:
+    def save_json(
+        self,
+        filepath: str,
+        overwrite: bool = True,
+        serialize_unsupported: bool = False,
+    ) -> None:
         if os.path.exists(filepath) and not overwrite:
             raise FileExistsError(filepath)
-        data = self.model_dump()
+        data = self.model_dump(mode="json") if serialize_unsupported else self.model_dump()
         with open(filepath, "w") as f:
-            json.dump(data, f)
-
-    def save_yaml(self, filepath: str, overwrite: bool = True, comments: bool = True) -> None:
+            json.dump(data, f, indent=4, default=str)
+
+    def save_yaml(
+        self,
+        filepath: str,
+        overwrite: bool = True,
+        comments: bool = True,
+        serialize_unsupported: bool = False,
+    ) -> None:
         if os.path.exists(filepath) and not overwrite:
             raise FileExistsError(filepath)
 
         yaml = YAML()
         yaml.indent(mapping=2, sequence=4, offset=2)
         yaml.preserve_quotes = True
 
-        data = self.model_dump()
+        data = self.model_dump(mode="json") if serialize_unsupported else self.model_dump()
         if comments:
-            data = self.to_commented_yaml()
-        else:
-            data = self.model_dump()
+            data = self._to_commented_yaml(data)
         with open(filepath, "w") as f:
             yaml.dump(data, f)