gyomu-python-analysis 0.2.0__tar.gz → 0.3.0__tar.gz

{gyomu_python_analysis-0.2.0 → gyomu_python_analysis-0.3.0}/.gitignore

@@ -17,3 +17,13 @@ __pycache__/
 .ruff_cache/
 htmlcov/
 *.egg-info/
+log/
+
+
+# gyomu ai related
+**/.gyomu/cache
+**/.gyomu/snapshot
+**/.gyomu/checkpoint
+
+# snapshot
+__snapshots__

{gyomu_python_analysis-0.2.0 → gyomu_python_analysis-0.3.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.5
 Name: gyomu-python-analysis
-Version: 0.2.0
+Version: 0.3.0
 Summary: Gyomu Python Analysis
 Requires-Python: >=3.13
 Requires-Dist: docstring-parser>=0.18.0
 Requires-Dist: griffelib>=2.2.0
 Requires-Dist: gyomu-infra
 Requires-Dist: gyomu-schema
-Requires-Dist: returns>=0.29.0
+Requires-Dist: returns
 Description-Content-Type: text/markdown
 
 # gyomu-python-analysis

{gyomu_python_analysis-0.2.0 → gyomu_python_analysis-0.3.0}/pyproject.toml

@@ -7,7 +7,7 @@ requires-python = ">=3.13"
 dependencies = [
     "gyomu-schema",
     "gyomu-infra",
-    "returns>=0.29.0",
+    "returns",
     "griffelib>=2.2.0",
     "docstring-parser>=0.18.0",
 ]

gyomu_python_analysis-0.3.0/python_analysis_test_support/fixtures/src/analysis/docstring/15-custom-list-section.py

@@ -0,0 +1,7 @@
+def custom_list_section() -> None:
+    """Process something.
+
+    Attributes:
+        foo: Foo attribute.
+        bar: Bar attribute.
+    """

gyomu_python_analysis-0.3.0/python_analysis_test_support/fixtures/src/analysis/symbol/variable.py

@@ -0,0 +1,33 @@
+
+from typing import Annotated
+
+from pydantic import Field
+
+VERSION = 5
+VERSION_STR = "5"
+
+_internal_value = 10
+
+ANNOTATED: int
+
+Calculated = 2 + 3
+
+
+Confidence = Annotated[
+    float,
+    Field(
+        ge=0.0,
+        le=1.0,
+        description="AI decision confidence used for merge strategy routing",
+    ),
+]
+
+Confidence2 = Annotated[
+    float,
+    SomeMetadata(),
+    Field(
+        ge=0.0,
+        le=1.0,
+        description="AI decision confidence used for merge strategy routing",
+    ),
+]

gyomu_python_analysis-0.3.0/python_analysis_test_support/helpers.py

@@ -0,0 +1,341 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from griffe import Attribute, Class, Function, TypeAlias
+from gyomu_infra.logger import logger
+from gyomu_python_analysis.analysis.analyzers.cls import analyze_class
+from gyomu_python_analysis.analysis.analyzers.context import initialize_symbol_context
+from gyomu_python_analysis.analysis.analyzers.functions import analyze_function
+from gyomu_python_analysis.analysis.analyzers.type_alias import analyze_type_alias
+from gyomu_python_analysis.analysis.analyzers.variables import analyze_variable
+from gyomu_python_analysis.analysis.file.source_file_context import SourceFileContext
+from gyomu_python_analysis.analysis.initialize import initialize_project_context
+from gyomu_python_analysis.analysis.load import load_module
+from gyomu_python_analysis.analysis.load_module import load_module_analysis
+from gyomu_python_analysis.project.context import ProjectContext, PyProjectConfig
+from gyomu_schema.schemas.python.class_analysis import ClassAnalysis
+from gyomu_schema.schemas.python.function_analysis import FunctionAnalysis
+from gyomu_schema.schemas.python.module import ModuleAnalysis
+from gyomu_schema.schemas.python.symbol import SymbolAnalysis
+from gyomu_schema.schemas.python.type_alias import TypeAliasAnalysis
+from gyomu_schema.schemas.python.types import (
+    ProjectRelativePath,
+    PythonPath,
+    WorkspaceRelativePath,
+)
+from gyomu_schema.schemas.python.variable import VariableAnalysis
+from gyomu_schema.schemas.types import FullPath
+from returns.result import Failure
+
+TEST_SUPPORT_ROOT = FullPath(Path(__file__).parent)
+FIXTURES_ROOT = FullPath(Path(__file__).parent / "fixtures")
+MONOREPO_FIXTURES_ROOT = FullPath(Path(__file__).parent / "monorepo_fixtures")
+
+
+_default_project_config = PyProjectConfig(
+    path=WorkspaceRelativePath(Path(".")),
+    name="test",
+    version="0.1",
+    description=None,
+    formatter_line_length=88,
+)
+
+
+def _create_context() -> ProjectContext:
+    return initialize_project_context(
+        project_root=FIXTURES_ROOT, source_root=ProjectRelativePath(Path("src"))
+    ).unwrap()
+
+
+# def create_declaration_identity(id: str) -> DeclarationIdentity:
+#     return DeclarationIdentity(
+#         symbol_id=SymbolId(id),
+#         declaration_id=DeclarationId("."),
+#     )
+
+
+# def create_location(
+#     start_offset: int = 0,
+#     end_offset: int = 0,
+#     start_line: int = 1,
+#     start_column: int = 0,
+#     end_line: int = 1,
+#     end_column: int = 0,
+# ) -> SourceLocation:
+#     return SourceLocation(
+#         start_line=start_line,
+#         start_offset=start_offset,
+#         end_line=end_line,
+#         end_offset=end_offset,
+#         start_column=start_column,
+#         end_column=end_column,
+#     )
+
+
+# _default_identity = DeclarationIdentity(
+#     symbol_id=SymbolId("test.User"),
+#     declaration_id=DeclarationId("."),
+# )
+
+
+# def create_type_alias_analysis(
+#     indent: int,
+#     location: SourceLocation,
+#     name: str = "test_func",
+#     identity: DeclarationIdentity | None = None,
+# ) -> TypeAliasAnalysis:
+#     if identity is None:
+#         identity = create_declaration_identity(name)
+#     return TypeAliasAnalysis(
+#         name=name,
+#         docstring=None,
+#         identity=identity,
+#         decorators=tuple(),
+#         dependencies=tuple(),
+#         indent=indent,
+#         kind=DeclarationKind.TYPEALIAS,
+#         visibility=Visibility.PUBLIC,
+#         location=location,
+#         alias_type=None,
+#     )
+
+
+# def create_variable_analysis(
+#     indent: int,
+#     location: SourceLocation,
+#     name: str = "test_func",
+#     identity: DeclarationIdentity | None = None,
+# ) -> VariableAnalysis:
+#     if identity is None:
+#         identity = create_declaration_identity(name)
+#     return VariableAnalysis(
+#         name=name,
+#         docstring=None,
+#         identity=identity,
+#         decorators=tuple(),
+#         dependencies=tuple(),
+#         indent=indent,
+#         kind=DeclarationKind.VARIABLE,
+#         visibility=Visibility.PUBLIC,
+#         location=location,
+#         type=None,
+#         value_source=None,
+#         value_expression=None,
+#         pydantic=None,
+#     )
+
+
+# def create_function_analysis(
+#     indent: int,
+#     location: SourceLocation,
+#     name: str = "test_func",
+#     identity: DeclarationIdentity | None = None,
+# ) -> FunctionAnalysis:
+#     if identity is None:
+#         identity = create_declaration_identity(name)
+#     return FunctionAnalysis(
+#         name=name,
+#         docstring=None,
+#         identity=identity,
+#         decorators=tuple(),
+#         dependencies=tuple(),
+#         indent=indent,
+#         is_async=False,
+#         kind=DeclarationKind.FUNCTION,
+#         parameters=tuple(),
+#         return_type=None,
+#         visibility=Visibility.PUBLIC,
+#         location=location,
+#     )
+
+
+# def create_method_analysis(
+#     indent: int | None,
+#     location: SourceLocation | None,
+#     name: str = "test_func",
+#     identity: DeclarationIdentity | None = None,
+# ) -> MethodAnalysis:
+#     if identity is None:
+#         identity = create_declaration_identity(name)
+#     return MethodAnalysis(
+#         name=name,
+#         docstring=None,
+#         identity=identity,
+#         decorators=tuple(),
+#         indent=indent,
+#         is_async=False,
+#         kind=DeclarationKind.METHOD,
+#         parameters=tuple(),
+#         return_type=None,
+#         visibility=Visibility.PUBLIC,
+#         location=location,
+#     )
+
+
+# def create_class_analysis(
+#     indent: int,
+#     location: SourceLocation,
+#     name: str = "test_class",
+#     identity: DeclarationIdentity | None = None,
+# ) -> ClassAnalysis:
+#     if identity is None:
+#         identity = create_declaration_identity(name)
+#     return ClassAnalysis(
+#         name=name,
+#         docstring=None,
+#         identity=identity,
+#         decorators=tuple(),
+#         dependencies=tuple(),
+#         indent=indent,
+#         kind=DeclarationKind.CLASS,
+#         bases=tuple(),
+#         visibility=Visibility.PUBLIC,
+#         location=location,
+#         methods=tuple(),
+#         variables=tuple(),
+#         type_aliases=tuple(),
+#         inner_classes=tuple(),
+#     )
+
+
+# def create_file_analysis_context(
+#     symbol: SymbolAnalysis | MemberAnalysis | None = None,
+#     symbol2: SymbolAnalysis | MemberAnalysis | None = None,
+#     symbol3: SymbolAnalysis | MemberAnalysis | None = None,
+# ) -> FileAnalysisContext:
+#     symbols: dict[DeclarationIdentity, SymbolAnalysis | MemberAnalysis]
+#     symbols = dict([(symbol.identity, symbol)]) if symbol else dict()
+
+#     if symbol2:
+#         symbols[symbol2.identity] = symbol2
+#     if symbol3:
+#         symbols[symbol3.identity] = symbol3
+#     return FileAnalysisContext(
+#         metadata=FileAnalysisMetadata(parsed_docstring=dict(), symbols=symbols),
+#         analysis=ModuleAnalysis(
+#             path=SourceRelativePath(Path(".")),
+#             name="test",
+#             module_name=PythonPath(""),
+#             docstring=None,
+#             imports=tuple(),
+#             symbols=(),
+#         ),
+#     )
+
+
+@dataclass
+class BaseContext:
+    project: ProjectContext
+    source: SourceFileContext
+
+
+class AnalysisTestBase:
+    def _analyze_module_base(self, file_name: PythonPath) -> ModuleAnalysis:
+        context = self._read_module_fixture(file_name)
+        result = load_module_analysis(context.project, file_name)
+        if isinstance(result, Failure):
+            raise result.failure()
+
+        return result.unwrap()
+
+    def _analyze_typealias_bases(
+        self, file_name: PythonPath, symbol_name: str, dump_required: bool = False
+    ) -> TypeAliasAnalysis:
+        symbol, source_lines = self._analyze_symbol(
+            file_name, symbol_name, dump_required
+        )
+        assert isinstance(symbol, TypeAlias)
+        return analyze_type_alias(
+            alias=symbol,
+            name=symbol_name,
+            context=initialize_symbol_context(
+                module_name=file_name, name=symbol_name, source_lines=source_lines
+            ),
+        )
+
+    def _analyze_function_base(
+        self, file_name: PythonPath, symbol_name: str, dump_required: bool = False
+    ) -> FunctionAnalysis:
+        symbol, source_lines = self._analyze_symbol(
+            file_name, symbol_name, dump_required
+        )
+        assert isinstance(symbol, Function)
+        return analyze_function(
+            func=symbol,
+            name=symbol_name,
+            context=initialize_symbol_context(
+                module_name=file_name, name=symbol_name, source_lines=source_lines
+            ),
+        )
+
+    def _analyze_variable_base(
+        self, file_name: PythonPath, symbol_name: str, dump_required: bool = False
+    ) -> VariableAnalysis:
+        symbol, source_lines = self._analyze_symbol(
+            file_name, symbol_name, dump_required
+        )
+        assert isinstance(symbol, Attribute)
+        return analyze_variable(
+            variable=symbol,
+            name=symbol_name,
+            context=initialize_symbol_context(
+                module_name=file_name, name=symbol_name, source_lines=source_lines
+            ),
+        )
+
+    def _analyze_class_base(
+        self, file_name: PythonPath, symbol_name: str, dump_required: bool = False
+    ) -> ClassAnalysis:
+        symbol, source_lines = self._analyze_symbol(
+            file_name, symbol_name, dump_required
+        )
+        assert isinstance(symbol, Class)
+        return analyze_class(
+            cls=symbol,
+            name=symbol_name,
+            context=initialize_symbol_context(
+                module_name=file_name, name=symbol_name, source_lines=source_lines
+            ),
+        )
+
+    def _analyze_symbol(
+        self, file_name: PythonPath, symbol_name: str, dump_required: bool = False
+    ) -> tuple[SymbolAnalysis, list[str]]:
+        module_name = file_name
+        context = self._read_module_fixture(module_name)
+        module = context.source.module
+        symbol = module[symbol_name]
+
+        if dump_required:
+            logger.info(symbol.as_dict())
+
+        source_full_path = (
+            context.project.project_root
+            / context.project.source_root
+            / context.source.path
+        )
+        source_lines = source_full_path.read_text(
+            encoding="utf-8",
+        ).splitlines(keepends=True)
+
+        return symbol, source_lines
+
+    def _read_module_fixture(self, module_path: PythonPath) -> BaseContext:
+        context = _create_context()
+        # search_path = context.project_root / context.source_root
+        # print("search:", search_path)
+        # print("modulePath:", modulePath)
+
+        # loader = GriffeLoader(
+        #     search_paths=[search_path],
+        # )
+        # module = loader.load(modulePath)
+        # if isinstance(module, Module):
+        #     print("location:", module.filepath)
+        #     return module
+        # raise ValueError("Invalid:")
+        result = load_module(context, module_path)
+
+        source_file_context = result.unwrap()
+
+        return BaseContext(project=context, source=source_file_context)

gyomu_python_analysis-0.3.0/python_analysis_test_support/monorepo_fixtures/packages/project_a/pyproject.toml

@@ -0,0 +1,4 @@
+[project]
+name = "project-a"
+version = "0.1.0"
+description = "Project A"

gyomu_python_analysis-0.3.0/python_analysis_test_support/monorepo_fixtures/packages/project_a/src/project_a/module.py

@@ -0,0 +1 @@
+VERSION = "1.0"

gyomu_python_analysis-0.3.0/python_analysis_test_support/monorepo_fixtures/packages/project_b/pyproject.toml

@@ -0,0 +1,4 @@
+[project]
+name = "project-b"
+version = "0.1.0"
+description = "Project B"

gyomu_python_analysis-0.3.0/python_analysis_test_support/monorepo_fixtures/packages/project_b/src/project_b/module.py

@@ -0,0 +1 @@
+VERSION = "1.1"

gyomu_python_analysis-0.3.0/python_analysis_test_support/monorepo_fixtures/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "test-monorepo"
+version = "0.1.0"
+
+[tool.uv.workspace]
+members = [
+    "packages/project_a",
+    "packages/project_b",
+]