confkit 1.3.0__tar.gz → 2.0.0__tar.gz

{confkit-1.3.0 → confkit-2.0.0}/.github/workflows/bump-version-by-labels.yml

@@ -30,9 +30,10 @@ jobs:
 
       - name: Determine version bump
         id: detect-bump
+        env:
+          LABELS: ${{ github.event.pull_request.labels.*.name }}
         run: |
           # Check PR labels to determine bump type
-          LABELS="${{ github.event.pull_request.labels.*.name }}"
           if echo "$LABELS" | grep -q "Major"; then
             echo "bump_type=major" >> $env:GITHUB_OUTPUT
           elif echo "$LABELS" | grep -q "Minor"; then

confkit-2.0.0/.github/workflows/lint.yml

@@ -0,0 +1,40 @@
+name: Lint & Type Check
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+  workflow_call:
+
+concurrency: lint-${{ github.sha }}
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache lint results
+        id: cache-lint
+        uses: actions/cache@v4
+        with:
+          path: .lint_cache
+          key: ${{ runner.os }}-lint-${{ hashFiles('**/tests/**/*.py', 'src/**') }}
+          restore-keys: |
+            ${{ runner.os }}-lint
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Run ruff check
+        run: uv run ruff check .
+
+      - name: Run type checking
+        run: uvx ty check . --ignore no-matching-overload

{confkit-1.3.0 → confkit-2.0.0}/.github/workflows/test.yml

@@ -49,12 +49,5 @@ jobs:
 
       - name: Run tests
         if: steps.cache-pytest.outputs.cache-hit != 'true'
-        run: uv run pytest .
-
-      - name: Run ruff check
-        if: steps.cache-pytest.outputs.cache-hit != 'true'
-        run: uv run ruff check .
-
-      - name: Run type checking
-        if: steps.cache-pytest.outputs.cache-hit != 'true'
-        run: uvx ty check . --ignore no-matching-overload
+        # Avoid executing examples in CI; they could run untrusted code from PRs
+        run: uv run pytest . --ignore=tests/test_examples_run.py

{confkit-1.3.0 → confkit-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confkit
-Version: 1.3.0
+Version: 2.0.0
 Summary: Lightweight and Easy to use configuration manager for Python projects
 Author: HEROgold
 Requires-Python: >=3.11

{confkit-1.3.0 → confkit-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "confkit"
-version = "1.3.0"
+version = "2.0.0"
 description = "Lightweight and Easy to use configuration manager for Python projects"
 readme = "README.md"
 authors = [

{confkit-1.3.0 → confkit-2.0.0}/ruff.toml

@@ -1,11 +1,17 @@
-lint.select = ["ALL"]
-lint.ignore = ["D203", "G004"]
 line-length = 128
 target-version = "py311"
 
+[lint]
+select = ["ALL"]
+ignore = ["D203", "G004"]
+
+[lint.isort]
+required-imports = ["from __future__ import annotations"]
+
 [lint.per-file-ignores]
 "test_*.py" = ["S101", "D103", "SLF001", "D100","D101", "FBT003", "PLR2004", "N814", "S105"]
 "examples/*.py" = ["ALL"]
+"src/confkit/data_types.py" = ["E701"] # Allow inline return after : on match for readability
 
 [format]
 # Don't apply line-length formatting to comments

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/__init__.py

@@ -2,6 +2,7 @@
 
 It includes the Config class and various data types used for configuration values.
 """
+from __future__ import annotations
 
 from .config import Config, ConfigContainerMeta
 from .data_types import (

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/config.py

@@ -60,6 +60,7 @@ class Config(Generic[VT]):
     _parser: ConfkitParser = UNSET
     _file: Path = UNSET
     _has_read_config: bool = False
+    _data_type: BaseDataType[VT]
 
     if TYPE_CHECKING:
         # Overloads for type checkers to understand the different settings of the Config descriptors.
@@ -69,13 +70,13 @@ class Config(Generic[VT]):
         def __init__(self, default: VT) -> None: ...
         # Specify the states of optional explicitly for type checkers.
         @overload
-        def __init__(self: Config[VT], default: VT, *, optional: Literal[False]) -> None: ...
+        def __init__(self: Config[OVT], default: OVT, *, optional: Literal[False]) -> None: ...
         @overload
-        def __init__(self: Config[VT], default: BaseDataType[VT], *, optional: Literal[False]) -> None: ...
+        def __init__(self: Config[OVT], default: BaseDataType[OVT], *, optional: Literal[False]) -> None: ...
         @overload
-        def __init__(self: Config[VT | None], default: VT, *, optional: Literal[True]) -> None: ...
+        def __init__(self: Config[OVT | None], default: OVT, *, optional: Literal[True]) -> None: ...
         @overload
-        def __init__(self: Config[VT | None], default: BaseDataType[VT], *, optional: Literal[True]) -> None: ...
+        def __init__(self: Config[OVT | None], default: BaseDataType[OVT], *, optional: Literal[True]) -> None: ...
 
     def __init__(
         self,
@@ -144,9 +145,7 @@ class Config(Generic[VT]):
 
     def convert(self, value: str) -> VT:
         """Convert the value to the desired type using the given converter method."""
-        # Ignore the type error of VT, type checkers don't like None as an option
-        # We handle it using the `optional` flag, or using Optional DataType. so we can safely ignore it.
-        return self._data_type.convert(value) # type: ignore[reportReturnType]
+        return self._data_type.convert(value)
 
     @staticmethod
     def _warn_base_class_usage() -> None:

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/data_types.py

@@ -6,6 +6,10 @@ import enum
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from datetime import UTC, date, datetime, time, timedelta, tzinfo
+from enum import Enum as dEnum
+from enum import IntEnum as dIntEnum
+from enum import IntFlag as dIntFlag
+from enum import StrEnum as dStrEnum
 from typing import ClassVar, Generic, NotRequired, Required, TypedDict, TypeVar, Unpack, cast, overload
 
 from confkit.sentinels import UNSET
@@ -65,30 +69,28 @@ class BaseDataType(ABC, Generic[T]):
         return Optional(BaseDataType.cast(default))
 
     @staticmethod
-    def cast(default: T | BaseDataType[T]) -> BaseDataType[T]:
+    def cast(default: T | BaseDataType[T]) -> BaseDataType[T]:  # noqa: C901, PLR0911
         """Convert the default value to a BaseDataType."""
         # We use Cast to shut up type checkers, as we know primitive types will be correct.
         # If a custom type is passed, it should be a BaseDataType subclass, which already has the correct types.
+        # Check enum types BEFORE basic types since some enums inherit from str/int
         match default:
-            case bool():
-                data_type = cast("BaseDataType[T]", Boolean(default))
-            case None:
-                data_type = cast("BaseDataType[T]", NoneType())
-            case int():
-                data_type = cast("BaseDataType[T]", Integer(default))
-            case float():
-                data_type = cast("BaseDataType[T]", Float(default))
-            case str():
-                data_type = cast("BaseDataType[T]", String(default))
-            case BaseDataType():
-                data_type = default
+            case dStrEnum():     return cast("BaseDataType[T]", StrEnum(default))
+            case dIntFlag():     return cast("BaseDataType[T]", IntFlag(default))
+            case dIntEnum():     return cast("BaseDataType[T]", IntEnum(default))
+            case dEnum():        return cast("BaseDataType[T]", Enum(default))
+            case bool():         return cast("BaseDataType[T]", Boolean(default))
+            case None:           return cast("BaseDataType[T]", NoneType())
+            case int():          return cast("BaseDataType[T]", Integer(default))
+            case float():        return cast("BaseDataType[T]", Float(default))
+            case str():          return cast("BaseDataType[T]", String(default))
+            case BaseDataType(): return default
             case _:
                 msg = (
                     f"Unsupported default value type: {type(default).__name__}. "
                     "Use a BaseDataType subclass for custom types."
                 )
                 raise InvalidDefaultError(msg)
-        return data_type
 
 
 class _EnumBase(BaseDataType[T]):
@@ -203,12 +205,17 @@ class NoneType(BaseDataType[None]):
         """Initialize the NoneType data type."""
         super().__init__(None)
 
-    def convert(self, value: str) -> bool: # type: ignore[reportIncompatibleMethodOverride]
-        """Convert a string value to None."""
-        # Ignore type exception as convert should return True/False for NoneType
-        # to determine if we have a valid null value or not.
+    def is_valid(self, value: str) -> bool:
+        """Check if the provided string value is in the set of null values."""
         return value.casefold().strip() in NoneType.null_values
 
+    def convert(self, value: str) -> None:
+        """Convert a string value to None."""
+        if self.is_valid(value):
+            return
+        msg = f"Value '{value}' is not a valid null value. Expected one of: {', '.join(NoneType.null_values)}."
+        raise ValueError(msg)
+
 
 class String(BaseDataType[str]):
     """A config value that is a string."""
@@ -359,8 +366,8 @@ class Optional(BaseDataType[T | None], Generic[T]):
 
     def convert(self, value: str) -> T | None:
         """Convert a string value to the optional type."""
-        if self._none_type.convert(value):
-            return None
+        if self._none_type.is_valid(value):
+            return self._none_type.convert(value)
         return self._data_type.convert(value)
 
     def validate(self) -> bool:

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/exceptions.py

@@ -1,4 +1,6 @@
 """Module for custom exceptions used in the confkit package."""
+from __future__ import annotations
+
 
 class InvalidDefaultError(ValueError):
     """Raised when the default value is not set or invalid."""

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/ext/__init__.py

@@ -4,5 +4,6 @@ Modules inside this package may rely on optional extras. They are intentionally
 not imported eagerly so users can access the pieces they installed without
 pulling in additional dependencies.
 """
+from __future__ import annotations
 
 __all__: list[str] = []

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/ext/pydantic.py

@@ -1,7 +1,13 @@
 """Helper utilities for working with Pydantic models and confkit."""
+from __future__ import annotations
 
-try:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
     from pydantic import BaseModel
+
+try:
+    import pydantic  # noqa: F401
 except ImportError as exc:
     msg = (
         "confkit.ext.pydantic requires the optional 'pydantic' extra. "

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/ext/reference.py

@@ -2,6 +2,7 @@
 
 It allows you to create relative references to other configuration files
 """
+from __future__ import annotations
 
 from pathlib import Path
 from typing import Any

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/parsers.py

@@ -177,7 +177,6 @@ class EnvParser(ConfkitParser):
     @override
     def set_section(self, section: str) -> None:
         """EnvParser has no sections, this is a no-op."""
-        pass  # noqa: PIE790
 
     @override
     def set_option(self, option: str) -> None:
@@ -188,7 +187,6 @@ class EnvParser(ConfkitParser):
     @override
     def add_section(self, section: str) -> None:
         """EnvParser has no sections, this is a no-op."""
-        pass  # noqa: PIE790
 
     @override
     def set(self, section: str, option: str, value: object) -> None:

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/sentinels.py

@@ -1,4 +1,5 @@
 """Private sentinel for missing values."""
+from __future__ import annotations
 
 from typing import Any
 

{confkit-1.3.0 → confkit-2.0.0}/src/confkit/watcher.py

@@ -1,5 +1,10 @@
 """A simple file watcher to monitor changes in a file."""
-from pathlib import Path
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
 
 
 class FileWatcher:  # noqa: D101

{confkit-1.3.0 → confkit-2.0.0}/tests/test_config.py

@@ -1,4 +1,6 @@
 """Test suite for the Config class and its descriptors."""
+from __future__ import annotations
+
 import enum
 from enum import auto
 from pathlib import Path
@@ -105,10 +107,10 @@ class Test:
     binary_value = Config(Binary(0b101010))
     binary_value_2 = Config(Binary(b"101010"))
     # Test invalid setups (Type checkers like pyright will raise errors here)
-    none_int = Config(Integer(None)) # type: ignore[reportArgumentType]
-    none_string = Config(String(None)) # type: ignore[reportArgumentType]
-    none_boolean = Config(Boolean(None)) # type: ignore[reportArgumentType]
-    none_float = Config(Float(None)) # type: ignore[reportArgumentType]
+    none_int = Config(Integer(None))
+    none_string = Config(String(None))
+    none_boolean = Config(Boolean(None))
+    none_float = Config(Float(None))
     # Custom data type tests
     custom = Config(Integer(0))
     optional_custom = Config(Optional(Integer(0)))
@@ -153,7 +155,7 @@ class Test:
     list_of_paths = Config(List(["/path/to/file1", "/path/to/file2"]))
 
     @Config.with_setting(number)
-    def setting(self, **kwargs):  # type: ignore[reportMissingParameterType]  # noqa: ANN003, ANN201, D102
+    def setting(self, **kwargs):  # noqa: ANN003, ANN201, D102
         return kwargs.get("number")
 
 @pytest.mark.order(0)
@@ -183,19 +185,19 @@ def test_int_flag() -> None:
 
 def test_init_no_args() -> None:
     with pytest.raises((InvalidDefaultError, InvalidConverterError)):
-        Config() # type: ignore[reportCallIssue]
+        Config()
 
 
 def test_init_no_default() -> None:
     with pytest.raises(InvalidDefaultError):
-        Config() # type: ignore[reportCallIssue]
+        Config()
 
 
 def test_optional_validate_none_value() -> None:
     """Test Optional.validate when value is None."""
     optional_type = Optional(String("default"))
     # Use monkey patching to set internal state
-    with patch.object(optional_type._data_type, "value", None):  # type: ignore[attr-defined]
+    with patch.object(optional_type._data_type, "value", None):
         assert optional_type.validate() is True
 
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_config_classvars.py

@@ -2,10 +2,11 @@
 
 This also contains the test cases where specific settings are expected.
 """
+from __future__ import annotations
+
 import tempfile
-from collections.abc import Callable
 from pathlib import Path
-from typing import Never, ParamSpec, TypeVar
+from typing import TYPE_CHECKING, Never, ParamSpec, TypeVar
 
 import pytest
 from hypothesis import given
@@ -17,6 +18,9 @@ from confkit.exceptions import InvalidConverterError, InvalidDefaultError
 from confkit.parsers import IniParser
 from confkit.sentinels import UNSET
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 F = TypeVar("F")
 P = ParamSpec("P")
 
@@ -60,7 +64,7 @@ def test_config_validate_parser_unset() -> None:
 def test_config_converter_is_unset() -> None:
     """Test validate_strict_type when converter is UNSET - Line 154 in config.py."""
     class MockDataType(BaseDataType[str]):
-        def convert(self, value: str) -> Never: # ty: ignore[invalid-return-type]
+        def convert(self, value: str) -> Never:
             ...
 
     # Create a temporary isolated environment
@@ -148,7 +152,7 @@ def test_config_type_mismatch_error() -> None:
     class WrongTypeDataType(BaseDataType[str]):
         def __init__(self, default: str) -> None:
             super().__init__(default)
-        def convert(self, value: str) -> int:  # type: ignore[override]
+        def convert(self, value: str) -> int:
             return int(value)
 
     # Create a temporary isolated environment

{confkit-1.3.0 → confkit-2.0.0}/tests/test_config_decorators.py

@@ -3,9 +3,10 @@
 These are usually not safe enough to test using a single file, at the same time.ArithmeticError
 These get their own test file.
 """
-from collections.abc import Callable
+from __future__ import annotations
+
 from pathlib import Path
-from typing import ParamSpec, TypeVar
+from typing import TYPE_CHECKING, ParamSpec, TypeVar
 
 import pytest
 from hypothesis import given
@@ -15,6 +16,9 @@ from confkit.config import Config as OG
 from confkit.parsers import IniParser
 from confkit.sentinels import UNSET
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 F = TypeVar("F")
 P = ParamSpec("P")
 
@@ -25,7 +29,7 @@ def config_new(func: Callable[P, F]) -> Callable[P, F]:
     """Save and restore the _file and _parser attributes for the Config."""
     def inner(*args: P.args, **kwargs: P.kwargs) -> F:
         restores = (getattr(Config, "_file", UNSET), getattr(Config, "_parser", UNSET))
-        new_file = Path(f"{func.__name__}.ini")  # ty: ignore[unresolved-attribute]
+        new_file = Path(f"{func.__name__}.ini")
         new_file.touch(exist_ok=True)
         Config._file = new_file
         Config._parser = IniParser()

{confkit-1.3.0 → confkit-2.0.0}/tests/test_config_detect_parser.py

@@ -1,4 +1,6 @@
 """Test Config.detect_parser behavior for different file extensions."""
+from __future__ import annotations
+
 from pathlib import Path
 
 import pytest

{confkit-1.3.0 → confkit-2.0.0}/tests/test_data_types.py

@@ -1,4 +1,6 @@
 """Tests for data type classes in confkit.data_types."""
+from __future__ import annotations
+
 from datetime import UTC, date, datetime, time, timedelta
 from typing import Final
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_enum_allowed_values.py

@@ -1,4 +1,6 @@
 """Tests for enum types displaying allowed values."""
+from __future__ import annotations
+
 import enum
 from enum import IntEnum, IntFlag, StrEnum, auto
 

confkit-2.0.0/tests/test_enum_auto_conversion.py

@@ -0,0 +1,146 @@
+"""Tests for automatic enum type conversion in Config descriptors.
+
+Tests that StrEnum, IntEnum, IntFlag, and Enum defaults are automatically
+wrapped in their corresponding data type converters when used with Config.
+"""
+from __future__ import annotations
+
+import enum
+from enum import IntEnum, IntFlag, StrEnum
+from typing import TYPE_CHECKING
+
+from confkit import Config as ConfigBase
+from confkit.data_types import Enum as ConfigEnum
+from confkit.data_types import IntEnum as ConfigIntEnum
+from confkit.data_types import IntFlag as ConfigIntFlag
+from confkit.data_types import StrEnum as ConfigStrEnum
+from confkit.parsers import IniParser
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class LogLevel(StrEnum):
+    """String-based enum for log levels."""
+
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+class Priority(IntEnum):
+    """Integer-based enum for task priorities."""
+
+    LOW = 0
+    MEDIUM = 5
+    HIGH = 10
+
+
+class Permission(IntFlag):
+    """Integer flag enum for permission bits."""
+
+    NONE = 0
+    READ = 1
+    WRITE = 2
+    EXECUTE = 4
+    ALL = READ | WRITE | EXECUTE
+
+
+class StandardEnum(enum.Enum):
+    """Standard enum for testing."""
+
+    OPTION_A = 1
+    OPTION_B = 2
+
+
+class TestStrEnumAutoWrapping:
+    """Test that StrEnum instances are automatically wrapped."""
+
+    def test_strenum_auto_wraps_to_config_strenum(self, tmp_path: Path) -> None:
+        """Test that Config(StrEnum.value) auto-wraps to Config(ConfigStrEnum(StrEnum.value))."""
+        config_file = tmp_path / "config.ini"
+        config_file.write_text("")
+
+        class StrEnumConfig(ConfigBase):
+            pass
+
+        StrEnumConfig.set_parser(IniParser())
+        StrEnumConfig.set_file(config_file)
+        StrEnumConfig._has_read_config = False
+
+        class AppConfig:
+            log_level = StrEnumConfig(LogLevel.INFO)
+
+        descriptor = AppConfig.__dict__["log_level"]
+        assert isinstance(descriptor._data_type, ConfigStrEnum)
+        assert descriptor._data_type.value == LogLevel.INFO
+
+
+class TestIntEnumAutoWrapping:
+    """Test that IntEnum instances are automatically wrapped."""
+
+    def test_intenum_auto_wraps_to_config_intenum(self, tmp_path: Path) -> None:
+        """Test that Config(IntEnum.value) auto-wraps to Config(ConfigIntEnum(IntEnum.value))."""
+        config_file = tmp_path / "config.ini"
+        config_file.write_text("")
+
+        class IntEnumConfig(ConfigBase):
+            pass
+
+        IntEnumConfig.set_parser(IniParser())
+        IntEnumConfig.set_file(config_file)
+        IntEnumConfig._has_read_config = False
+
+        class AppConfig:
+            priority = IntEnumConfig(Priority.MEDIUM)
+
+        descriptor = AppConfig.__dict__["priority"]
+        assert isinstance(descriptor._data_type, ConfigIntEnum)
+        assert descriptor._data_type.value == Priority.MEDIUM
+
+
+class TestIntFlagAutoWrapping:
+    """Test that IntFlag instances are automatically wrapped."""
+
+    def test_intflag_auto_wraps_to_config_intflag(self, tmp_path: Path) -> None:
+        """Test that Config(IntFlag.value) auto-wraps to Config(ConfigIntFlag(IntFlag.value))."""
+        config_file = tmp_path / "config.ini"
+        config_file.write_text("")
+
+        class IntFlagConfig(ConfigBase):
+            pass
+
+        IntFlagConfig.set_parser(IniParser())
+        IntFlagConfig.set_file(config_file)
+        IntFlagConfig._has_read_config = False
+
+        class AppConfig:
+            perms = IntFlagConfig(Permission.READ)
+
+        descriptor = AppConfig.__dict__["perms"]
+        assert isinstance(descriptor._data_type, ConfigIntFlag)
+        assert descriptor._data_type.value == Permission.READ
+
+
+class TestStandardEnumAutoWrapping:
+    """Test that standard Enum instances are automatically wrapped."""
+
+    def test_standard_enum_auto_wraps_to_config_enum(self, tmp_path: Path) -> None:
+        """Test that Config(Enum.value) auto-wraps to Config(ConfigEnum(Enum.value))."""
+        config_file = tmp_path / "config.ini"
+        config_file.write_text("")
+
+        class EnumConfig(ConfigBase):
+            pass
+
+        EnumConfig.set_parser(IniParser())
+        EnumConfig.set_file(config_file)
+        EnumConfig._has_read_config = False
+
+        class AppConfig:
+            option = EnumConfig(StandardEnum.OPTION_A)
+
+        descriptor = AppConfig.__dict__["option"]
+        assert isinstance(descriptor._data_type, ConfigEnum)
+        assert descriptor._data_type.value == StandardEnum.OPTION_A

{confkit-1.3.0 → confkit-2.0.0}/tests/test_list_type.py

@@ -1,4 +1,5 @@
 """Test the List data type."""
+from __future__ import annotations
 
 import pytest
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_metaclass.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 
 from confkit.config import Config as OG

{confkit-1.3.0 → confkit-2.0.0}/tests/test_msgspec.py

@@ -1,5 +1,7 @@
 
 """Tests for MsgspecParser (unified YAML/JSON/TOML parser)."""
+from __future__ import annotations
+
 import pathlib
 import tempfile
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_msgspecparser_branches.py

@@ -1,4 +1,6 @@
 """Tests for MsgspecParser.get fallback and string branch in write."""
+from __future__ import annotations
+
 import io
 
 from confkit.ext.parsers import MsgspecParser

{confkit-1.3.0 → confkit-2.0.0}/tests/test_msgspecparser_no_msgspec.py

@@ -1,4 +1,6 @@
 """Test MsgspecParser behavior when msgspec is not installed."""
+from __future__ import annotations
+
 import re
 import sys
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_msgspecparser_read.py

@@ -1,11 +1,16 @@
 """Tests for MsgspecParser.read edge cases."""
-from pathlib import Path
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import msgspec
 import pytest
 
 from confkit.ext.parsers import MsgspecParser
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 def test_read_file_does_not_exist(tmp_path: Path) -> None:
     file = tmp_path / "notfound.json"

{confkit-1.3.0 → confkit-2.0.0}/tests/test_msgspecparser_sections.py

@@ -1,4 +1,6 @@
 """Tests for MsgspecParser section/option methods."""
+from __future__ import annotations
+
 from confkit.ext.parsers import MsgspecParser
 
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_multiple_configurations.py

@@ -1,4 +1,6 @@
 """Tests for multiple configurations."""
+from __future__ import annotations
+
 from pathlib import Path
 
 import hypothesis

{confkit-1.3.0 → confkit-2.0.0}/tests/test_on_file_change.py

@@ -1,4 +1,6 @@
 """Tests for on_file_change method in Config descriptor."""
+from __future__ import annotations
+
 from pathlib import Path
 from typing import Any, ClassVar
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_sentinel.py

@@ -1,4 +1,5 @@
 """Test cases for the UNSET sentinel from confkit.sentinels."""
+from __future__ import annotations
 
 from confkit.sentinels import UNSET
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_two_instances.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 from tempfile import TemporaryDirectory
 

{confkit-1.3.0 → confkit-2.0.0}/tests/test_unreachable_paths.py

@@ -1,4 +1,5 @@
 """Test suite for testing supposedly unreachable code paths in data_types.py."""
+from __future__ import annotations
 
 import pytest
 from hypothesis import given
@@ -10,7 +11,7 @@ from confkit.data_types import BaseDataType
 class DataType(BaseDataType[str]):
     """Basic DataType that doesn't do anything."""
 
-    def convert(self, value: str) -> str: ... # ty: ignore[invalid-return-type].  # noqa: D102
+    def convert(self, value: str) -> str: ... # noqa: D102
 
 class MockBase:
     """Mock base class without __args__."""