gyomu-python-analysis 0.2.0__py3-none-any.whl

gyomu_python_analysis/analysis/analyzers/expression/name.py

@@ -0,0 +1,38 @@
+# from griffe import ExprName
+# from gyomu_schema.schemas.python.type.structure import (
+#     NameStructureAnalysis,
+#     NoneStructureAnalysis,
+#     TypeStructureKind,
+# )
+
+# from gyomu_python_analysis.analysis.analyzers.context import SymbolContext
+# from gyomu_python_analysis.analysis.analyzers.dependency import register_dependency
+
+
+# def analyze_expression_name(
+#     expression: ExprName,
+#     context: SymbolContext,
+#     need_registration_dependency: bool,
+# ) -> NameStructureAnalysis | NoneStructureAnalysis:
+#     # print(
+#     #     dict(
+#     #         name=expression.name,
+#     #         member=expression.member,
+#     #         path=expression.path,
+#     #         canonical_name=expression.canonical_name,
+#     #         is_enum_class=expression.is_enum_class,
+#     #         is_enum_instance=expression.is_enum_instance,
+#     #         is_enum_value=expression.is_enum_value,
+#     #         is_type_parameter=expression.is_type_parameter,
+#     #     )
+#     # )
+
+#     if expression.name == "None":
+#         return NoneStructureAnalysis(
+#             kind=TypeStructureKind.NONE,
+#         )
+#     if need_registration_dependency:
+#         register_dependency(context.declaration, expression.name, context)
+#     return NameStructureAnalysis(
+#         name=expression.name,
+#     )

gyomu_python_analysis/analysis/analyzers/functions.py

@@ -0,0 +1,53 @@
+from griffe import Function
+from griffe import ParameterKind as GriffeParameterKind
+from gyomu_schema.schemas.python.function_analysis import FunctionAnalysis
+from gyomu_schema.schemas.python.parameter import ParameterAnalysis, ParameterKind
+
+from gyomu_python_analysis.analysis.analyzers.context import (
+    SymbolContext,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.common import build_symbol_common
+from gyomu_python_analysis.analysis.analyzers.types import analyze_type
+
+
+def _get_function_parameter_kind(kind: GriffeParameterKind | None) -> ParameterKind:
+    match kind:
+        case GriffeParameterKind.keyword_only:
+            return ParameterKind.KEYWORD_ONLY
+        case GriffeParameterKind.positional_only:
+            return ParameterKind.POSITIONAL_ONLY
+        case GriffeParameterKind.positional_or_keyword:
+            return ParameterKind.POSITIONAL_OR_KEYWORD
+        case GriffeParameterKind.var_keyword:
+            return ParameterKind.VAR_KEYWORD
+        case GriffeParameterKind.var_positional:
+            return ParameterKind.VAR_POSITIONAL
+    raise ValueError(f"Invalid Parameter Kind: {str(kind)}")
+
+
+def analyze_function(
+    func: Function, name: str, context: SymbolContext
+) -> FunctionAnalysis:
+    for dec in func.decorators:
+        print(dec.as_dict())
+    parameters: list[ParameterAnalysis] = []
+    for param in func.parameters:
+        parameters.append(
+            ParameterAnalysis(
+                name=param.name,
+                kind=_get_function_parameter_kind(param.kind),
+                type=analyze_type(param.annotation, context),
+                default=None,
+            )
+        )
+    # pprint(func.as_dict())
+    func_common = build_symbol_common(symbol=func, name=name, context=context)
+    return_type = analyze_type(func.returns, context)
+    return FunctionAnalysis(
+        **func_common,
+        dependencies=tuple([]),
+        parameters=tuple(parameters),
+        is_async="async" in func.labels,
+        return_type=return_type,
+        identity=context.declaration,
+    )

gyomu_python_analysis/analysis/analyzers/imports.py

@@ -0,0 +1,21 @@
+from griffe import Alias
+from gyomu_schema.schemas.python.import_analysis import ImportAnalysis, ImportKind
+
+
+def analyze_import(
+    alias: Alias,
+    name: str,
+    source_lines: list[str],
+) -> ImportAnalysis:
+    target_path = alias.target_path
+    attr = alias.as_dict()
+    print(attr)
+    # print(f"path: {alias.path}")
+    # print(f"target-path: {alias.target_path}")
+    # print(f"canonical_path: {alias.canonical_path}")
+    assert attr["lineno"]
+    target_line = source_lines[int(attr["lineno"]) - 1]
+    kind = ImportKind.MODULE
+    if target_line.strip().startswith("from"):
+        kind = ImportKind.SYMBOL
+    return ImportAnalysis(imported_name=target_path, local_name=name, kind=kind)

gyomu_python_analysis/analysis/analyzers/internal/common.py

@@ -0,0 +1,87 @@
+from griffe import Class, Docstring, Function, Object
+from gyomu_schema.schemas.python.decorator import DecoratorAnalysis
+from gyomu_schema.schemas.python.docstring import DocstringCommon
+from gyomu_schema.schemas.python.location import SourceLocation
+from gyomu_schema.schemas.python.symbol_base import MemberCommon, SymbolCommon
+
+from gyomu_python_analysis.analysis.analyzers.context import SymbolContext
+from gyomu_python_analysis.analysis.analyzers.decorator import analyze_decorators
+from gyomu_python_analysis.analysis.analyzers.docstring import analyze_docstring
+from gyomu_python_analysis.analysis.analyzers.internal.location import (
+    calculate_docstring_location,
+    calculate_member_location,
+    calculate_symbol_location,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.visibility import (
+    calculate_visibility,
+)
+
+
+def build_symbol_common(
+    symbol: Object,
+    name: str,
+    context: SymbolContext,
+) -> SymbolCommon:
+    location = calculate_symbol_location(symbol=symbol, context=context)
+    docstring = (
+        analyze_docstring(
+            symbol.docstring,
+            doc_common=build_docstring_common(symbol.docstring, context=context),
+            context=context,
+        )
+        if symbol.docstring is not None
+        else None
+    )
+    decorators: list[DecoratorAnalysis] = []
+    if isinstance(symbol, Class | Function):
+        decorators = analyze_decorators(symbol.decorators, context=context)
+    return {
+        "name": name,
+        "location": location,
+        "visibility": calculate_visibility(name),
+        "indent": location.start_column,
+        "docstring": docstring,
+        "decorators": tuple(decorators),
+    }
+
+
+def build_member_common(
+    symbol: Object,
+    name: str,
+    context: SymbolContext,
+    parent_location: SourceLocation | None = None,
+) -> MemberCommon:
+    location = calculate_member_location(
+        symbol=symbol,
+        context=context,
+        parent_location=parent_location,
+    )
+    docstring = (
+        analyze_docstring(
+            symbol.docstring,
+            doc_common=build_docstring_common(symbol.docstring, context=context),
+            context=context,
+        )
+        if symbol.docstring is not None
+        else None
+    )
+    decorators: list[DecoratorAnalysis] = []
+    if isinstance(symbol, Function):
+        decorators = analyze_decorators(symbol.decorators, context=context)
+
+    return {
+        "name": name,
+        "location": location,
+        "visibility": calculate_visibility(name),
+        "indent": location.start_column if location is not None else None,
+        "docstring": docstring,
+        "decorators": tuple(decorators),
+    }
+
+
+def build_docstring_common(doc: Docstring, context: SymbolContext) -> DocstringCommon:
+    location = calculate_docstring_location(doc=doc, context=context)
+    return {
+        "location": location,
+        "indent": location.start_column,
+    }

gyomu_python_analysis/analysis/analyzers/internal/location.py

@@ -0,0 +1,68 @@
+from griffe import Decorator, Docstring, Object
+from gyomu_schema.schemas.python.location import SourceLocation
+
+from gyomu_python_analysis.analysis.analyzers.context import SymbolContext
+
+
+def _calculate_location(
+    target: Object | Docstring | Decorator, context: SymbolContext
+) -> SourceLocation:
+    # source_full_path = project.project_root / project.source_root / source_file.path
+    start_line_no = target.lineno
+    end_line_no = target.endlineno
+
+    assert start_line_no is not None
+    assert end_line_no is not None
+
+    start_line = context.source_lines[start_line_no - 1]
+    end_line = context.source_lines[end_line_no - 1]
+
+    start_column = len(start_line) - len(start_line.lstrip())
+    end_column = len(end_line.rstrip())
+
+    start_offset = context.line_start_offsets[start_line_no - 1] + start_column
+    end_offset = context.line_start_offsets[end_line_no - 1] + end_column
+
+    return SourceLocation(
+        start_line=start_line_no,
+        start_column=start_column,
+        end_line=end_line_no,
+        end_column=end_column,
+        start_offset=start_offset,
+        end_offset=end_offset,
+    )
+
+
+def calculate_symbol_location(
+    symbol: Object,
+    context: SymbolContext,
+) -> SourceLocation:
+    return _calculate_location(symbol, context)
+
+
+def calculate_member_location(
+    symbol: Object,
+    context: SymbolContext,
+    parent_location: SourceLocation | None,
+) -> SourceLocation | None:
+    location = calculate_symbol_location(symbol=symbol, context=context)
+    if parent_location is not None and (
+        location.start_line >= parent_location.start_line
+        and location.end_line <= parent_location.end_line
+    ):
+        return None
+    return location
+
+
+def calculate_docstring_location(
+    doc: Docstring,
+    context: SymbolContext,
+) -> SourceLocation:
+    return _calculate_location(target=doc, context=context)
+
+
+def calculate_decorator_location(
+    decorator: Decorator,
+    context: SymbolContext,
+) -> SourceLocation:
+    return _calculate_location(target=decorator, context=context)

gyomu_python_analysis/analysis/analyzers/internal/visibility.py

@@ -0,0 +1,27 @@
+from gyomu_schema.schemas.python.visibility import Visibility
+
+_SPECIAL_NAMES = frozenset(
+    {
+        "__all__",
+        "__annotations__",
+        "__builtins__",
+        "__cached__",
+        "__doc__",
+        "__file__",
+        "__loader__",
+        "__name__",
+        "__package__",
+        "__path__",
+        "__spec__",
+    }
+)
+
+
+def calculate_visibility(name: str) -> Visibility:
+    if name in _SPECIAL_NAMES:
+        return Visibility.SPECIAL
+
+    if name.startswith("_"):
+        return Visibility.PRIVATE
+
+    return Visibility.PUBLIC

gyomu_python_analysis/analysis/analyzers/pydantic.py

@@ -0,0 +1,62 @@
+from gyomu_schema.schemas.python.pydantic import PydanticFieldAnalysis
+from gyomu_schema.schemas.python.type.structure import (
+    LiteralValue,
+    NameStructureAnalysis,
+    NoneStructureAnalysis,
+)
+from gyomu_schema.schemas.python.type.type_analysis import (
+    CallStructureAnalysis,
+    ExpressionAnalysis,
+    KeywordStructureAnalysis,
+    TypeExpression,
+    UnionStructureAnalysis,
+)
+
+
+def _is_field_required(field_type: ExpressionAnalysis) -> bool:
+    if isinstance(field_type, NoneStructureAnalysis):
+        return False
+    if isinstance(field_type, UnionStructureAnalysis):
+        for element in field_type.types:
+            if isinstance(element, NoneStructureAnalysis):
+                return False
+    return True
+
+
+def retrieve_str_value(value: TypeExpression) -> str | None:
+    if isinstance(value, LiteralValue):
+        return str(value.value)
+    return None
+
+
+def analyze_pydantic(
+    field_type: ExpressionAnalysis, expression: TypeExpression
+) -> PydanticFieldAnalysis | None:
+    is_required = _is_field_required(field_type)
+
+    if (
+        isinstance(expression, CallStructureAnalysis)
+        and isinstance(expression.function, NameStructureAnalysis)
+        and expression.function.name == "Field"
+    ):
+        description = None
+        alias = None
+        default = None
+        for argument in expression.arguments:
+            if isinstance(argument, KeywordStructureAnalysis):
+                match argument.name:
+                    case "description":
+                        description = retrieve_str_value(argument.value)
+
+                    case "alias":
+                        alias = retrieve_str_value(argument.value)
+            else:
+                default = retrieve_str_value(argument)
+
+        return PydanticFieldAnalysis(
+            required=is_required,
+            description=description,
+            alias=alias,
+            default_source=default,
+        )
+    return None

gyomu_python_analysis/analysis/analyzers/type_alias.py

@@ -0,0 +1,24 @@
+from griffe import TypeAlias
+from gyomu_schema.schemas.python.type_alias import TypeAliasAnalysis
+
+from gyomu_python_analysis.analysis.analyzers.context import (
+    MemberPath,
+    SymbolContext,
+    build_declaration_identity,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.common import build_symbol_common
+from gyomu_python_analysis.analysis.analyzers.types import analyze_type
+
+
+def analyze_type_alias(
+    alias: TypeAlias, name: str, context: SymbolContext
+) -> TypeAliasAnalysis:
+    member_path: MemberPath = ()
+    alias_common = build_symbol_common(symbol=alias, name=name, context=context)
+    type = analyze_type(alias.value, context)
+    return TypeAliasAnalysis(
+        **alias_common,
+        dependencies=tuple(),
+        alias_type=type,
+        identity=build_declaration_identity(context, member_path),
+    )

gyomu_python_analysis/analysis/analyzers/types.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from griffe import Expr
+from gyomu_schema.schemas.python.type.structure import NoneStructureAnalysis
+from gyomu_schema.schemas.python.type.type_analysis import (
+    TypeAnalysis,
+)
+
+from gyomu_python_analysis.analysis.analyzers.context import SymbolContext
+from gyomu_python_analysis.analysis.analyzers.expression.expr import analyze_expression
+
+
+def analyze_type(
+    annotation: str | Expr | None, context: SymbolContext
+) -> TypeAnalysis | None:
+    if annotation is None:
+        return None
+    if isinstance(annotation, str):
+        # print(annotation)
+        if annotation == "None":
+            return TypeAnalysis(text=annotation, structure=NoneStructureAnalysis())
+        return TypeAnalysis(text=annotation)
+    if isinstance(annotation, Expr):
+        text = str(annotation)
+        print(annotation.as_dict())
+        return TypeAnalysis(
+            text=text, structure=analyze_expression(annotation, context)
+        )
+    raise ValueError(f"Unsupported annotation type: {type(annotation)}")

gyomu_python_analysis/analysis/analyzers/variables.py

@@ -0,0 +1,22 @@
+from griffe import Attribute
+from gyomu_schema.schemas.python.variable import VariableAnalysis
+
+from gyomu_python_analysis.analysis.analyzers.context import (
+    SymbolContext,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.common import build_symbol_common
+from gyomu_python_analysis.analysis.analyzers.types import analyze_type
+
+
+def analyze_variable(
+    variable: Attribute, name: str, context: SymbolContext
+) -> VariableAnalysis:
+    variable_common = build_symbol_common(symbol=variable, name=name, context=context)
+    type = analyze_type(variable.annotation, context)
+    return VariableAnalysis(
+        **variable_common,
+        dependencies=tuple(),
+        type=type,
+        value_source=str(variable.value) if variable.value is not None else None,
+        identity=context.declaration,
+    )

gyomu_python_analysis/analysis/extract/symbols.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+
+from griffe import Alias, Attribute, Class, Function, Module, TypeAlias
+from gyomu_infra.logger import logger
+from gyomu_schema.schemas.python.import_analysis import ImportAnalysis
+from gyomu_schema.schemas.python.symbol import SymbolAnalysis
+from gyomu_schema.schemas.python.types import (
+    PythonPath,
+)
+
+from gyomu_python_analysis.analysis.analyzers.cls import analyze_class
+from gyomu_python_analysis.analysis.analyzers.context import (
+    DependencyInformation,
+    initialize_symbol_context,
+)
+from gyomu_python_analysis.analysis.analyzers.dependency import (
+    resolve_dependencies,
+)
+from gyomu_python_analysis.analysis.analyzers.functions import analyze_function
+from gyomu_python_analysis.analysis.analyzers.imports import analyze_import
+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
+
+
+@dataclass
+class SymbolExtractContext:
+    imported: tuple[ImportAnalysis, ...]
+    symbols: tuple[SymbolAnalysis, ...]
+
+
+def extract_symbols(
+    source_file: SourceFileContext,
+    source_lines: list[str],
+) -> SymbolExtractContext:
+    imported: list[ImportAnalysis] = _extract_imports(source_file.module, source_lines)
+    symbols: list[SymbolAnalysis] = _extract_symbols_internal(
+        source_file, source_lines, imported
+    )
+    # for symbol_name, value in module.members.items():
+    #     if isinstance(value, Alias):
+    return SymbolExtractContext(imported=tuple(imported), symbols=tuple(symbols))
+
+
+def _extract_imports(
+    module: Module,
+    source_lines: list[str],
+) -> list[ImportAnalysis]:
+    imported: list[ImportAnalysis] = []
+    for symbol_name, value in module.members.items():
+        if isinstance(value, Alias):
+            imported.append(analyze_import(value, symbol_name, source_lines))
+    return imported
+
+
+def _extract_symbols_internal(
+    source_file: SourceFileContext,
+    source_lines: list[str],
+    imported: list[ImportAnalysis],
+) -> list[SymbolAnalysis]:
+    symbols: list[SymbolAnalysis] = []
+    dependencies: list[DependencyInformation] = []
+    module_name: PythonPath = PythonPath(source_file.module.path)
+    logger.info(f"module_name:{module_name}")
+    for symbol_name, symbol in source_file.module.members.items():
+        if isinstance(symbol, Alias):
+            continue
+        # pprint(f"Extracting symbol: {symbol_name} ({type(symbol)})")
+        # pprint(symbol.as_dict())
+        context = initialize_symbol_context(
+            module_name=module_name, name=symbol_name, source_lines=source_lines
+        )
+        if isinstance(symbol, Attribute):
+            symbols.append(
+                analyze_variable(
+                    variable=symbol,
+                    name=symbol_name,
+                    context=context,
+                )
+            )
+        elif isinstance(symbol, Function):
+            symbols.append(
+                analyze_function(
+                    func=symbol,
+                    name=symbol_name,
+                    context=context,
+                )
+            )
+        elif isinstance(symbol, Class):
+            symbols.append(
+                analyze_class(
+                    cls=symbol,
+                    name=symbol_name,
+                    context=context,
+                )
+            )
+
+        elif isinstance(symbol, TypeAlias):
+            symbols.append(
+                analyze_type_alias(
+                    alias=symbol,
+                    name=symbol_name,
+                    context=context,
+                )
+            )
+        for item in context.dependencies:
+            dependencies.append(item)
+
+    dependency_map = resolve_dependencies(dependencies, imported, symbols)
+
+    symbols_by_identity = {symbol.identity: symbol for symbol in symbols}
+    for identity, dependency_list in dependency_map.items():
+        source_symbol = symbols_by_identity.get(identity)
+        if source_symbol is None:
+            raise ValueError(f"Unexpected Error. Should not happen. {repr(identity)}")
+        source_symbol.dependencies = dependency_list
+
+    return symbols

gyomu_python_analysis/analysis/file/source_file_context.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from griffe import Module
+from gyomu_schema.schemas.python.types import SourceRelativePath
+
+
+@dataclass(frozen=True)
+class SourceFileContext:
+    module: Module
+    path: SourceRelativePath

gyomu_python_analysis/analysis/get_module.py

@@ -0,0 +1,55 @@
+from gyomu_infra.filesystem.file_io import read_json, write_json
+from gyomu_infra.logger import logger
+from gyomu_schema.schemas.python.module import ModuleAnalysis
+from gyomu_schema.schemas.python.types import ProjectRelativePath
+from gyomu_schema.schemas.types import FullPath
+from returns.result import Failure, Result, Success
+
+from gyomu_python_analysis.analysis.load_module import load_module_analysis
+from gyomu_python_analysis.error.analysis import AnalysisError
+from gyomu_python_analysis.path.conversion import (
+    project_relative_path_to_source_relative_path,
+    source_relative_path_to_python_path,
+)
+from gyomu_python_analysis.project.context import ProjectContext
+
+
+def get_module_analysis(
+    context: ProjectContext, file_path: ProjectRelativePath
+) -> Result[ModuleAnalysis, AnalysisError]:
+    cache_path = _get_cache_path(context, file_path)
+    if cache_path.exists():
+        cache_result = read_json(cache_path, ModuleAnalysis)
+        if isinstance(cache_result, Success):
+            return cache_result
+        else:
+            message = (
+                f"fail to parse ModuleAnalysis on {cache_path}, \n"
+                f"error: {repr(cache_result.failure())}"
+            )
+            logger.error(message)
+
+    source_relative_path = project_relative_path_to_source_relative_path(
+        path=file_path, context=context
+    )
+    module_path = source_relative_path_to_python_path(path=source_relative_path)
+    result = load_module_analysis(context, module_path)
+    if isinstance(result, Success):
+        write_result = write_json(cache_path, result.unwrap())
+        if isinstance(write_result, Failure):
+            return Failure(
+                AnalysisError(
+                    "fail to write ModuleAnalysis",
+                    file_path=module_path,
+                    phase="post-analysis",
+                ).chain(write_result.failure())
+            )
+
+    return result
+
+
+def _get_cache_path(
+    context: ProjectContext, source_path: ProjectRelativePath
+) -> FullPath:
+    cache_root = context.project_root / ".gyomu" / "cache"
+    return cache_root / f"{source_path}.json"

gyomu_python_analysis/analysis/load.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from griffe import Module
+from gyomu_schema.schemas.python.types import PythonPath, SourceRelativePath
+from gyomu_schema.utility.returns import from_sync
+from returns.result import Result
+
+from gyomu_python_analysis.analysis.file.source_file_context import SourceFileContext
+from gyomu_python_analysis.error.analysis import AnalysisError
+from gyomu_python_analysis.project.context import ProjectContext
+
+
+def load_module(
+    context: ProjectContext, module_path: PythonPath
+) -> Result[SourceFileContext, AnalysisError]:
+
+    def load_griffe() -> SourceFileContext:
+
+        module = context.loader.load(module_path)
+        if not isinstance(module, Module):
+            raise ValueError(f"Invalid Module Path: {module_path}")
+        full_path = module.filepath
+        if not isinstance(full_path, Path):
+            raise ValueError(f"module full path is Not Path: {full_path}")
+        source_path = full_path.relative_to(context.project_root / context.source_root)
+        return SourceFileContext(module=module, path=SourceRelativePath(source_path))
+
+    return from_sync(
+        load_griffe,
+        build_error=lambda e: AnalysisError(
+            message="fail to load source",
+            file_path=module_path,
+            phase="source-file-load",
+            context="gyomu_python_analysis.analysis.load_sourde_file",
+        ).chain(e),
+    )
+
+
+# def _get_module_name(
+#     source_file_path: SourceRelativePath,
+# ) -> str:
+#     return source_file_path.with_suffix("").as_posix().replace("/", ".")