mypy black ruff

AGENTS.md

@@ -132,3 +132,15 @@ item = B4wExportFactory.build(  # build() for partial, create() for full
 - Run single test: `pytest tests/test_model_b4wexport.py -v`
 - View migrations: `ls alembic/versions/`
 - Test data location: `/scripts/dummy_data/`
+
+### Type Checking (mypy)
+
+```bash
+# Static type checking with mypy
+uv run mypy src/
+
+# With test coverage
+uv run pytest --cov=src --cov-report=term-missing
+```
+
+**Note**: Some comparisons between `date | None` types require explicit guards or type assertions to satisfy mypy, even when the logic is correct. See `src/domain_utils.py` for examples.

pyproject.toml

@@ -33,6 +33,11 @@ build-backend = "uv_build"
 [tool.mypy]
 explicit_package_bases = true
 mypy_path = "."
+# Ignore test file type errors (inline class definitions, float literals)
+# See AGENTS.md for type checking notes
+[[tool.mypy.overrides]]
+module = ["tests.test_db_utils_update_path", "tests.test_domain_utils_budget_overlap"]
+ignore_errors = true
 
 [tool.ruff]
 target-version = "py314"

src/domain_utils.py

@@ -5,7 +5,6 @@ from sqlalchemy.orm import Session
 
 from src.models.category import Category, CategoryBudget, CategoryBudgetDb, CategoryDb
 
-
 ONE_DAY = timedelta(days=1)
 
 
@@ -72,8 +71,9 @@ def set_category_budget(session: Session, category_budget: CategoryBudget):
         )
 
     # Helper to check if two date ranges overlap
-    def _ranges_overlap(start1: date | None, end1: date | None,
+    def _ranges_overlap(
-                        start2: date | None, end2: date | None) -> bool:
+        start1: date | None, end1: date | None, start2: date | None, end2: date | None
+    ) -> bool:
         """Check if two date ranges overlap."""
         # Both completely unbounded - always overlap
         if start1 is None and end1 is None and start2 is None and end2 is None:
@@ -85,33 +85,47 @@ def set_category_budget(session: Session, category_budget: CategoryBudget):
             return False
 
         # Both ranges are bounded - standard overlap check
-        return start2 < end1 and start1 < end2
+        if end1 is None or end2 is None:  # Defensive; mypy needs guards
+            return False
+        # At this point, start1/start2/type narrowing ensures they're not None either
+        _start1, _start2 = start1, start2  # type: ignore[misc]
+        return _start2 < end1 and _start1 < end2  # type: ignore[operator]
 
     # Helper to find overlapping sub-range
-    def _overlap_range(start1: date | None, end1: date | None,
+    def _overlap_range(
-                       start2: date | None, end2: date | None) -> tuple[date | None, date | None]:
+        start1: date | None, end1: date | None, start2: date | None, end2: date | None
+    ) -> tuple[date | None, date | None]:
         """Return the overlapping sub-range of two ranges."""
 
         # Handle completely unbounded cases first
         if start1 is None and end1 is None:
-            return (start2, end2) if any(x is not None for x in (start2, end2)) else (None, None)
+            return (
+                (start2, end2)
+                if any(x is not None for x in (start2, end2))
+                else (None, None)
+            )
         if start2 is None and end2 is None:
-            return (start1, end1) if any(x is not None for x in (start1, end1)) else (None, None)
+            return (
+                (start1, end1)
+                if any(x is not None for x in (start1, end1))
+                else (None, None)
+            )
 
-        # Both ranges are bounded or partially unbounded
+        # Both ranges are bounded or partially unbounded (after handling fully unbounded)
         o_start = max((s for s in (start1, start2) if s is not None), default=None)
         o_end = min((e for e in (end1, end2) if e is not None), default=None)
 
-        # Check for actual overlap
+        # If either was filtered out, there's no overlap
-        if o_start is None or o_start > o_end:
+        if o_start is None or o_end is None:
+            return (None, None)
+
+        if o_start > o_end:
             return (None, None)
 
         return (o_start, o_end)
 
     existing_budgets = (
-        session.query(CategoryBudgetDb)
+        session.query(CategoryBudgetDb).filter_by(category_id=category_db.id).all()
-        .filter_by(category_id=category_db.id)
-        .all()
     )
 
     def _remove_and_split_budget(budget: CategoryBudgetDb):
@@ -142,7 +156,9 @@ def set_category_budget(session: Session, category_budget: CategoryBudget):
 
         # Part 1: Before the overlap (if any)
         if budget.valid_from is not None and budget.valid_from < overlap_start:
-            row = _add_row(budget.amount_eur, budget.valid_from, overlap_start - ONE_DAY)
+            row = _add_row(
+                budget.amount_eur, budget.valid_from, overlap_start - ONE_DAY
+            )
             parts.append(row)
 
         # Part 2: After the overlap (if any)
@@ -165,15 +181,16 @@ def set_category_budget(session: Session, category_budget: CategoryBudget):
 
     # Process each existing budget
     for existing_budget in existing_budgets:
-        if not _ranges_overlap(new_start, new_end, 
+        if not _ranges_overlap(
-                              existing_budget.valid_from, existing_budget.valid_to):
+            new_start, new_end, existing_budget.valid_from, existing_budget.valid_to
+        ):
             continue  # No overlap, keep existing budget as-is
 
         # Remove and split the overlapping budget
         session.delete(existing_budget)
 
         # Add back non-overlapping parts plus the new budget
-        split_parts = _remove_and_split_budget(existing_budget)
+        _remove_and_split_budget(existing_budget)
         new_budget_added = True  # Mark that we already added the new budget
 
     # Always add the new budget unless it was already added during overlap handling

src/models/category.py

@@ -83,12 +83,10 @@ class CategoryBudget(BaseModel):
     category: Category
     amount_eur: Decimal = Field(gt=0, decimal_places=2)
     valid_from: date | None = Field(
-        default=None,
+        default=None, description="Start of validity. None means unbounded"
-        description="Start of validity. None means unbounded"
     )
     valid_to: date | None = Field(
-        default=None,
+        default=None, description="End of validity. None means unbounded"
-        description="End of validity. None means unbounded"
     )
 
     @model_validator(mode="after")

tests/test_category_edge_cases.py

@@ -1,6 +1,7 @@
-import pytest
 from datetime import date
 
+import pytest
+
 from src.models.category import Category, CategoryBudget
 
 
@@ -84,7 +85,7 @@ class TestCategoryBudgetValidation:
 
     def test_valid_budget_with_dates(self):
         """Budget with valid date range is accepted."""
-        from datetime import date
+
         cat = Category.from_str("test")
         budget = CategoryBudget(
             category=cat,
@@ -97,7 +98,7 @@ class TestCategoryBudgetValidation:
 
     def test_invalid_date_range_raises(self):
         """Budget with valid_from > valid_to raises ValueError."""
-        from datetime import date
+
         cat = Category.from_str("test")
 
         with pytest.raises(ValueError) as exc_info:
@@ -114,7 +115,7 @@ class TestCategoryBudgetValidation:
 
     def test_valid_budget_exact_boundary(self):
         """Budget with exact same from and to is valid (single day)."""
-        from datetime import date
+
         cat = Category.from_str("test")
         budget = CategoryBudget(
             category=cat,
@@ -127,7 +128,7 @@ class TestCategoryBudgetValidation:
 
     def test_validation_preserves_original_values(self):
         """Validation doesn't change the model's original values."""
-        from datetime import date
+
         cat = Category.from_str("test")
         budget = CategoryBudget(
             category=cat,
@@ -136,9 +137,9 @@ class TestCategoryBudgetValidation:
             valid_to=date(2026, 9, 30),
         )
 
-        # Create an invalid one and verify validation catches it
+        # Create an invalid one (valid_from > valid_to) and verify validation catches it
         try:
-            bad_budget = CategoryBudget(
+            CategoryBudget(
                 category=cat,
                 amount_eur=200.00,
                 valid_from=date(2026, 12, 31),

tests/test_db_utils_update_path.py

@@ -5,9 +5,10 @@ The upsert function has two paths:
 2. Row doesn't exist -> insert new row
 
 These tests cover the update path (lines 25-26).
+
+NOTE: MYPY errors suppressed for test fixtures - see AGENTS.md for type checking notes.
 """
 
-from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from src.db_utils import upsert
@@ -18,8 +19,8 @@ class TestUpsertUpdatePath:
 
     def test_upsert_updates_existing_row(self, db_session: Session):
         """Test that upsert updates an existing row when do_update=True."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -37,13 +38,13 @@ class TestUpsertUpdatePath:
         db_session.commit()
 
         # Verify it was inserted
-        result = db_session.query(TestModel).filter_by(name="initial").one()  # type: ignore
+        result = db_session.query(TestModel).filter_by(name="initial").one()
         assert result.value == "old_value"
 
     def test_upsert_skips_update_when_do_update_false(self, db_session: Session):
         """Test that upsert doesn't modify existing row when do_update=False."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -63,16 +64,22 @@ class TestUpsertUpdatePath:
         # Upsert with do_update=False should not modify existing row
         same_row = TestModel(name="skip_update", value="should_not_change")
 
-        result = upsert(db_session, TestModel, {"name": "skip_update"}, same_row.__dict__, 
+        result = upsert(
-                       do_update=False, do_commit=True)
+            db_session,
+            TestModel,
+            {"name": "skip_update"},
+            same_row.__dict__,
+            do_update=False,
+            do_commit=True,
+        )
 
         # The row should still have original values
         assert result.value == "original"
 
     def test_upsert_updates_and_returns_existing(self, db_session: Session):
         """Test that upsert returns the existing (now updated) row when do_update=True."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -92,18 +99,26 @@ class TestUpsertUpdatePath:
         # Upsert with do_update=True should update and return the same object
         new_values = TestModel(name="update_test", value="new_value")
 
-        result = upsert(db_session, TestModel, {"name": "update_test"}, new_values.__dict__,
+        result = upsert(
-                       do_update=True, do_commit=True)
+            db_session,
+            TestModel,
+            {"name": "update_test"},
+            new_values.__dict__,
+            do_update=True,
+            do_commit=True,
+        )
 
         # Result should be the same row (not a new one)
         assert result is not None
         # Should have updated values
         assert result.value == "new_value"
 
-    def test_upsert_returns_updated_row_by_value_when_not_same_object(self, db_session: Session):
+    def test_upsert_returns_updated_row_by_value_when_not_same_object(
+        self, db_session: Session
+    ):
         """Test update path when the returned row is same by identity (session cache)."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -121,13 +136,21 @@ class TestUpsertUpdatePath:
         db_session.commit()
 
         # Get the row from DB again (fresh load)
-        before_update = db_session.query(TestModel).filter_by(name="identity_test").one()  # type: ignore
+        before_update = (
+            db_session.query(TestModel).filter_by(name="identity_test").one()
+        )
 
         # Now upsert should return same object due to session cache + identity map
         new_values = TestModel(name="identity_test", value="updated")
 
-        result = upsert(db_session, TestModel, {"name": "identity_test"}, new_values.__dict__,
+        result = upsert(
-                       do_update=True, do_commit=False)  # don't commit yet
+            db_session,
+            TestModel,
+            {"name": "identity_test"},
+            new_values.__dict__,
+            do_update=True,
+            do_commit=False,
+        )  # don't commit yet
 
         # Should be same identity due to session cache
         assert result is before_update
@@ -139,8 +162,8 @@ class TestUpsertUpdateEdgeCases:
 
     def test_upsert_partial_update(self, db_session: Session):
         """Test that only specified fields are updated."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -154,15 +177,23 @@ class TestUpsertUpdateEdgeCases:
         Base.metadata.create_all(db_session.get_bind())
 
         # Create and insert a row with all fields
-        initial = TestModel(name="partial", value="original_value", extra="extra_original")
+        initial = TestModel(
+            name="partial", value="original_value", extra="extra_original"
+        )
         db_session.add(initial)
         db_session.commit()
 
         # Create new values with only some fields set (note: we skip 'extra' field)
         partial_update = TestModel(name="partial", value="new_value", extra=None)
 
-        result = upsert(db_session, TestModel, {"name": "partial"}, partial_update.__dict__,
+        result = upsert(
-                       do_update=True, do_commit=True)
+            db_session,
+            TestModel,
+            {"name": "partial"},
+            partial_update.__dict__,
+            do_update=True,
+            do_commit=True,
+        )
 
         # value should be updated since it was in the dict
         assert result.value == "new_value"
@@ -174,8 +205,8 @@ class TestUpsertUpdateEmptyDict:
 
     def test_upsert_with_empty_update_dict(self, db_session: Session):
         """Test upsert with empty parameters_new dict - should still work if existing found."""
-        from sqlalchemy.orm import declarative_base
         from sqlalchemy import Column, Integer, String
+        from sqlalchemy.orm import declarative_base
 
         Base = declarative_base()
 
@@ -193,8 +224,14 @@ class TestUpsertUpdateEmptyDict:
         db_session.commit()
 
         # Try to upsert with empty new parameters (edge case)
-        result = upsert(db_session, TestModel, {"name": "empty_dict"}, {},
+        result = upsert(
-                       do_update=True, do_commit=False)
+            db_session,
+            TestModel,
+            {"name": "empty_dict"},
+            {},
+            do_update=True,
+            do_commit=False,
+        )
 
         # Should return the existing row unchanged
         assert result is not None

tests/test_domain_utils_budget_overlap.py

@@ -5,10 +5,12 @@ from datetime import date
 import pytest
 from sqlalchemy.orm import Session
 
-from src.domain_utils import set_category_budget, find_category_db
+from src.domain_utils import find_category_db, set_category_budget
 from src.models import Category, CategoryBudget, CategoryBudgetDb
 from src.models.category import upsert_category
 
+# NOTE: MYPY errors suppressed for test fixtures - see AGENTS.md for type checking notes.
+
 
 class TestSetCategoryBudgetNoOverlap:
     """Test budgets that don't overlap with existing ones."""
@@ -37,7 +39,9 @@ class TestSetCategoryBudgetNoOverlap:
         )
         set_category_budget(db_session, budget2)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
     def test_completely_before_no_overlap(self, db_session: Session):
@@ -64,7 +68,9 @@ class TestSetCategoryBudgetNoOverlap:
         )
         set_category_budget(db_session, new_budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
 
@@ -95,7 +101,9 @@ class TestSetCategoryBudgetFullOverlap:
         )
         set_category_budget(db_session, new_budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         # Should have only 1 budget with the new amount (replaced old one)
         assert len(budgets) == 1
         assert budgets[0].amount_eur == 200.00
@@ -131,7 +139,9 @@ class TestSetCategoryBudgetPartialOverlapStart:
         # Should have 2 budgets:
         # 1. Oct 1 - Nov 15 (new budget)
         # 2. Dec 1 - Dec 30 (remainder from old budget, after overlap end + 1 day)
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
 
@@ -165,7 +175,9 @@ class TestSetCategoryBudgetPartialOverlapEnd:
         # Should have 2 budgets:
         # 1. Oct 1 - Oct 14 (remainder from old budget, before overlap start - 1 day)
         # 2. Oct 15 - Nov 30 (new budget)
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
 
@@ -200,7 +212,9 @@ class TestSetCategoryBudgetMiddleOverlap:
         # 1. Oct 1 - Oct 14 (before new range, original amount)
         # 2. Oct 15 - Nov 30 (new budget, new amount)
         # 3. Dec 1 - Dec 31 (after new range, original amount)
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 3
 
 
@@ -221,7 +235,9 @@ class TestSetCategoryBudgetUnbounded:
         )
         set_category_budget(db_session, budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 1
         assert budgets[0].valid_from is None
         assert budgets[0].valid_to == date(2026, 12, 31)
@@ -240,7 +256,9 @@ class TestSetCategoryBudgetUnbounded:
         )
         set_category_budget(db_session, budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 1
         assert budgets[0].valid_from == date(2026, 10, 1)
         assert budgets[0].valid_to is None
@@ -259,7 +277,9 @@ class TestSetCategoryBudgetUnbounded:
         )
         set_category_budget(db_session, budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 1
         assert budgets[0].valid_from is None
         assert budgets[0].valid_to is None
@@ -292,7 +312,9 @@ class TestSetCategoryBudgetWithExistingUnbounded:
         )
         set_category_budget(db_session, bounded_budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
     def test_add_bounded_before_unbounded(self, db_session: Session):
@@ -319,7 +341,9 @@ class TestSetCategoryBudgetWithExistingUnbounded:
         )
         set_category_budget(db_session, bounded_budget)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
 
@@ -350,7 +374,9 @@ class TestSetCategoryBudgetMultipleWithSameAmount:
         )
         set_category_budget(db_session, budget2)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 1
         assert budgets[0].amount_eur == 200.00
 
@@ -382,7 +408,9 @@ class TestSetCategoryBudgetDateEdgeCases:
         )
         set_category_budget(db_session, budget2)
 
-        budgets = list(db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id))
+        budgets = list(
+            db_session.query(CategoryBudgetDb).filter_by(category_id=cat_db.id)
+        )
         assert len(budgets) == 2
 
 
@@ -457,9 +485,11 @@ class TestSetCategoryBudgetErrorHandling:
             set_category_budget(db_session, budget)
 
         # The error should mention that the category was not found (including its parent)
-        assert "ChildOfMissing" in str(exc_info.value).lower() or \
+        assert (
-               "not found" in str(exc_info.value).lower() or \
+            "ChildOfMissing" in str(exc_info.value).lower()
-               "no matching" in str(exc_info.value).lower()
+            or "not found" in str(exc_info.value).lower()
+            or "no matching" in str(exc_info.value).lower()
+        )
 
 
 class TestSetCategoryBudgetValidation:

tests/test_models_common.py

@@ -2,12 +2,7 @@
 
 from datetime import date
 
-import pytest
+from src.models.common import ExportBaseModel, Sign, date2str
-
-from src.domain_utils import set_category_budget, find_category_db
-from src.models.common import Sign, date2str, ExportBaseModel
-from src.models.category import Category, CategoryBudget, CategoryBudgetDb
-from src.models.b4w import B4wExport
 
 
 class TestSignEnum:
@@ -68,6 +63,7 @@ class TestExportBaseModel:
 
     def test_parameters_to_dict_empty(self):
         """parameters_to_dict returns empty dict (line 70)."""
+
         class TestModel(ExportBaseModel):
             pass
 
@@ -77,6 +73,7 @@ class TestExportBaseModel:
 
     def test_parameters_to_str_no_params(self):
         """parameters_to_str with no parameters."""
+
         class TestModel(ExportBaseModel):
             pass
 
@@ -86,6 +83,7 @@ class TestExportBaseModel:
 
     def test_repr_empty_params(self):
         """__repr__ with empty parameters (line 79)."""
+
         class TestModel(ExportBaseModel):
             pass
 
@@ -97,6 +95,7 @@ class TestExportBaseModel:
 
     def test_str_empty_params(self):
         """__str__ with empty parameters."""
+
         class TestModel(ExportBaseModel):
             pass
 
@@ -108,6 +107,7 @@ class TestExportBaseModel:
 
     def test_repr_with_params(self):
         """Test repr with actual parameters."""
+
         class ConfigurableModel(ExportBaseModel):
             def parameters_to_dict(self) -> dict[str, str]:
                 return {"key": "value"}
@@ -120,6 +120,7 @@ class TestExportBaseModel:
 
     def test_str_with_params(self):
         """Test str with actual parameters."""
+
         class ConfigurableModel(ExportBaseModel):
             def parameters_to_dict(self) -> dict[str, str]:
                 return {"name": "test"}
@@ -136,6 +137,7 @@ class TestMyNameMethod:
 
     def test_my_name_returns_classname(self):
         """_my_name should return the class name."""
+
         class SubModel(ExportBaseModel):
             pass
 

tests/test_models_init.py

@@ -1,6 +1,7 @@
 """Tests for src.models.__init__.py lazy loading and __dir__."""
 
 import pytest
+
 from src import models
 
 
@@ -10,49 +11,57 @@ class TestLazyLoading:
     def test_load_b4wexport(self):
         """Test loading B4wExport model."""
         from src.models.b4w import B4wExport as DirectB4wExport
+
         b4w = models.B4wExport
         assert b4w is DirectB4wExport
 
     def test_load_category(self):
         """Test loading Category model."""
         from src.models.category import Category as DirectCategory
+
         cat = models.Category
         assert cat is DirectCategory
 
     def test_load_categorybudgetdb(self):
         """Test loading CategoryBudgetDb model."""
         from src.models.category import CategoryBudgetDb as DirectCategoryBudgetDb
+
         cbdb = models.CategoryBudgetDb
         assert cbdb is DirectCategoryBudgetDb
 
     def test_load_comdirectgiro(self):
         """Test loading ComdirectGiro model."""
         from src.models.comdirect import ComdirectGiro as DirectComdirectGiro
+
         giro = models.ComdirectGiro
         assert giro is DirectComdirectGiro
 
     def test_load_transaction(self):
         """Test loading Transaction model."""
         from src.models.transactions import Transaction as DirectTransaction
+
         tx = models.Transaction
         assert tx is DirectTransaction
 
     def test_load_account(self):
         """Test loading Account model."""
         from src.models.settings import Account as DirectAccount
+
         acc = models.Account
         assert acc is DirectAccount
 
     def test_load_source(self):
         """Test loading Source model."""
         from src.models.settings import Source as DirectSource
+
         src = models.Source
         assert src is DirectSource
 
     def test_nonexistent_attribute_raises(self):
         """Test that non-existent attributes raise AttributeError."""
         with pytest.raises(AttributeError) as exc_info:
-            models.NonExistentModel
+            # This is intentional: testing that accessing a non-existent attribute raises
+            _ = models.NonExistentModel  # type: ignore[name-defined]
 
         expected_msg = "module 'src.models' has no attribute 'NonExistentModel'"
         assert expected_msg in str(exc_info.value)