code-change-impact-analyzer 0.1.0__tar.gz

code_change_impact_analyzer-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+.Python
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.venv/
+venv/
+.env
+.DS_Store
+.vscode/

code_change_impact_analyzer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vidhi Bhutia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

code_change_impact_analyzer-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include src *.py
+recursive-exclude tests *

code_change_impact_analyzer-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: code-change-impact-analyzer
+Version: 0.1.0
+Summary: Analyze and predict impacted Python modules from code changes using static dependency analysis.
+Project-URL: PyPI, https://pypi.org/project/code-change-impact-analyzer/
+Author-email: Vidhi Bhutia <vidhibhutia2407@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,dependency-graph,impact-analysis,python,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.12.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Code Change Impact Analyzer
+
+A Python package and CLI that predicts which Python modules are impacted when a file changes.
+
+## What it does
+
+Given a changed file (for example `auth/login.py`), the analyzer:
+
+1. Parses project files.
+2. Detects function definitions.
+3. Builds import and call dependency graphs.
+4. Maps function usage across modules.
+5. Shows impacted modules.
+
+## Why engineers use it
+
+- Understand blast radius before merging changes.
+- Speed up code reviews in large codebases.
+- Decide where to add or run tests.
+
+## Installation
+
+```bash
+pip install code-change-impact-analyzer
+```
+
+For local development:
+
+```bash
+pip install -e .[dev]
+```
+
+## CLI Usage
+
+```bash
+impact-analyzer --root . --changed auth/login.py
+```
+
+Options:
+
+- `--root`: project root directory to analyze (default: current directory)
+- `--changed`: changed file path relative to root (required)
+- `--json`: print JSON output
+
+## Example Output
+
+```text
+Editing: auth/login.py
+Impacted modules:
+- api/routes.py
+- user/service.py
+- tests/test_login.py
+```
+
+## How it works
+
+The tool performs static analysis over Python source files:
+
+- Collects module imports (`import x`, `from x import y`)
+- Collects function definitions per module
+- Collects function calls per module
+- Builds reverse dependency graph to find modules depending on the changed module
+- Expands impact by function-level usage signals
+
+## Limitations
+
+- Dynamic imports and metaprogramming are not fully resolved.
+- Runtime dispatch and monkey patching are not modeled.
+- Best for conventional Python codebases.

code_change_impact_analyzer-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Code Change Impact Analyzer
+
+A Python package and CLI that predicts which Python modules are impacted when a file changes.
+
+## What it does
+
+Given a changed file (for example `auth/login.py`), the analyzer:
+
+1. Parses project files.
+2. Detects function definitions.
+3. Builds import and call dependency graphs.
+4. Maps function usage across modules.
+5. Shows impacted modules.
+
+## Why engineers use it
+
+- Understand blast radius before merging changes.
+- Speed up code reviews in large codebases.
+- Decide where to add or run tests.
+
+## Installation
+
+```bash
+pip install code-change-impact-analyzer
+```
+
+For local development:
+
+```bash
+pip install -e .[dev]
+```
+
+## CLI Usage
+
+```bash
+impact-analyzer --root . --changed auth/login.py
+```
+
+Options:
+
+- `--root`: project root directory to analyze (default: current directory)
+- `--changed`: changed file path relative to root (required)
+- `--json`: print JSON output
+
+## Example Output
+
+```text
+Editing: auth/login.py
+Impacted modules:
+- api/routes.py
+- user/service.py
+- tests/test_login.py
+```
+
+## How it works
+
+The tool performs static analysis over Python source files:
+
+- Collects module imports (`import x`, `from x import y`)
+- Collects function definitions per module
+- Collects function calls per module
+- Builds reverse dependency graph to find modules depending on the changed module
+- Expands impact by function-level usage signals
+
+## Limitations
+
+- Dynamic imports and metaprogramming are not fully resolved.
+- Runtime dispatch and monkey patching are not modeled.
+- Best for conventional Python codebases.

code_change_impact_analyzer-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "code-change-impact-analyzer"
+version = "0.1.0"
+description = "Analyze and predict impacted Python modules from code changes using static dependency analysis."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+  { name = "Vidhi Bhutia", email = "vidhibhutia2407@gmail.com" }
+]
+keywords = ["static-analysis", "dependency-graph", "impact-analysis", "python", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Software Development :: Quality Assurance"
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.3.0",
+  "pytest-cov>=5.0.0",
+  "ruff>=0.12.0",
+  "mypy>=1.11.0"
+]
+
+[project.urls]
+PyPI = "https://pypi.org/project/code-change-impact-analyzer/"
+
+[project.scripts]
+impact-analyzer = "code_impact_analyzer.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/code_impact_analyzer"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+addopts = "-q"
+norecursedirs = ["tests/fixtures"]
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+warn_unused_configs = true
+mypy_path = "src"

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/__init__.py

@@ -0,0 +1,4 @@
+from .analyzer import ImpactReport, analyze_change
+
+__all__ = ["ImpactReport", "analyze_change"]
+__version__ = "0.1.0"

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/analyzer.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path
+
+from .models import ImpactReport, ImpactedModule, ModuleAnalysis
+from .parser import discover_python_files, module_name_from_path, module_path_from_name, parse_module_file
+
+
+def _resolve_imported_modules(import_name: str, known_modules: set[str]) -> set[str]:
+    resolved: set[str] = set()
+
+    if import_name in known_modules:
+        resolved.add(import_name)
+
+    prefix = import_name
+    while "." in prefix:
+        prefix = prefix.rsplit(".", 1)[0]
+        if prefix in known_modules:
+            resolved.add(prefix)
+
+    for module in known_modules:
+        if module.startswith(import_name + "."):
+            resolved.add(module)
+
+    return resolved
+
+
+def _build_reverse_dependency_graph(module_map: dict[str, ModuleAnalysis]) -> dict[str, set[str]]:
+    known_modules = set(module_map)
+    reverse_graph: dict[str, set[str]] = {module: set() for module in module_map}
+
+    for module, analysis in module_map.items():
+        for imported in analysis.imports:
+            for resolved in _resolve_imported_modules(imported, known_modules):
+                reverse_graph.setdefault(resolved, set()).add(module)
+
+    return reverse_graph
+
+
+def _transitive_dependents(changed_module: str, reverse_graph: dict[str, set[str]]) -> set[str]:
+    impacted: set[str] = set()
+    queue: deque[str] = deque([changed_module])
+    visited: set[str] = {changed_module}
+
+    while queue:
+        current = queue.popleft()
+        for dependent in reverse_graph.get(current, set()):
+            if dependent in visited:
+                continue
+            visited.add(dependent)
+            impacted.add(dependent)
+            queue.append(dependent)
+
+    return impacted
+
+
+def analyze_change(root: str | Path, changed_file: str | Path) -> ImpactReport:
+    root_path = Path(root).resolve()
+    changed_path = (root_path / changed_file).resolve() if not Path(changed_file).is_absolute() else Path(changed_file).resolve()
+
+    if not changed_path.exists() or changed_path.suffix != ".py":
+        raise FileNotFoundError(f"Changed file does not exist or is not a .py file: {changed_file}")
+
+    python_files = discover_python_files(root_path)
+    module_to_path: dict[str, Path] = {}
+    module_map: dict[str, ModuleAnalysis] = {}
+
+    for file_path in python_files:
+        module_name = module_name_from_path(root_path, file_path)
+        module_to_path[module_name] = file_path
+        module_map[module_name] = parse_module_file(file_path)
+
+    changed_module = module_name_from_path(root_path, changed_path)
+    if changed_module not in module_map:
+        raise ValueError(f"Changed module was not discovered during analysis: {changed_module}")
+
+    reverse_graph = _build_reverse_dependency_graph(module_map)
+    impacted_by_import = _transitive_dependents(changed_module, reverse_graph)
+
+    changed_functions = module_map[changed_module].function_defs
+    impacted_entries: list[ImpactedModule] = []
+
+    for module in sorted(impacted_by_import):
+        reasons: list[str] = ["imports-or-transitively-depends-on-changed-module"]
+        if changed_functions and module_map[module].function_calls.intersection(changed_functions):
+            reasons.append("calls-function-defined-in-changed-module")
+
+        resolved_path = module_to_path.get(module) or module_path_from_name(root_path, module)
+        relative_path = str(resolved_path.relative_to(root_path)).replace("\\", "/")
+        impacted_entries.append(
+            ImpactedModule(module=module, path=relative_path, reasons=tuple(reasons))
+        )
+
+    changed_relative = str(changed_path.relative_to(root_path)).replace("\\", "/")
+    return ImpactReport(
+        changed_file=changed_relative,
+        changed_module=changed_module,
+        impacted_modules=tuple(impacted_entries),
+    )

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/cli.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .analyzer import analyze_change
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="impact-analyzer",
+        description="Predict impacted Python modules for a changed file.",
+    )
+    parser.add_argument("--root", default=".", help="Project root to analyze (default: current directory)")
+    parser.add_argument("--changed", required=True, help="Changed Python file path, relative to root")
+    parser.add_argument("--json", action="store_true", dest="as_json", help="Print output in JSON format")
+    return parser
+
+
+def _print_human(report: dict[str, object]) -> None:
+    changed_file = report["changed_file"]
+    impacted = report["impacted_modules"]
+
+    print(f"Editing: {changed_file}")
+    print("Impacted modules:")
+    if not impacted:
+        print("(none)")
+        return
+
+    for item in impacted:
+        path = item["path"]
+        print(f"- {path}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        report = analyze_change(Path(args.root), Path(args.changed)).as_dict()
+    except Exception as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    if args.as_json:
+        print(json.dumps(report, indent=2))
+    else:
+        _print_human(report)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/models.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class ModuleAnalysis:
+    imports: set[str]
+    function_defs: set[str]
+    function_calls: set[str]
+
+
+@dataclass(frozen=True)
+class ImpactedModule:
+    module: str
+    path: str
+    reasons: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class ImpactReport:
+    changed_file: str
+    changed_module: str
+    impacted_modules: tuple[ImpactedModule, ...] = field(default_factory=tuple)
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "changed_file": self.changed_file,
+            "changed_module": self.changed_module,
+            "impacted_modules": [
+                {"module": item.module, "path": item.path, "reasons": list(item.reasons)}
+                for item in self.impacted_modules
+            ],
+        }

code_change_impact_analyzer-0.1.0/src/code_impact_analyzer/parser.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from .models import ModuleAnalysis
+
+
+class _ModuleVisitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.imports: set[str] = set()
+        self.function_defs: set[str] = set()
+        self.function_calls: set[str] = set()
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            self.imports.add(alias.name)
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.module:
+            self.imports.add(node.module)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self.function_defs.add(node.name)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self.function_defs.add(node.name)
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        function_name = _extract_called_name(node.func)
+        if function_name:
+            self.function_calls.add(function_name)
+        self.generic_visit(node)
+
+
+def _extract_called_name(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    return None
+
+
+def module_name_from_path(root: Path, file_path: Path) -> str:
+    rel_path = file_path.relative_to(root)
+    if rel_path.suffix != ".py":
+        raise ValueError(f"Expected a Python file, got: {file_path}")
+
+    parts = list(rel_path.with_suffix("").parts)
+    if parts and parts[-1] == "__init__":
+        parts = parts[:-1]
+
+    return ".".join(parts)
+
+
+def module_path_from_name(root: Path, module_name: str) -> Path:
+    parts = module_name.split(".") if module_name else []
+    return root.joinpath(*parts).with_suffix(".py")
+
+
+def discover_python_files(root: Path) -> list[Path]:
+    ignore_dirs = {".git", ".venv", "venv", "__pycache__", "build", "dist", ".mypy_cache", ".pytest_cache"}
+    python_files: list[Path] = []
+
+    for path in root.rglob("*.py"):
+        if any(part in ignore_dirs for part in path.parts):
+            continue
+        python_files.append(path)
+
+    return sorted(python_files)
+
+
+def parse_module_file(file_path: Path) -> ModuleAnalysis:
+    source = file_path.read_text(encoding="utf-8")
+    tree = ast.parse(source, filename=str(file_path))
+
+    visitor = _ModuleVisitor()
+    visitor.visit(tree)
+
+    return ModuleAnalysis(
+        imports=visitor.imports,
+        function_defs=visitor.function_defs,
+        function_calls=visitor.function_calls,
+    )

code_change_impact_analyzer-0.1.0/tests/fixtures/sample_project/api/routes.py

@@ -0,0 +1,5 @@
+from auth.login import login_user
+
+
+def login_route(user: str, pwd: str) -> bool:
+    return login_user(user, pwd)

code_change_impact_analyzer-0.1.0/tests/fixtures/sample_project/auth/login.py

@@ -0,0 +1,2 @@
+def login_user(username: str, password: str) -> bool:
+    return bool(username and password)

code_change_impact_analyzer-0.1.0/tests/fixtures/sample_project/tests/test_login.py

@@ -0,0 +1,5 @@
+from auth.login import login_user
+
+
+def test_login_user() -> None:
+    assert login_user("john", "secret")

code_change_impact_analyzer-0.1.0/tests/fixtures/sample_project/user/service.py

@@ -0,0 +1,5 @@
+from auth import login
+
+
+def can_sign_in(user: str, pwd: str) -> bool:
+    return login.login_user(user, pwd)

code_change_impact_analyzer-0.1.0/tests/test_analyzer.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+from code_impact_analyzer import analyze_change
+
+
+def test_analyze_change_returns_expected_impacted_modules() -> None:
+    root = Path(__file__).parent / "fixtures" / "sample_project"
+    report = analyze_change(root, "auth/login.py")
+
+    impacted_paths = {item.path for item in report.impacted_modules}
+    assert impacted_paths == {"api/routes.py", "tests/test_login.py", "user/service.py"}
+
+
+def test_changed_file_not_listed_as_impacted() -> None:
+    root = Path(__file__).parent / "fixtures" / "sample_project"
+    report = analyze_change(root, "auth/login.py")
+
+    impacted_paths = {item.path for item in report.impacted_modules}
+    assert "auth/login.py" not in impacted_paths

code_change_impact_analyzer-0.1.0/tests/test_cli.py

@@ -0,0 +1,15 @@
+import json
+from pathlib import Path
+
+from code_impact_analyzer.cli import main
+
+
+def test_cli_json_output(capsys) -> None:
+    root = Path(__file__).parent / "fixtures" / "sample_project"
+    exit_code = main(["--root", str(root), "--changed", "auth/login.py", "--json"])
+    assert exit_code == 0
+
+    output = capsys.readouterr().out
+    data = json.loads(output)
+    impacted_paths = {item["path"] for item in data["impacted_modules"]}
+    assert impacted_paths == {"api/routes.py", "tests/test_login.py", "user/service.py"}