codinsight 0.0.5__tar.gz → 0.0.7__tar.gz

codinsight-0.0.7/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: codinsight
+Version: 0.0.7
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.10.5
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: pycodestyle>=2.14.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydocstyle>=6.3.0
+Requires-Dist: pytest>=8.4.1
+Requires-Dist: pytest-cov>=6.2.1
+Requires-Dist: radon>=6.0.1
+Requires-Dist: reportlab>=4.4.3
+Requires-Dist: scikit-learn>=1.7.1

codinsight-0.0.7/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codinsight"
+version = "0.0.7"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "matplotlib>=3.10.5",
+    "pandas>=2.3.1",
+    "pycodestyle>=2.14.0",
+    "pydantic>=2.11.7",
+    "pydocstyle>=6.3.0",
+    "pytest>=8.4.1",
+    "pytest-cov>=6.2.1",
+    "radon>=6.0.1",
+    "reportlab>=4.4.3",
+    "scikit-learn>=1.7.1",
+]
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+
+[tool.isort]
+profile = "black"
+
+[tool.pydocstyle]
+ignore = ["D100", "D104", "D203", "D205", "D212", "D400", "D415"]
+addopts = "--exclude=tests"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/code_insight"]
+include = ["src/code_insight/py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

codinsight-0.0.7/src/code_insight/__init__.py

@@ -0,0 +1,26 @@
+from .code_analysis.algorithm import Algorithm, AlgorithmAnalysisResult
+from .code_analysis.complexity import Complexity, ComplexityAnalysisResult
+from .code_analysis.readability import Readability, ReadabilityAnalysisResult
+from .code_analysis.redundancy import Redundancy, RedundancyAnalysisResult
+from .code_analysis.struct import Struct, StructAnalysisResult
+from .code_analysis.style import Style, StyleAnalysisResult
+from .core import CodeAnalysis, CodeAnalysisType
+from .trend_analysis.trend_analysis import TrendAnalysis
+
+__all__ = [
+    "CodeAnalysis",
+    "Readability",
+    "ReadabilityAnalysisResult",
+    "CodeAnalysisType",
+    "Style",
+    "StyleAnalysisResult",
+    "Struct",
+    "StructAnalysisResult",
+    "Redundancy",
+    "RedundancyAnalysisResult",
+    "Algorithm",
+    "AlgorithmAnalysisResult",
+    "Complexity",
+    "ComplexityAnalysisResult",
+    "TrendAnalysis",
+]

codinsight-0.0.7/src/code_insight/code_analysis/abstract.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+
+class BaseAnalysisResult(BaseModel):
+    """解析結果のベースモデル"""
+
+
+T = TypeVar("T", bound=BaseAnalysisResult)
+
+
+class AbstractAnalysis(ABC, Generic[T]):
+    """解析抽象クラス"""
+
+    @abstractmethod
+    def analyze(self, source_code: str) -> T:
+        """コードを解析する"""
+        raise NotImplementedError("analyze method must be implemented")

codinsight-0.0.7/src/code_insight/code_analysis/algorithm.py

@@ -0,0 +1,189 @@
+import ast
+from typing import Set
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class AlgorithmAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(アルゴリズム)
+    * 制御構文
+        * if文の数
+        * for文の数
+        * while文の数
+        * try-except文の数
+    * 再帰構造
+        * 再帰関数の割合
+    * FP的要素
+        * lambda式の数
+        * リスト内包表記の数
+        * map/filter/reduce呼び出しの数
+    * 循環的複雑度
+        * McCabe複雑度の平均
+    * ネスト深度
+        * 制御構文の最大ネスト深度
+    """
+
+    if_count: int
+    for_count: int
+    while_count: int
+    try_count: int
+    recursion_rate: float
+    lambda_count: int
+    comprehension_count: int
+    functional_call_count: int
+    cyclomatic_complexity: float
+    max_nesting_depth: int
+
+
+class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult]):
+    """解析クラス(アルゴリズム)"""
+
+    def analyze(self, source_code: str) -> AlgorithmAnalysisResult:
+        """コード解析"""
+        return AlgorithmAnalysisResult(
+            if_count=self.get_if_count(source_code),
+            for_count=self.get_for_count(source_code),
+            while_count=self.get_while_count(source_code),
+            try_count=self.get_try_count(source_code),
+            recursion_rate=self.get_recursion_rate(source_code),
+            lambda_count=self.get_lambda_count(source_code),
+            comprehension_count=self.get_comprehension_count(source_code),
+            functional_call_count=self.get_functional_call_count(source_code),
+            cyclomatic_complexity=self.get_cyclomatic_complexity(source_code),
+            max_nesting_depth=self.get_max_nesting_depth(source_code),
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """ソースコードを解析"""
+        return ast.parse(source_code)
+
+    def get_if_count(self, source_code: str) -> int:
+        """if文の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(isinstance(node, ast.If) for node in ast.walk(tree))
+
+    def get_for_count(self, source_code: str) -> int:
+        """for文の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(isinstance(node, (ast.For, ast.AsyncFor)) for node in ast.walk(tree))
+
+    def get_while_count(self, source_code: str) -> int:
+        """while文の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(isinstance(node, ast.While) for node in ast.walk(tree))
+
+    def get_try_count(self, source_code: str) -> int:
+        """try-except文の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(isinstance(node, ast.Try) for node in ast.walk(tree))
+
+    def get_recursion_rate(self, source_code: str) -> float:
+        """再帰関数の割合を取得"""
+        tree = self.parse_source_code(source_code)
+        function_names: Set[str] = set()
+        recursive_functions: Set[str] = set()
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                function_names.add(node.name)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                for call_node in ast.walk(node):
+                    if (
+                        isinstance(call_node, ast.Call)
+                        and isinstance(call_node.func, ast.Name)
+                        and call_node.func.id == node.name
+                    ):
+                        recursive_functions.add(node.name)
+
+        if function_names:
+            return len(recursive_functions) / len(function_names)
+        return 0.0
+
+    def get_lambda_count(self, source_code: str) -> int:
+        """lambda式の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(isinstance(node, ast.Lambda) for node in ast.walk(tree))
+
+    def get_comprehension_count(self, source_code: str) -> int:
+        """内包表記の数を取得"""
+        tree = self.parse_source_code(source_code)
+        return sum(
+            isinstance(
+                node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+            )
+            for node in ast.walk(tree)
+        )
+
+    def get_functional_call_count(self, source_code: str) -> int:
+        """map/filter/reduce呼び出しの数を取得"""
+        tree = self.parse_source_code(source_code)
+        functional_names = {"map", "filter", "reduce"}
+        count = 0
+
+        for node in ast.walk(tree):
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Name)
+                and node.func.id in functional_names
+            ):
+                count += 1
+
+        return count
+
+    def get_cyclomatic_complexity(self, source_code: str) -> float:
+        """循環的複雑度の平均を取得"""
+        tree = self.parse_source_code(source_code)
+        complexities = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                complexity = self._calculate_function_complexity(node)
+                complexities.append(complexity)
+
+        return sum(complexities) / len(complexities) if complexities else 0.0
+
+    def _calculate_function_complexity(self, func_node: ast.FunctionDef) -> int:
+        """関数の循環的複雑度を計算"""
+        complexity = 1
+
+        for node in ast.walk(func_node):
+            if isinstance(node, (ast.If, ast.While, ast.For, ast.AsyncFor)):
+                complexity += 1
+            elif isinstance(node, ast.Try):
+                complexity += len(node.handlers)
+            elif isinstance(node, ast.BoolOp):
+                complexity += len(node.values) - 1
+
+        return complexity
+
+    def get_max_nesting_depth(self, source_code: str) -> int:
+        """制御構文の最大ネスト深度を取得"""
+        tree = self.parse_source_code(source_code)
+        max_depth = 0
+
+        def calculate_depth(node: ast.AST, current_depth: int = 0) -> None:
+            nonlocal max_depth
+
+            if isinstance(
+                node,
+                (
+                    ast.If,
+                    ast.For,
+                    ast.AsyncFor,
+                    ast.While,
+                    ast.Try,
+                    ast.With,
+                    ast.AsyncWith,
+                ),
+            ):
+                current_depth += 1
+                max_depth = max(max_depth, current_depth)
+
+            for child in ast.iter_child_nodes(node):
+                calculate_depth(child, current_depth)
+
+        calculate_depth(tree)
+        return max_depth

codinsight-0.0.7/src/code_insight/code_analysis/complexity.py

@@ -0,0 +1,212 @@
+import ast
+
+import radon.complexity as cc
+import radon.metrics as metrics
+
+from code_insight.code_analysis.abstract import AbstractAnalysis, BaseAnalysisResult
+
+
+class ComplexityAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(複雑度)
+    * サイクロマティック複雑度
+        * 関数・メソッドの平均サイクロマティック複雑度
+    * Halstead複雑度
+        * Halstead Volume, Difficulty, Effort
+    * ネストの深さ
+        * 最大ネスト深度と平均ネスト深度
+    * 認知的複雑度
+        * 制御構造の複雑さを測定
+    * 保守性指数
+        * Maintainability Index
+    """
+
+    cyclomatic_complexity: float
+    halstead_volume: float
+    halstead_difficulty: float
+    halstead_effort: float
+    max_nesting_depth: int
+    avg_nesting_depth: float
+    cognitive_complexity: float
+    maintainability_index: float
+
+
+class Complexity(AbstractAnalysis[ComplexityAnalysisResult]):
+    """解析クラス(複雑度)"""
+
+    def analyze(self, source_code: str) -> ComplexityAnalysisResult:
+        """コード解析"""
+        return ComplexityAnalysisResult(
+            cyclomatic_complexity=self.get_cyclomatic_complexity(source_code),
+            halstead_volume=self.get_halstead_volume(source_code),
+            halstead_difficulty=self.get_halstead_difficulty(source_code),
+            halstead_effort=self.get_halstead_effort(source_code),
+            max_nesting_depth=self.get_max_nesting_depth(source_code),
+            avg_nesting_depth=self.get_avg_nesting_depth(source_code),
+            cognitive_complexity=self.get_cognitive_complexity(source_code),
+            maintainability_index=self.get_maintainability_index(source_code),
+        )
+
+    def get_cyclomatic_complexity(self, source_code: str) -> float:
+        """サイクロマティック複雑度の平均を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            cc_result = cc.cc_visit(source_code)
+            if not cc_result:
+                return 0.0
+
+            total_complexity = sum(item.complexity for item in cc_result)
+            return total_complexity / len(cc_result)
+        except Exception:
+            return 0.0
+
+    def get_halstead_volume(self, source_code: str) -> float:
+        """Halstead Volumeを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.volume if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_halstead_difficulty(self, source_code: str) -> float:
+        """Halstead Difficultyを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.difficulty if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_halstead_effort(self, source_code: str) -> float:
+        """Halstead Effortを取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            h_result = metrics.h_visit(source_code)
+            return h_result.total.effort if h_result.total else 0.0
+        except Exception:
+            return 0.0
+
+    def get_maintainability_index(self, source_code: str) -> float:
+        """保守性指数を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            return metrics.mi_visit(source_code, multi=True)
+        except Exception:
+            return 0.0
+
+    def get_max_nesting_depth(self, source_code: str) -> int:
+        """最大ネスト深度を取得"""
+        if not source_code.strip():
+            return 0
+
+        try:
+            tree = ast.parse(source_code)
+            max_depth = 0
+
+            def calculate_depth(node: ast.AST, current_depth: int = 0) -> int:
+                nonlocal max_depth
+
+                nesting_nodes = (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.With,
+                    ast.Try,
+                    ast.FunctionDef,
+                    ast.ClassDef,
+                    ast.AsyncFor,
+                    ast.AsyncWith,
+                )
+
+                if isinstance(node, nesting_nodes):
+                    current_depth += 1
+                    max_depth = max(max_depth, current_depth)
+
+                for child in ast.iter_child_nodes(node):
+                    calculate_depth(child, current_depth)
+
+                return max_depth
+
+            return calculate_depth(tree)
+        except Exception:
+            return 0
+
+    def get_avg_nesting_depth(self, source_code: str) -> float:
+        """平均ネスト深度を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            tree = ast.parse(source_code)
+            depths = []
+
+            def collect_depths(node: ast.AST, current_depth: int = 0) -> None:
+                nesting_nodes = (ast.If, ast.For, ast.While, ast.With, ast.Try)
+
+                if isinstance(node, nesting_nodes):
+                    current_depth += 1
+                    depths.append(current_depth)
+
+                for child in ast.iter_child_nodes(node):
+                    collect_depths(child, current_depth)
+
+            collect_depths(tree)
+            return sum(depths) / len(depths) if depths else 0.0
+        except Exception:
+            return 0.0
+
+    def get_cognitive_complexity(self, source_code: str) -> float:
+        """認知的複雑度を取得"""
+        if not source_code.strip():
+            return 0.0
+
+        try:
+            tree = ast.parse(source_code)
+            complexity = 0
+
+            def calculate_cognitive_complexity(
+                node: ast.AST, nesting_level: int = 0
+            ) -> int:
+                nonlocal complexity
+
+                if isinstance(node, (ast.If, ast.While, ast.For)):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.Try):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.ExceptHandler):
+                    complexity += 1 + nesting_level
+                elif isinstance(node, ast.BoolOp):
+                    complexity += len(node.values) - 1
+
+                nesting_increment_nodes = (
+                    ast.If,
+                    ast.For,
+                    ast.While,
+                    ast.Try,
+                    ast.FunctionDef,
+                    ast.AsyncFunctionDef,
+                )
+
+                new_nesting_level = nesting_level
+                if isinstance(node, nesting_increment_nodes):
+                    new_nesting_level += 1
+
+                for child in ast.iter_child_nodes(node):
+                    calculate_cognitive_complexity(child, new_nesting_level)
+
+                return complexity
+
+            return float(calculate_cognitive_complexity(tree))
+        except Exception:
+            return 0.0