codinsight 0.0.6__tar.gz → 0.0.8__tar.gz

codinsight-0.0.8/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: codinsight
+Version: 0.0.8
+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 - 複数ファイル解析の利用方法
+
+概要
+- 複数のファイルやディレクトリを再帰的に走査し、既存の解析エンジン（Style/Struct/Readability/Redundancy/Algorithm/Complexity/Quality）で一括解析を実行
+- 拡張子のフィルタや除外パターン（node_modules, .git など）に対応
+- 結果をファイル単位と集約統計（平均など）で取得可能
+- Pydantic BaseModel で JSON 化が容易
+
+## API 使用例
+
+```python
+from code_insight.core import CodeAnalysisType
+from code_insight.multi_analysis import MultiFileAnalyzer
+
+analyzer = MultiFileAnalyzer(
+    exts={".py"},
+    excludes={"node_modules", "target", ".git", ".venv", "__pycache__"},
+)
+result = analyzer.analyze(
+    ["src", "tests"],
+    [CodeAnalysisType.STYLE, CodeAnalysisType.STRUCT],
+)
+print(result.model_dump_json())
+```
+
+## 設定のカスタマイズ
+
+```python
+from code_insight.core import CodeAnalysis, AnalysisConfigs, CodeAnalysisType
+from code_insight.code_analysis.quality import QualityAnalysisConfig
+from code_insight.code_analysis.redundancy import RedundancyAnalysisConfig
+from code_insight.code_analysis.style import StyleAnalysisConfig
+
+# カスタム設定の作成
+configs = AnalysisConfigs(
+    quality=QualityAnalysisConfig(
+        long_param_threshold=3,  # デフォルト: 5
+        enabled=True
+    ),
+    redundancy=RedundancyAnalysisConfig(
+        long_function_lines_threshold=30,  # デフォルト: 50
+        long_function_complexity_threshold=8,  # デフォルト: 10
+        ignored_function_names={"main", "__init__", "setup"}
+    ),
+    style=StyleAnalysisConfig(
+        function_name_pattern=r"^[a-z_][a-z0-9_]*$",  # snake_case
+        class_name_pattern=r"^[A-Z][a-zA-Z0-9]*$"     # PascalCase
+    )
+)
+
+# 設定を使用した解析
+analysis = CodeAnalysis(source_code, configs)
+result = analysis.analyze([CodeAnalysisType.QUALITY, CodeAnalysisType.REDUNDANCY])
+
+# 複数ファイル解析での設定使用
+analyzer = MultiFileAnalyzer(configs=configs)
+result = analyzer.analyze(["src"], [CodeAnalysisType.STYLE])
+```
+
+### 設定可能な項目
+
+#### Quality解析
+- `long_param_threshold`: 長引数関数の閾値（デフォルト: 5）
+- `enabled`: 解析の有効/無効（デフォルト: True）
+
+#### Redundancy解析
+- `long_function_lines_threshold`: 長大関数の行数閾値（デフォルト: 50）
+- `long_function_complexity_threshold`: 長大関数の複雑度閾値（デフォルト: 10）
+- `ignored_function_names`: 未使用コード検出で無視する関数名（デフォルト: {"main", "__init__", "__main__"}）
+
+#### Style解析
+- `function_name_pattern`: 関数名の正規表現パターン（デフォルト: snake_case）
+- `class_name_pattern`: クラス名の正規表現パターン（デフォルト: PascalCase）
+
+#### その他の解析エンジン
+- Algorithm, Complexity, Readability, Structの各解析エンジンにも同様の設定項目があります
+
+主なオプション
+- exts: 対象拡張子のセット（デフォルト: {".py"}）
+- excludes: 除外ディレクトリ名のセット（デフォルト: {"node_modules", "target", ".git", ".venv", "__pycache__"}）
+
+返却データの構造
+- files: 各ファイルの解析結果（解析タイプ名 → メトリクス辞書）
+- aggregate:
+  - total_files: 解析対象に収集されたファイル数
+  - analyzed_files: 実際に解析に成功したファイル数
+  - errors: 解析時にエラーとなったファイルパスの一覧
+  - by_type_avg: 解析タイプごとの各数値メトリクスの平均値
+
+注意
+- 現時点では直列処理のみ対応。大規模データや並列化は将来的な拡張予定

codinsight-0.0.8/README.md

@@ -0,0 +1,91 @@
+Codinsight - 複数ファイル解析の利用方法
+
+概要
+- 複数のファイルやディレクトリを再帰的に走査し、既存の解析エンジン（Style/Struct/Readability/Redundancy/Algorithm/Complexity/Quality）で一括解析を実行
+- 拡張子のフィルタや除外パターン（node_modules, .git など）に対応
+- 結果をファイル単位と集約統計（平均など）で取得可能
+- Pydantic BaseModel で JSON 化が容易
+
+## API 使用例
+
+```python
+from code_insight.core import CodeAnalysisType
+from code_insight.multi_analysis import MultiFileAnalyzer
+
+analyzer = MultiFileAnalyzer(
+    exts={".py"},
+    excludes={"node_modules", "target", ".git", ".venv", "__pycache__"},
+)
+result = analyzer.analyze(
+    ["src", "tests"],
+    [CodeAnalysisType.STYLE, CodeAnalysisType.STRUCT],
+)
+print(result.model_dump_json())
+```
+
+## 設定のカスタマイズ
+
+```python
+from code_insight.core import CodeAnalysis, AnalysisConfigs, CodeAnalysisType
+from code_insight.code_analysis.quality import QualityAnalysisConfig
+from code_insight.code_analysis.redundancy import RedundancyAnalysisConfig
+from code_insight.code_analysis.style import StyleAnalysisConfig
+
+# カスタム設定の作成
+configs = AnalysisConfigs(
+    quality=QualityAnalysisConfig(
+        long_param_threshold=3,  # デフォルト: 5
+        enabled=True
+    ),
+    redundancy=RedundancyAnalysisConfig(
+        long_function_lines_threshold=30,  # デフォルト: 50
+        long_function_complexity_threshold=8,  # デフォルト: 10
+        ignored_function_names={"main", "__init__", "setup"}
+    ),
+    style=StyleAnalysisConfig(
+        function_name_pattern=r"^[a-z_][a-z0-9_]*$",  # snake_case
+        class_name_pattern=r"^[A-Z][a-zA-Z0-9]*$"     # PascalCase
+    )
+)
+
+# 設定を使用した解析
+analysis = CodeAnalysis(source_code, configs)
+result = analysis.analyze([CodeAnalysisType.QUALITY, CodeAnalysisType.REDUNDANCY])
+
+# 複数ファイル解析での設定使用
+analyzer = MultiFileAnalyzer(configs=configs)
+result = analyzer.analyze(["src"], [CodeAnalysisType.STYLE])
+```
+
+### 設定可能な項目
+
+#### Quality解析
+- `long_param_threshold`: 長引数関数の閾値（デフォルト: 5）
+- `enabled`: 解析の有効/無効（デフォルト: True）
+
+#### Redundancy解析
+- `long_function_lines_threshold`: 長大関数の行数閾値（デフォルト: 50）
+- `long_function_complexity_threshold`: 長大関数の複雑度閾値（デフォルト: 10）
+- `ignored_function_names`: 未使用コード検出で無視する関数名（デフォルト: {"main", "__init__", "__main__"}）
+
+#### Style解析
+- `function_name_pattern`: 関数名の正規表現パターン（デフォルト: snake_case）
+- `class_name_pattern`: クラス名の正規表現パターン（デフォルト: PascalCase）
+
+#### その他の解析エンジン
+- Algorithm, Complexity, Readability, Structの各解析エンジンにも同様の設定項目があります
+
+主なオプション
+- exts: 対象拡張子のセット（デフォルト: {".py"}）
+- excludes: 除外ディレクトリ名のセット（デフォルト: {"node_modules", "target", ".git", ".venv", "__pycache__"}）
+
+返却データの構造
+- files: 各ファイルの解析結果（解析タイプ名 → メトリクス辞書）
+- aggregate:
+  - total_files: 解析対象に収集されたファイル数
+  - analyzed_files: 実際に解析に成功したファイル数
+  - errors: 解析時にエラーとなったファイルパスの一覧
+  - by_type_avg: 解析タイプごとの各数値メトリクスの平均値
+
+注意
+- 現時点では直列処理のみ対応。大規模データや並列化は将来的な拡張予定

{codinsight-0.0.6 → codinsight-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codinsight"
-version = "0.0.6"
+version = "0.0.8"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

codinsight-0.0.8/src/code_insight/__init__.py

@@ -0,0 +1,56 @@
+from .code_analysis.algorithm import (
+    Algorithm,
+    AlgorithmAnalysisConfig,
+    AlgorithmAnalysisResult,
+)
+from .code_analysis.complexity import (
+    Complexity,
+    ComplexityAnalysisConfig,
+    ComplexityAnalysisResult,
+)
+from .code_analysis.quality import Quality, QualityAnalysisConfig, QualityAnalysisResult
+from .code_analysis.readability import (
+    Readability,
+    ReadabilityAnalysisConfig,
+    ReadabilityAnalysisResult,
+)
+from .code_analysis.redundancy import (
+    Redundancy,
+    RedundancyAnalysisConfig,
+    RedundancyAnalysisResult,
+)
+from .code_analysis.struct import Struct, StructAnalysisConfig, StructAnalysisResult
+from .code_analysis.style import Style, StyleAnalysisConfig, StyleAnalysisResult
+from .core import AnalysisConfigs, CodeAnalysis, CodeAnalysisType
+from .multi_analysis import MultiAnalysisResult, MultiFileAnalyzer
+from .trend_analysis.trend_analysis import TrendAnalysis
+
+__all__ = [
+    "CodeAnalysis",
+    "CodeAnalysisType",
+    "AnalysisConfigs",
+    "MultiFileAnalyzer",
+    "MultiAnalysisResult",
+    "Readability",
+    "ReadabilityAnalysisResult",
+    "ReadabilityAnalysisConfig",
+    "Algorithm",
+    "AlgorithmAnalysisResult",
+    "AlgorithmAnalysisConfig",
+    "Complexity",
+    "ComplexityAnalysisResult",
+    "ComplexityAnalysisConfig",
+    "Quality",
+    "QualityAnalysisResult",
+    "QualityAnalysisConfig",
+    "Redundancy",
+    "RedundancyAnalysisResult",
+    "RedundancyAnalysisConfig",
+    "Struct",
+    "StructAnalysisResult",
+    "StructAnalysisConfig",
+    "Style",
+    "StyleAnalysisResult",
+    "StyleAnalysisConfig",
+    "TrendAnalysis",
+]

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

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+
+class BaseAnalysisConfig(BaseModel):
+    """解析設定のベースクラス"""
+
+    enabled: bool = True
+
+
+class BaseAnalysisResult(BaseModel):
+    """解析結果のベースモデル"""
+
+
+R = TypeVar("R", bound=BaseAnalysisResult)
+C = TypeVar("C", bound=BaseAnalysisConfig)
+
+
+class AbstractAnalysis(ABC, Generic[R, C]):
+    """解析抽象クラス"""
+
+    config: C
+
+    def __init__(self, config: C | None = None) -> None:
+        """コンストラクタ"""
+        self.config = config or self.get_default_config()
+
+    @abstractmethod
+    def get_default_config(self) -> C:
+        """デフォルト設定を取得"""
+        raise NotImplementedError("get_default_config method must be implemented")
+
+    @abstractmethod
+    def analyze(self, source_code: str) -> R:
+        """コードを解析する"""
+        raise NotImplementedError("analyze method must be implemented")

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

@@ -0,0 +1,233 @@
+import ast
+from typing import Set
+
+from code_insight.code_analysis.abstract import (
+    AbstractAnalysis,
+    BaseAnalysisConfig,
+    BaseAnalysisResult,
+)
+
+
+class AlgorithmAnalysisConfig(BaseAnalysisConfig):
+    """
+    アルゴリズム解析設定
+    * 最大ネスト深度閾値
+    * サイクロマティック複雑度閾値
+    """
+
+    max_nesting_depth_threshold: int = 4
+    cyclomatic_complexity_threshold: float = 5.0
+
+
+class AlgorithmAnalysisResult(BaseAnalysisResult):
+    """
+    解析結果(アルゴリズム)
+    * 制御構文
+        * if文の数
+        * for文の数
+        * while文の数
+        * try-except文の数
+    * 再帰構造
+        * 再帰関数の割合
+    * FP的要素
+        * lambda式の数
+        * リスト内包表記の数
+        * map/filter/reduce呼び出しの数
+    * ネスト深度
+        * 制御構文の最大ネスト深度
+    """
+
+    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
+    max_nesting_depth: int
+
+
+class Algorithm(AbstractAnalysis[AlgorithmAnalysisResult, AlgorithmAnalysisConfig]):
+    """解析クラス(アルゴリズム)"""
+
+    def __init__(self, config: AlgorithmAnalysisConfig | None = None) -> None:
+        """コンストラクタ"""
+        super().__init__(config)
+
+    def get_default_config(self) -> AlgorithmAnalysisConfig:
+        """デフォルト設定を取得"""
+        return AlgorithmAnalysisConfig()
+
+    def analyze(self, source_code: str) -> AlgorithmAnalysisResult:
+        """コード解析"""
+        if not self.config.enabled:
+            return AlgorithmAnalysisResult(
+                if_count=0,
+                for_count=0,
+                while_count=0,
+                try_count=0,
+                recursion_rate=0.0,
+                lambda_count=0,
+                comprehension_count=0,
+                functional_call_count=0,
+                max_nesting_depth=0,
+            )
+
+        tree = self.parse_source_code(source_code)
+
+        return AlgorithmAnalysisResult(
+            if_count=self.get_if_count(source_code, tree),
+            for_count=self.get_for_count(source_code, tree),
+            while_count=self.get_while_count(source_code, tree),
+            try_count=self.get_try_count(source_code, tree),
+            recursion_rate=self.get_recursion_rate(source_code, tree),
+            lambda_count=self.get_lambda_count(source_code, tree),
+            comprehension_count=self.get_comprehension_count(source_code, tree),
+            functional_call_count=self.get_functional_call_count(source_code, tree),
+            max_nesting_depth=self.get_max_nesting_depth(source_code, tree),
+        )
+
+    def parse_source_code(self, source_code: str) -> ast.AST:
+        """ソースコードを解析"""
+        return ast.parse(source_code)
+
+    def get_if_count(self, source_code: str, tree: ast.AST | None = None) -> int:
+        """if文の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None) -> int:
+        """for文の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None) -> int:
+        """while文の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None) -> int:
+        """try-except文の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None
+    ) -> float:
+        """再帰関数の割合を取得"""
+        tree = tree or 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, tree: ast.AST | None = None) -> int:
+        """lambda式の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None
+    ) -> int:
+        """内包表記の数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None
+    ) -> int:
+        """map/filter/reduce呼び出しの数を取得"""
+        tree = tree or 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, tree: ast.AST | None = None
+    ) -> float:
+        """循環的複雑度の平均を取得"""
+        tree = tree or 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, tree: ast.AST | None = None
+    ) -> int:
+        """制御構文の最大ネスト深度を取得"""
+        tree = tree or 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