chore(system, core): fixes linting/formatting issues

Signed-off-by: Roel <75250264+RoelBollens-TomTom@users.noreply.github.com>

Author: RoelBollens-TomTom

packages/overture-schema-cli/src/overture/schema/cli/commands.py

@@ -228,7 +228,7 @@ def resolve_types(
     elif theme_names and not type_names:
         # Theme-only mode: all types in specified themes
         for key, model_class in all_models.items():
-            if next(iter(tags_by_key(key.tags, "overture:theme")),None) in theme_names:
+            if next(iter(tags_by_key(key.tags, "overture:theme")), None) in theme_names:
                 filtered_models[key] = model_class
 
     elif type_names and not theme_names:
@@ -240,7 +240,11 @@ def resolve_types(
     elif type_names and theme_names:
         # Both specified: find matching types within specified themes
         for key, model_class in all_models.items():
-            if key.name in type_names and next(iter(tags_by_key(key.tags, "overture:theme")),None) in theme_names:
+            if (
+                key.name in type_names
+                and next(iter(tags_by_key(key.tags, "overture:theme")), None)
+                in theme_names
+            ):
                 filtered_models[key] = model_class
 
     else:
@@ -789,9 +793,7 @@ def json_schema_command(
     help="Group types by tag prefix (e.g., 'overture:theme')",
 )
 def list_types(
-    tags: tuple[str, ...],
-    excluded_tags: tuple[str, ...],
-    group_by: str | None
+    tags: tuple[str, ...], excluded_tags: tuple[str, ...], group_by: str | None
 ) -> None:
     r"""List all available types grouped by theme with descriptions.
 
@@ -810,7 +812,9 @@ def list_types(
         if tags:
             filters.append(lambda key: all(tag in key.tags for tag in tags))
         if excluded_tags:
-            filters.append(lambda key: not any(tag in key.tags for tag in excluded_tags))
+            filters.append(
+                lambda key: not any(tag in key.tags for tag in excluded_tags)
+            )
 
         if filters:
             models = {
@@ -822,15 +826,23 @@ def list_types(
         if group_by:
             grouped_models: dict[str, set[ModelKey]] = {}
 
-            for key, model_class in models.items():
+            for key in models.keys():
                 if groups := tags_by_key(key.tags, group_by):
                     for group in groups:
                         grouped_models.setdefault(group, set()).add(key)
 
-            padding = max((len(key.name) for keys in grouped_models.values() for key in keys), default=0) + 2
+            padding = (
+                max(
+                    (len(key.name) for keys in grouped_models.values() for key in keys),
+                    default=0,
+                )
+                + 2
+            )
 
             for group, keys in sorted(grouped_models.items()):
-                stdout.print(f"[green bold]{group_by}={group} ({len(keys)})[/green bold]")
+                stdout.print(
+                    f"[green bold]{group_by}={group} ({len(keys)})[/green bold]"
+                )
                 for key in sorted(keys, key=lambda k: k.name):
                     model = Text()
                     model.append("→ ", style="bright_black")
@@ -850,7 +862,6 @@ def list_types(
                 model.append_text(Text().append("  ".join(sorted(key.tags))))
                 stdout.print(model)
 
-
     except Exception as e:
         click.echo(f"Error listing types: {e}", err=True)
 

packages/overture-schema-cli/tests/test_resolve_types.py

@@ -128,7 +128,10 @@ def test_resolve_types_returns_expected_themes(
         from overture.schema.system.discovery import discover_models
 
         models = discover_models()
-        actual_themes = {next(iter(tags_by_key(key.tags, "overture:theme")),None) for key in models.keys()}
+        actual_themes = {
+            next(iter(tags_by_key(key.tags, "overture:theme")), None)
+            for key in models.keys()
+        }
 
         # Check that we have at least the expected themes (may have more)
         assert expected_themes.issubset(actual_themes), (

packages/overture-schema-codegen/src/overture/schema/codegen/cli.py

@@ -49,7 +49,7 @@ def _write_output(
 
 def _find_theme(tags: frozenset[str]) -> str | None:
     """Find the theme tag in a set of tags, if any."""
-    return next(iter(tags_by_key(tags, "overture:theme")),None)
+    return next(iter(tags_by_key(tags, "overture:theme")), None)
 
 
 @click.group()

packages/overture-schema-codegen/tests/codegen_test_support.py

@@ -303,7 +303,7 @@ def find_member(spec: EnumSpec, name: str) -> EnumMemberSpec:
 
 def find_theme(tags: frozenset[str]) -> str | None:
     """Extract the theme from a set of tags, if present."""
-    return next(iter(tags_by_key(tags, "overture:theme")),None)
+    return next(iter(tags_by_key(tags, "overture:theme")), None)
 
 
 T = TypeVar("T")

packages/overture-schema-core/src/overture/schema/core/tag_providers.py

@@ -1,8 +1,8 @@
-from typing import Any, get_origin, Annotated, get_args, Union, Literal
+from typing import Annotated, Any, Literal, Union, get_args, get_origin
 
-from overture.schema.core import OvertureFeature
 from pydantic import BaseModel
 
+from overture.schema.core import OvertureFeature
 from overture.schema.system.discovery import ModelKey
 
 APPROVED = {
@@ -36,7 +36,7 @@ def authority_provider(
 def theme_provider(
     model_class: type[BaseModel], key: ModelKey, tags: set[str]
 ) -> set[str]:
-    for tp in _reduce_types(model_class):
+    for tp in _extract_types(model_class):
         if issubclass(tp, OvertureFeature):
             tags.add(
                 "overture:theme=" + get_args(tp.model_fields["theme"].annotation)[0]
@@ -48,10 +48,10 @@ def _matches_manifest(key: ModelKey) -> bool:
     return key.entry_point in APPROVED
 
 
-def _reduce_types(tp: Any) -> set[type]:
+def _extract_types(tp: Any) -> set[type]:  # noqa: ANN401
     result: set[type] = set()
 
-    def visit(t: Any) -> None:
+    def visit(t: Any) -> None:  # noqa: ANN401
         origin = get_origin(t)
         if origin is Annotated:
             visit(get_args(t)[0])

packages/overture-schema-core/tests/test_approved_models.py

@@ -1,11 +1,10 @@
-import pytest
 from overture.schema.system.discovery import discover_models
 
 
 def test_overture_feature_models_are_official() -> None:
     models = discover_models()
     for key in models:
         if "overture:feature" in key.tags:
-            assert (
-                "overture:official" in key.tags
-            ), f"Model {key.name} is missing 'overture:official' tag."
+            assert "overture:official" in key.tags, (
+                f"Model {key.name} is missing 'overture:official' tag."
+            )

packages/overture-schema-system/src/overture/schema/system/discovery.py

@@ -3,8 +3,9 @@
 import importlib.metadata
 import logging
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, replace
-from typing import get_args, Literal, Union, get_origin, Annotated, Any, Callable
+from typing import Annotated, Any, Literal, Union, get_args, get_origin
 
 from pydantic import BaseModel
 
@@ -38,7 +39,7 @@ class ModelKey:
     """
 
     name: str  # friendly name from entry point key
-    entry_point : str # The entry point value in "module:Class" format
+    entry_point: str  # The entry point value in "module:Class" format
     tags: frozenset[str]  # plain and structured tags
 
 
@@ -85,16 +86,10 @@ def generate_tags(
 
 def _filter_tags(tags: set[str], provider: TagProviderKey) -> set[str]:
     reserved_tags = tuple(
-        tag
-        for tag, dist in RESERVED_TAGS.items()
-        if provider.package_name not in dist
+        tag for tag, dist in RESERVED_TAGS.items() if provider.package_name not in dist
     )
 
-    return {
-        tag
-        for tag in tags
-        if TAG_RE.match(tag) and not tag in reserved_tags
-    }
+    return {tag for tag in tags if TAG_RE.match(tag) and tag not in reserved_tags}
 
 
 def discover_tag_providers(
@@ -104,7 +99,6 @@ def discover_tag_providers(
 
     try:
         for tag_provider in importlib.metadata.entry_points(group=tag_providers_group):
-
             try:
                 tag_provider_class = tag_provider.load()
 
@@ -148,7 +142,6 @@ def discover_models(
 
     try:
         for model in importlib.metadata.entry_points(group=model_group):
-
             try:
                 model_class = model.load()
 
@@ -233,10 +226,10 @@ def feature_provider(
     return tags
 
 
-def _extract_types(tp: Any) -> set[type]:
+def _extract_types(tp: Any) -> set[type]:  # noqa: ANN401
     result: set[type] = set()
 
-    def visit(t: Any) -> None:
+    def visit(t: Any) -> None:  # noqa: ANN401
         origin = get_origin(t)
         if origin is Annotated:
             visit(get_args(t)[0])

packages/overture-schema-system/tests/test_tags.py

@@ -1,35 +1,41 @@
 from overture.schema.system.discovery import tags_by_key, tags_by_namespace
 
+
 def test_tags_by_key_returns_correct_values() -> None:
     tags = frozenset({"overture:theme=buildings", "overture", "draft"})
     key = "overture:theme"
     result = tags_by_key(tags, key)
     assert result == {"buildings"}
 
+
 def test_tags_by_key_returns_empty_set_for_nonexistent_key() -> None:
     tags = frozenset({"overture:theme=buildings", "overture", "draft"})
     key = "nonexistent:key"
     result = tags_by_key(tags, key)
     assert result == set()
 
+
 def test_tags_by_key_handles_empty_tags() -> None:
     tags: frozenset[str] = frozenset()
     key = "overture:theme"
     result = tags_by_key(tags, key)
     assert result == set()
 
+
 def test_tags_by_namespace_returns_correct_values() -> None:
     tags = frozenset({"system:extension", "overture"})
     namespace = "system"
     result = tags_by_namespace(tags, namespace)
     assert result == {"extension"}
 
+
 def test_tags_by_namespace_returns_empty_set_for_nonexistent_namespace() -> None:
     tags = frozenset({"system:extension", "overture"})
     namespace = "nonexistent"
     result = tags_by_namespace(tags, namespace)
     assert result == set()
 
+
 def test_tags_by_namespace_handles_empty_tags() -> None:
     tags: frozenset[str] = frozenset()
     namespace = "system"