modwire 9.2.1__tar.gz → 9.2.2__tar.gz

{modwire-9.2.1 → modwire-9.2.2}/.dev/modwire.egg-info/SOURCES.txt

@@ -120,10 +120,9 @@ src/modwire/cli/cache/models/cache_entry.py
 src/modwire/cli/cache/models/cache_key.py
 src/modwire/cli/cache/models/cache_options.py
 src/modwire/cli/cache/models/cache_outcome.py
+src/modwire/cli/cache/models/cache_stage.py
 src/modwire/cli/cache/models/cached_result.py
 src/modwire/cli/cache/models/extraction_snapshot.py
-src/modwire/cli/cache/models/source_entry.py
-src/modwire/cli/cache/models/source_inventory.py
 src/modwire/cli/cache/services/__init__.py
 src/modwire/cli/cache/services/cache_codec.py
 src/modwire/cli/cache/services/cache_identity.py
@@ -148,6 +147,8 @@ src/modwire/cli/pipeline/models/extractor_command_input.py
 src/modwire/cli/pipeline/models/extractor_source_input.py
 src/modwire/cli/pipeline/models/report_pipeline_context.py
 src/modwire/cli/pipeline/models/scan_policy.py
+src/modwire/cli/pipeline/models/source_entry.py
+src/modwire/cli/pipeline/models/source_inventory.py
 src/modwire/cli/pipeline/services/__init__.py
 src/modwire/cli/pipeline/services/batch_source_reader.py
 src/modwire/cli/pipeline/services/callables_insight.py

{modwire-9.2.1 → modwire-9.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 9.2.1
+Version: 9.2.2
 Summary: Code extraction, architecture analysis and the Modwire CLI.
 Author: Tomasz Szpak
 License-Expression: MIT

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/application.py

@@ -11,7 +11,8 @@ from .architecture.facade import ArchitectureFacade
 from .architecture.report.models.report_catalog import ReportCatalog
 from .architecture.report.models.report_node import ReportNode
 from .cli.cache.models.cache_options import CacheOptions
-from .cli.cache.models.cache_outcome import CacheOutcome, CacheStage
+from .cli.cache.models.cache_outcome import CacheOutcome
+from .cli.cache.models.cache_stage import CacheStage
 from .cli.cache.models.cached_result import CachedResult
 from .cli.facade import CliFacade
 from .cli.pipeline.models.scan_policy import ScanPolicy

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/cache/application.py

@@ -18,19 +18,14 @@ from ..pipeline.models.scan_policy import ScanPolicy
 from .domain import CacheStorage
 from .models.cache_key import CacheKey
 from .models.cache_options import CacheOptions
-from .models.cache_outcome import CacheOutcome, CacheStage
+from .models.cache_outcome import CacheOutcome
+from .models.cache_stage import CacheStage
 from .models.cached_result import CachedResult
 from .models.extraction_snapshot import ExtractionSnapshot
 from .services.cache_codec import CacheCodec
 from .services.cache_identity import CacheIdentity
 
 
-@dataclass(frozen=True)
-class _CacheRead:
-    value: object | None
-    invalidated: bool
-
-
 @injectable
 @dataclass(frozen=True)
 class CacheApplication:
@@ -57,17 +52,17 @@ class CacheApplication:
         invalidated = 0
         for entry in inventory.entries:
             key = keys[entry.source_id]
-            cached = self._read(options, key)
+            cached_value, cached_invalidated = self._read(options, key)
             try:
-                source_file = SourceFile.model_validate(cached.value)
+                source_file = SourceFile.model_validate(cached_value)
                 if source_file.file_id != entry.source_id:
                     raise ValueError("Cached source identity does not match its key.")
                 files[entry.source_id] = source_file
                 hits += 1
             except (TypeError, ValueError, ValidationError):
-                if cached.value is not None and not cached.invalidated:
+                if cached_value is not None and not cached_invalidated:
                     self.storage.delete(options, key)
-                invalidated += int(cached.invalidated or cached.value is not None)
+                invalidated += int(cached_invalidated or cached_value is not None)
                 misses.append(entry.source_id)
 
         if misses or not inventory.entries:
@@ -128,19 +123,19 @@ class CacheApplication:
 
     def code_map(self, snapshot: ExtractionSnapshot, options: CacheOptions) -> CachedResult[CodeMap | None]:
         key = self.identity.code_map("", snapshot.manifest)
-        cached = self._read(options, key)
+        cached_value, cached_invalidated = self._read(options, key)
         try:
-            value = CodeMap.model_validate(cached.value)
+            value = CodeMap.model_validate(cached_value)
             outcome = CacheOutcome(stage=CacheStage.CODE_MAP, namespace=options.namespace, hits=1)
         except (TypeError, ValueError, ValidationError):
-            if cached.value is not None and not cached.invalidated:
+            if cached_value is not None and not cached_invalidated:
                 self.storage.delete(options, key)
             value = None
             outcome = CacheOutcome(
                 stage=CacheStage.CODE_MAP,
                 namespace=options.namespace,
                 misses=1,
-                invalidated=int(cached.invalidated or cached.value is not None),
+                invalidated=int(cached_invalidated or cached_value is not None),
             )
         return CachedResult[CodeMap | None](value=value, outcomes=(outcome,))
 
@@ -152,9 +147,8 @@ class CacheApplication:
         self, code_map: CodeMap, config: ArchitectureConfig, options: CacheOptions
     ) -> CachedResult[tuple[ReportNode, ...] | None]:
         key = self.identity.reports(code_map, config)
-        cached = self._read(options, key)
-        cached_value: object | None = cached.value
-        invalidated = cached.invalidated or cached_value is not None
+        cached_value, cached_invalidated = self._read(options, key)
+        invalidated = cached_invalidated or cached_value is not None
         try:
             if not isinstance(cached_value, list):
                 raise ValueError("Cached reports must be a list.")
@@ -162,7 +156,7 @@ class CacheApplication:
             value = tuple(sorted(reports, key=lambda item: (item.metadata.order, item.metadata.id)))
             outcome = CacheOutcome(stage=CacheStage.REPORTS, namespace=options.namespace, hits=1)
         except (AttributeError, ImportError, KeyError, TypeError, ValueError, ValidationError):
-            if cached_value is not None and not cached.invalidated:
+            if cached_value is not None and not cached_invalidated:
                 self.storage.delete(options, key)
             value = None
             outcome = CacheOutcome(
@@ -202,15 +196,15 @@ class CacheApplication:
             self.storage.delete(options, entry.key)
             total -= entry.size
 
-    def _read(self, options: CacheOptions, key: CacheKey) -> _CacheRead:
+    def _read(self, options: CacheOptions, key: CacheKey) -> tuple[object | None, bool]:
         payload = self.storage.read(options, key)
         if payload is None:
-            return _CacheRead(value=None, invalidated=False)
+            return None, False
         value = self.codec.decode(key, payload)
         if value is None:
             self.storage.delete(options, key)
-            return _CacheRead(value=None, invalidated=True)
-        return _CacheRead(value=value, invalidated=False)
+            return None, True
+        return value, False
 
     def _write(self, options: CacheOptions, key: CacheKey, value: object) -> None:
         self.storage.write(options, key, self.codec.encode(key, value))

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/cache/models/cache_outcome.py

@@ -1,16 +1,7 @@
-from enum import StrEnum
-
 from pydantic import field_validator
 
 from ....shared.values.models.value_model import ValueModel
-
-
-class CacheStage(StrEnum):
-    """Public stages reported by cached Modwire operations."""
-
-    EXTRACTION = "extraction"
-    CODE_MAP = "code-map"
-    REPORTS = "reports"
+from .cache_stage import CacheStage
 
 
 class CacheOutcome(ValueModel):

modwire-9.2.2/src/modwire/cli/cache/models/cache_stage.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class CacheStage(StrEnum):
+    """Public stages reported by cached Modwire operations."""
+
+    EXTRACTION = "extraction"
+    CODE_MAP = "code-map"
+    REPORTS = "reports"

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/cache/models/cached_result.py

@@ -1,7 +1,8 @@
 from pydantic import field_validator
 
 from ....shared.values.models.value_model import ValueModel
-from .cache_outcome import CacheOutcome, CacheStage
+from .cache_outcome import CacheOutcome
+from .cache_stage import CacheStage
 
 
 class CachedResult[Result](ValueModel):

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/cache/services/cache_identity.py

@@ -11,8 +11,8 @@ from ....architecture.config.models.architecture_config import ArchitectureConfi
 from ....extraction.extractors.models.extraction_request import ExtractionRequest
 from ....shared.code.models.code_map import CodeMap
 from ...cache.models.cache_key import CacheKey, CacheKind
-from ...cache.models.source_entry import SourceEntry
 from ...pipeline.models.scan_policy import ScanPolicy
+from ...pipeline.models.source_entry import SourceEntry
 
 
 @injectable

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/pipeline/domain.py

@@ -5,9 +5,9 @@ from ...extraction.extractors.models.extractor_runtime import ExtractorRuntime
 from ...shared.code.models.identity import FileId
 from ...shared.code.models.source_extraction import SourceExtraction
 from ...shared.code.models.source_file import SourceFile
-from ..cache.models.source_inventory import SourceInventory
 from .models.report_pipeline_context import ReportPipelineContext
 from .models.scan_policy import ScanPolicy
+from .models.source_inventory import SourceInventory
 
 
 class ReportPipelineStep(ABC):

{modwire-9.2.1 → modwire-9.2.2}/src/modwire/cli/pipeline/services/batch_source_reader.py

@@ -20,10 +20,10 @@ from ....shared.code.models.duplicate_identity_error import DuplicateIdentityErr
 from ....shared.code.models.identity import FileId, ModuleId
 from ....shared.code.models.source_extraction import SourceExtraction
 from ....shared.code.models.source_file import SourceFile
-from ...cache.models.source_entry import SourceEntry
-from ...cache.models.source_inventory import SourceInventory
 from ..domain import SourceReader
 from ..models.scan_policy import ScanPolicy
+from ..models.source_entry import SourceEntry
+from ..models.source_inventory import SourceInventory
 
 
 @injectable(as_type=SourceReader)

{modwire-9.2.1 → modwire-9.2.2}/tests/architecture/base_test.py

@@ -10,4 +10,4 @@ class ArchitectureTestCase(ServiceTestCase):
         return {}
 
     def queryable_map(self, paths: tuple[str, ...], edges: tuple[tuple[str, str | None, str, str], ...]):
-        return CodeMapFactory.queryable({path: self.source_file(path) for path in paths}, edges)
+        return CodeMapFactory().queryable({path: self.source_file(path) for path in paths}, edges)

{modwire-9.2.1 → modwire-9.2.2}/tests/architecture/insights/base_test.py

@@ -6,7 +6,7 @@ class InsightTestCase(ArchitectureTestCase):
     def insight(
         self,
         files: dict[str, dict[str, object]],
-        edges: tuple[tuple[str, str | None, str, str], ...] = (),
+        edges: tuple[tuple[str, str | None, str, str], ...],
     ):
-        code_map = CodeMapFactory.queryable(files, edges)
+        code_map = CodeMapFactory().queryable(files, edges)
         return self.report("architecture.insights", self.example_configuration(), code_map)

{modwire-9.2.1 → modwire-9.2.2}/tests/architecture/insights/test_02_invariants.py

@@ -34,14 +34,22 @@ class TestInsightInvariants(InsightTestCase):
             {
                 "example_values.source": {
                     "exports": [
-                        CodeMapFactory.source_export("ExampleUsed"),
-                        CodeMapFactory.source_export("ExampleUnused"),
+                        CodeMapFactory().source_export("ExampleUsed"),
+                        CodeMapFactory().source_export("ExampleUnused"),
                     ]
                 },
                 "example_consumer.source": {
-                    "imports": [CodeMapFactory.source_import("example_values", imported_name="ExampleUsed")]
+                    "imports": [
+                        CodeMapFactory().source_import(
+                            "example_values",
+                            imported_name="ExampleUsed",
+                            is_aliased=False,
+                            imported_symbols=(),
+                        )
+                    ]
                 },
-            }
+            },
+            (),
         ).exports
         assert tuple((item.source_id, item.name) for item in result.unused_exports) == (
             ("example_values.source", "ExampleUnused"),
@@ -53,15 +61,16 @@ class TestInsightInvariants(InsightTestCase):
             {
                 source_id: {
                     "callables": [
-                        CodeMapFactory.source_callable(source_id, "example_target"),
-                        CodeMapFactory.source_callable(source_id, "example_caller"),
+                        CodeMapFactory().source_callable(source_id, "example_target"),
+                        CodeMapFactory().source_callable(source_id, "example_caller"),
                     ],
                     "calls": [
-                        CodeMapFactory.source_call(source_id, "example_caller", "example_target"),
-                        CodeMapFactory.source_call(source_id, "example_caller", "example_target"),
+                        CodeMapFactory().source_call(source_id, "example_caller", "example_target"),
+                        CodeMapFactory().source_call(source_id, "example_caller", "example_target"),
                     ],
                 }
-            }
+            },
+            (),
         ).callables
         entries = {item.source_callable: item for item in result.entries}
         caller = next(item for key, item in entries.items() if key.endswith("example_caller"))
@@ -71,7 +80,7 @@ class TestInsightInvariants(InsightTestCase):
         assert target.calls == ()
 
     def test_empty_project_has_empty_insights(self) -> None:
-        result = self.insight({})
+        result = self.insight({}, ())
         assert result.clusters.clusters == ()
         assert result.hotspots.hotspots == ()
         assert result.callables.entries == ()

{modwire-9.2.1 → modwire-9.2.2}/tests/architecture/shape/base_test.py

@@ -4,4 +4,6 @@ from ..base_test import ArchitectureTestCase
 
 class ShapeTestCase(ArchitectureTestCase):
     def source_file(self, file_id: str) -> dict[str, object]:
-        return {"functions": [CodeMapFactory.symbol("example_function")]}
+        return {
+            "functions": [CodeMapFactory().symbol("example_function", line_count=1, declared_args=0, optional_args=0)]
+        }

modwire-9.2.2/tests/architecture/shape/test_01_limits.py

@@ -0,0 +1,178 @@
+import pytest
+
+from ...support.code_map import CodeMapFactory
+from .base_test import ShapeTestCase
+
+
+class TestShapeLimits(ShapeTestCase):
+    @pytest.mark.parametrize(
+        ("rule", "source_file", "actual"),
+        (
+            (
+                "max_classes_per_file",
+                {
+                    "classes": [
+                        CodeMapFactory().source_class("ExampleFirst", line_count=1, methods=(), properties=()),
+                        CodeMapFactory().source_class("ExampleSecond", line_count=1, methods=(), properties=()),
+                    ]
+                },
+                2,
+            ),
+            (
+                "max_functions_per_file",
+                {
+                    "functions": [
+                        CodeMapFactory().symbol("example_first", line_count=1, declared_args=0, optional_args=0),
+                        CodeMapFactory().symbol("example_second", line_count=1, declared_args=0, optional_args=0),
+                    ]
+                },
+                2,
+            ),
+            (
+                "max_methods_per_class",
+                {
+                    "classes": [
+                        CodeMapFactory().source_class(
+                            "ExampleValue",
+                            line_count=1,
+                            methods=(
+                                CodeMapFactory().symbol(
+                                    "example_first", line_count=1, declared_args=0, optional_args=0
+                                ),
+                                CodeMapFactory().symbol(
+                                    "example_second", line_count=1, declared_args=0, optional_args=0
+                                ),
+                            ),
+                            properties=(),
+                        )
+                    ]
+                },
+                2,
+            ),
+            (
+                "max_declared_args",
+                {
+                    "functions": [
+                        CodeMapFactory().symbol("example_function", line_count=1, declared_args=2, optional_args=0)
+                    ]
+                },
+                2,
+            ),
+            (
+                "max_function_lines",
+                {
+                    "functions": [
+                        CodeMapFactory().symbol("example_function", line_count=3, declared_args=0, optional_args=0)
+                    ]
+                },
+                3,
+            ),
+            (
+                "max_method_lines",
+                {
+                    "classes": [
+                        CodeMapFactory().source_class(
+                            "ExampleValue",
+                            line_count=1,
+                            methods=(
+                                CodeMapFactory().symbol(
+                                    "example_method", line_count=3, declared_args=0, optional_args=0
+                                ),
+                            ),
+                            properties=(),
+                        )
+                    ]
+                },
+                3,
+            ),
+            (
+                "max_class_lines",
+                {"classes": [CodeMapFactory().source_class("ExampleValue", line_count=3, methods=(), properties=())]},
+                3,
+            ),
+        ),
+    )
+    @pytest.mark.parametrize("offset", (-1, 0, 1))
+    def test_limits_report_only_values_above_the_threshold(
+        self, rule: str, source_file: dict[str, object], actual: int, offset: int
+    ) -> None:
+        code_map = CodeMapFactory().queryable({"example.source": source_file}, ())
+        config = self.application.configure(
+            {"shape": {"realms": [{"name": "example-source", "match": "*", "shape": {rule: actual + offset}}]}}
+        )
+        violations = tuple(
+            item
+            for item in self.report("architecture.violations.shape", config, code_map).violations
+            if item.rule_name == rule
+        )
+        if offset < 0:
+            assert len(violations) == 1
+            assert violations[0].actual == actual
+            assert violations[0].limit == actual + offset
+            assert violations[0].source_id == "example.source"
+        else:
+            assert violations == ()
+
+    @pytest.mark.parametrize(
+        ("rule", "source_file"),
+        (
+            (
+                "allow_optional_function_args",
+                {
+                    "functions": [
+                        CodeMapFactory().symbol("example_function", line_count=1, declared_args=1, optional_args=1)
+                    ]
+                },
+            ),
+            (
+                "allow_optional_method_args",
+                {
+                    "classes": [
+                        CodeMapFactory().source_class(
+                            "ExampleValue",
+                            line_count=1,
+                            methods=(
+                                CodeMapFactory().symbol(
+                                    "example_method", line_count=1, declared_args=1, optional_args=1
+                                ),
+                            ),
+                            properties=(),
+                        )
+                    ]
+                },
+            ),
+            (
+                "allow_optional_class_properties",
+                {
+                    "classes": [
+                        CodeMapFactory().source_class(
+                            "ExampleValue",
+                            line_count=1,
+                            methods=(),
+                            properties=({"name": "example_value", "is_optional": True},),
+                        )
+                    ]
+                },
+            ),
+            (
+                "allow_import_aliases",
+                {
+                    "imports": [
+                        CodeMapFactory().source_import(
+                            "example_external", imported_name="", is_aliased=True, imported_symbols=()
+                        )
+                    ]
+                },
+            ),
+        ),
+    )
+    @pytest.mark.parametrize("allowed", (False, True))
+    def test_boolean_permissions_apply_to_the_public_report(
+        self, rule: str, source_file: dict[str, object], allowed: bool
+    ) -> None:
+        code_map = CodeMapFactory().queryable({"example.source": source_file}, ())
+        config = self.application.configure(
+            {"shape": {"realms": [{"name": "example-source", "match": "*", "shape": {rule: allowed}}]}}
+        )
+        violations = self.report("architecture.violations.shape", config, code_map).violations
+        assert any(item.rule_name == rule for item in violations) is not allowed

{modwire-9.2.1 → modwire-9.2.2}/tests/shared/code/test_02_invariants.py

@@ -6,16 +6,17 @@ from ...support.service_test import ServiceTestCase
 
 class TestPublicCodeValues(ServiceTestCase):
     def test_query_filters_are_composable_without_changing_the_original_query(self) -> None:
-        result = CodeMapFactory.queryable(
+        result = CodeMapFactory().queryable(
             {
                 "example.source": {
                     "classes": [
-                        CodeMapFactory.source_class("ExampleFirst"),
-                        CodeMapFactory.source_class("ExampleSecond"),
-                        CodeMapFactory.source_class("ExampleThird"),
+                        CodeMapFactory().source_class("ExampleFirst", line_count=1, methods=(), properties=()),
+                        CodeMapFactory().source_class("ExampleSecond", line_count=1, methods=(), properties=()),
+                        CodeMapFactory().source_class("ExampleThird", line_count=1, methods=(), properties=()),
                     ]
                 }
-            }
+            },
+            (),
         )
         original = result.classes()
         selected = original.where_contains(lambda item: item.item.name, "example", case_sensitive=False)
@@ -28,7 +29,7 @@ class TestPublicCodeValues(ServiceTestCase):
 
     def test_incoming_and_outgoing_queries_preserve_edge_direction(self) -> None:
         paths = ("example_first.source", "example_second.source", "example_third.source")
-        result = CodeMapFactory.queryable(
+        result = CodeMapFactory().queryable(
             dict.fromkeys(paths, {}),
             (
                 (paths[0], paths[1], "resolved", "example_second"),
@@ -42,16 +43,18 @@ class TestPublicCodeValues(ServiceTestCase):
         assert result.dependencies_between(paths[2], paths[1]).all() == ()
 
     def test_code_map_round_trips_json(self) -> None:
-        original = CodeMapFactory.queryable({"src/example.source": {}}).code_map
+        original = CodeMapFactory().queryable({"src/example.source": {}}, ()).code_map
         restored = type(original).model_validate_json(original.to_json())
         assert restored.to_dict() == original.to_dict()
         assert original.schema_version == 2
         assert set(json.loads(original.to_json())) == {"language", "extraction", "dependency_graph"}
 
     def test_query_surfaces_keep_external_and_tracked_edges_distinct(self) -> None:
-        result = CodeMapFactory.queryable(
+        result = CodeMapFactory().queryable(
             {
-                "example_values.source": {"classes": [CodeMapFactory.source_class("ExampleValue")]},
+                "example_values.source": {
+                    "classes": [CodeMapFactory().source_class("ExampleValue", line_count=1, methods=(), properties=())]
+                },
                 "example_consumer.source": {},
             },
             (

{modwire-9.2.1 → modwire-9.2.2}/tests/support/code_map.py

@@ -6,13 +6,12 @@ from modwire.application import CodeMap, QueryableCodeMap
 
 
 class CodeMapFactory:
-    @classmethod
     def queryable(
-        cls,
+        self,
         files: Mapping[str, Mapping[str, object]],
-        edges: tuple[tuple[str, str | None, str, str], ...] = (),
+        edges: tuple[tuple[str, str | None, str, str], ...],
     ) -> QueryableCodeMap:
-        source_files = {source_id: cls.source_file(source_id, values) for source_id, values in files.items()}
+        source_files = {source_id: self.source_file(source_id, values) for source_id, values in files.items()}
         modules = {str(source_file["module_id"]): source_id for source_id, source_file in source_files.items()}
         nodes = {source_id: {"id": source_id, "kind": "file"} for source_id in source_files}
         dependency_edges = []
@@ -43,8 +42,7 @@ class CodeMapFactory:
         )
         return QueryableCodeMap(code_map=code_map)
 
-    @staticmethod
-    def source_file(source_id: str, values: Mapping[str, object]) -> dict[str, object]:
+    def source_file(self, source_id: str, values: Mapping[str, object]) -> dict[str, object]:
         defaults: dict[str, object] = {
             "file_id": source_id,
             "module_id": str(PurePosixPath(source_id).with_suffix("")).replace("/", "."),
@@ -64,8 +62,7 @@ class CodeMapFactory:
         }
         return {**defaults, **values}
 
-    @staticmethod
-    def symbol(name: str, *, line_count: int = 1, declared_args: int = 0, optional_args: int = 0) -> dict[str, Any]:
+    def symbol(self, name: str, *, line_count: int, declared_args: int, optional_args: int) -> dict[str, Any]:
         return {
             "name": name,
             "visibility": "public",
@@ -75,14 +72,13 @@ class CodeMapFactory:
             "optional_args": optional_args,
         }
 
-    @classmethod
     def source_class(
-        cls,
+        self,
         name: str,
         *,
-        line_count: int = 1,
-        methods: tuple[Mapping[str, object], ...] = (),
-        properties: tuple[Mapping[str, object], ...] = (),
+        line_count: int,
+        methods: tuple[Mapping[str, object], ...],
+        properties: tuple[Mapping[str, object], ...],
     ) -> dict[str, object]:
         return {
             "name": name,
@@ -93,13 +89,13 @@ class CodeMapFactory:
             "properties": list(properties),
         }
 
-    @staticmethod
     def source_import(
+        self,
         specifier: str,
         *,
-        imported_name: str = "",
-        is_aliased: bool = False,
-        imported_symbols: tuple[Mapping[str, object], ...] = (),
+        imported_name: str,
+        is_aliased: bool,
+        imported_symbols: tuple[Mapping[str, object], ...],
     ) -> dict[str, object]:
         return {
             "path": specifier,
@@ -117,8 +113,7 @@ class CodeMapFactory:
             "imported_symbols": list(imported_symbols),
         }
 
-    @staticmethod
-    def source_export(name: str) -> dict[str, object]:
+    def source_export(self, name: str) -> dict[str, object]:
         return {
             "name": name,
             "local_name": name,
@@ -133,10 +128,9 @@ class CodeMapFactory:
             "statement_id": 0,
         }
 
-    @classmethod
-    def source_callable(cls, source_id: str, name: str) -> dict[str, object]:
+    def source_callable(self, source_id: str, name: str) -> dict[str, object]:
         return {
-            **cls.symbol(name),
+            **self.symbol(name, line_count=1, declared_args=0, optional_args=0),
             "id": f"{source_id}::{name}",
             "source_id": source_id,
             "qualified_name": name,
@@ -150,8 +144,7 @@ class CodeMapFactory:
             "docstring": "",
         }
 
-    @staticmethod
-    def source_call(source_id: str, source_name: str, target_name: str) -> dict[str, object]:
+    def source_call(self, source_id: str, source_name: str, target_name: str) -> dict[str, object]:
         return {
             "source_callable_id": f"{source_id}::{source_name}",
             "target_callable_id": f"{source_id}::{target_name}",