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

gyomu_python_analysis/analysis/analyzers/cls.py

@@ -0,0 +1,343 @@
+from griffe import Attribute, Class, Function, TypeAlias
+from gyomu_infra.logger import logger
+from gyomu_schema.schemas.python.class_analysis import (
+    ClassAnalysis,
+    ClassCommon,
+    ClassTypeAliasAnalysis,
+    ClassVariableAnalysis,
+    InnerClassAnalysis,
+)
+from gyomu_schema.schemas.python.location import SourceLocation
+from gyomu_schema.schemas.python.method_analysis import MethodAnalysis
+from gyomu_schema.schemas.python.parameter import ParameterAnalysis
+from gyomu_schema.schemas.python.pydantic import PydanticFieldAnalysis
+from gyomu_schema.schemas.python.type.structure import NameStructureAnalysis
+from gyomu_schema.schemas.python.type.type_analysis import TypeAnalysis
+
+from gyomu_python_analysis.analysis.analyzers.context import (
+    MemberPath,
+    SymbolContext,
+    build_declaration_identity,
+)
+from gyomu_python_analysis.analysis.analyzers.expression.expr import (
+    analyze_type_expression,
+)
+from gyomu_python_analysis.analysis.analyzers.functions import (
+    _get_function_parameter_kind,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.common import (
+    build_member_common,
+    build_symbol_common,
+)
+from gyomu_python_analysis.analysis.analyzers.pydantic import analyze_pydantic
+from gyomu_python_analysis.analysis.analyzers.types import analyze_type
+
+
+def _retrieve_constructor_location(
+    cls: Class,
+    context: SymbolContext,
+) -> SourceLocation | None:
+    constructor_location: SourceLocation | None = None
+    if "__init__" in cls.members:
+        init_member = cls.members["__init__"]
+        if isinstance(init_member, Function):
+            constructor_common = build_member_common(
+                symbol=init_member,
+                name="__init__",
+                parent_location=None,
+                context=context,
+            )
+            constructor_location = constructor_common["location"]
+    return constructor_location
+
+
+def _build_class_type_aliases(
+    cls: Class,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> list[ClassTypeAliasAnalysis]:
+    aliases: list[ClassTypeAliasAnalysis] = []
+    for member_name, member in cls.members.items():
+        if isinstance(member, TypeAlias):
+            aliases.append(
+                _build_class_type_alias_analysis(
+                    member=member,
+                    name=member_name,
+                    parent_location=parent_location,
+                    context=context,
+                    member_path=member_path,
+                )
+            )
+    return aliases
+
+
+def _build_class_type_alias_analysis(
+    member: TypeAlias,
+    name: str,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> ClassTypeAliasAnalysis:
+    new_member_path = (*member_path, name)
+    alias_common = build_member_common(
+        symbol=member,
+        name=name,
+        parent_location=parent_location,
+        context=context,
+    )
+    return ClassTypeAliasAnalysis(
+        **alias_common,
+        alias_type=analyze_type(member.value, context),
+        identity=build_declaration_identity(
+            context=context, member_path=new_member_path
+        ),
+    )
+
+
+def _build_class_variables(
+    cls: Class,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+    is_pydantic_base_class: bool,
+) -> list[ClassVariableAnalysis]:
+    variables: list[ClassVariableAnalysis] = []
+    for member_name, member in cls.members.items():
+        if isinstance(member, Attribute):
+            variables.append(
+                _build_class_variable_analysis(
+                    member=member,
+                    name=member_name,
+                    parent_location=parent_location,
+                    context=context,
+                    member_path=member_path,
+                    is_pydantic_base_class=is_pydantic_base_class,
+                )
+            )
+    return variables
+
+
+def _build_class_variable_analysis(
+    member: Attribute,
+    name: str,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+    is_pydantic_base_class: bool,
+) -> ClassVariableAnalysis:
+    new_member_path = (*member_path, name)
+    variable_common = build_member_common(
+        symbol=member,
+        name=name,
+        parent_location=parent_location,
+        context=context,
+    )
+    variable_type = analyze_type(member.annotation, context)
+    value_expression = (
+        analyze_type_expression(member.value, context)
+        if member.value is not None
+        else None
+    )
+    pydantic: PydanticFieldAnalysis | None = None
+    logger.info(f"pydantic_base:{is_pydantic_base_class}")
+    if (
+        value_expression
+        and variable_type
+        and variable_type.structure
+        and is_pydantic_base_class
+    ):
+        print(repr(variable_type.structure))
+        print(repr(value_expression))
+        pydantic = analyze_pydantic(variable_type.structure, value_expression)
+
+    return ClassVariableAnalysis(
+        **variable_common,
+        type=variable_type,
+        value_source=str(member.value) if member.value is not None else None,
+        value_expression=analyze_type_expression(member.value, context)
+        if member.value is not None
+        else None,
+        pydantic=pydantic,
+        identity=build_declaration_identity(
+            context=context, member_path=new_member_path
+        ),
+    )
+
+
+def _build_class_method_analysis(
+    member: Function,
+    name: str,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> MethodAnalysis:
+    new_member_path = (*member_path, name)
+    method_parameters: list[ParameterAnalysis] = []
+    for param in member.parameters:
+        method_parameters.append(
+            ParameterAnalysis(
+                name=param.name,
+                kind=_get_function_parameter_kind(param.kind),
+                type=analyze_type(param.annotation, context),
+                default=None,
+            )
+        )
+    method_common = build_member_common(
+        symbol=member,
+        name=name,
+        parent_location=parent_location,
+        context=context,
+    )
+
+    return MethodAnalysis(
+        **method_common,
+        parameters=tuple(method_parameters),
+        return_type=analyze_type(member.returns, context),
+        is_async="async" in member.labels,
+        identity=build_declaration_identity(
+            context=context, member_path=new_member_path
+        ),
+    )
+
+
+def _build_class_methods(
+    cls: Class,
+    parent_location: SourceLocation | None,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> list[MethodAnalysis]:
+    methods: list[MethodAnalysis] = []
+    for member_name, member in cls.members.items():
+        if isinstance(member, Function):
+            methods.append(
+                _build_class_method_analysis(
+                    member=member,
+                    name=member_name,
+                    parent_location=parent_location,
+                    context=context,
+                    member_path=member_path,
+                )
+            )
+    return methods
+
+
+def _build_inner_classes(
+    cls: Class, context: SymbolContext, member_path: MemberPath
+) -> list[InnerClassAnalysis]:
+    inner_classes: list[InnerClassAnalysis] = []
+    for member_name, member in cls.members.items():
+        if isinstance(member, Class):
+            inner_classes.append(
+                _analyze_inner_class(
+                    cls=member,
+                    name=member_name,
+                    context=context,
+                    member_path=member_path,
+                )
+            )
+    return inner_classes
+
+
+def _is_pydantic_base_class(bases: list[TypeAnalysis]) -> bool:
+    for base in bases:
+        if (
+            isinstance(base.structure, NameStructureAnalysis)
+            and base.structure.name == "BaseModel"
+        ):
+            return True
+
+    return False
+
+
+def _analyze_class_common(
+    cls: Class,
+    name: str,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> ClassCommon:
+    bases: list[TypeAnalysis] = [
+        analyzed
+        for base in cls.bases
+        if (analyzed := analyze_type(base, context)) is not None
+    ]
+
+    is_pydantic_base_class = _is_pydantic_base_class(bases)
+
+    constructor_location: SourceLocation | None = _retrieve_constructor_location(
+        cls, context
+    )
+
+    parameters: list[ClassVariableAnalysis] = _build_class_variables(
+        cls=cls,
+        parent_location=constructor_location,
+        context=context,
+        member_path=member_path,
+        is_pydantic_base_class=is_pydantic_base_class,
+    )
+
+    methods: list[MethodAnalysis] = _build_class_methods(
+        cls=cls,
+        parent_location=constructor_location,
+        context=context,
+        member_path=member_path,
+    )
+
+    type_aliases: list[ClassTypeAliasAnalysis] = _build_class_type_aliases(
+        cls=cls,
+        parent_location=constructor_location,
+        context=context,
+        member_path=member_path,
+    )
+
+    inner_classes: list[InnerClassAnalysis] = _build_inner_classes(
+        cls=cls, context=context, member_path=member_path
+    )
+
+    return {
+        "bases": tuple(bases),
+        "inner_classes": tuple(inner_classes),
+        "methods": tuple(methods),
+        "variables": tuple(parameters),
+        "type_aliases": tuple(type_aliases),
+    }
+
+
+def _analyze_inner_class(
+    cls: Class,
+    name: str,
+    context: SymbolContext,
+    member_path: MemberPath,
+) -> InnerClassAnalysis:
+    new_member_path = (*member_path, name)
+    class_common = _analyze_class_common(
+        cls, name, context, member_path=new_member_path
+    )
+    # pprint(cls.as_dict())
+    base_common = build_member_common(
+        symbol=cls,
+        name=name,
+        parent_location=None,
+        context=context,
+    )
+    return InnerClassAnalysis(
+        **base_common,
+        **class_common,
+        identity=build_declaration_identity(
+            context=context, member_path=new_member_path
+        ),
+    )
+
+
+def analyze_class(cls: Class, name: str, context: SymbolContext) -> ClassAnalysis:
+    member_path: MemberPath = ()
+    class_common = _analyze_class_common(cls, name, context, member_path)
+    # pprint(cls.as_dict())
+    base_common = build_symbol_common(symbol=cls, name=name, context=context)
+
+    return ClassAnalysis(
+        **base_common,
+        **class_common,
+        dependencies=tuple(),
+        identity=context.declaration,
+    )

gyomu_python_analysis/analysis/analyzers/context.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+
+from gyomu_schema.schemas.python.types import (
+    DeclarationId,
+    DeclarationIdentity,
+    PythonPath,
+    SymbolId,
+)
+
+
+@dataclass
+class DependencyInformation:
+    source: DeclarationIdentity
+    target_name: str
+
+
+@dataclass
+class SymbolContext:
+    dependencies: list[DependencyInformation]
+    declaration: DeclarationIdentity
+    source_lines: list[str]
+    line_start_offsets: list[int]
+
+
+type MemberPath = tuple[str, ...]
+
+
+def initialize_symbol_context(
+    module_name: PythonPath, name: str, source_lines: list[str]
+) -> SymbolContext:
+    symbol_id = build_symbol_id(module_name=module_name, name=name)
+    line_start_offsets = [0]
+    for line in source_lines[:-1]:
+        line_start_offsets.append(
+            line_start_offsets[-1] + len(line),
+        )
+    return SymbolContext(
+        dependencies=[],
+        declaration=DeclarationIdentity(
+            symbol_id=symbol_id,
+            declaration_id=_build_declaration_id(tuple()),
+        ),
+        source_lines=source_lines,
+        line_start_offsets=line_start_offsets,
+    )
+
+
+def build_symbol_id(module_name: PythonPath, name: str) -> SymbolId:
+    if name == "":
+        return SymbolId(f"{module_name}")
+    return SymbolId(f"{module_name}::{name}")
+
+
+def _build_declaration_id(member_path: MemberPath) -> DeclarationId:
+    if not member_path:
+        return DeclarationId(".")
+    return DeclarationId(".::" + "::".join(member_path))
+
+
+def build_declaration_identity(
+    context: SymbolContext, member_path: MemberPath
+) -> DeclarationIdentity:
+    return DeclarationIdentity(
+        symbol_id=context.declaration.symbol_id,
+        declaration_id=_build_declaration_id(member_path),
+    )

gyomu_python_analysis/analysis/analyzers/decorator.py

@@ -0,0 +1,88 @@
+from griffe import Decorator
+from gyomu_infra.logger import logger
+from gyomu_schema.schemas.python.decorator import DecoratorAnalysis, DecoratorArgument
+from gyomu_schema.schemas.python.type.structure import (
+    LiteralValue,
+    NameStructureAnalysis,
+)
+from gyomu_schema.schemas.python.type.type_analysis import (
+    AttributeStructureAnalysis,
+    CallStructureAnalysis,
+    ExpressionAnalysis,
+    KeywordStructureAnalysis,
+    TypeExpression,
+)
+
+from gyomu_python_analysis.analysis.analyzers.context import SymbolContext
+from gyomu_python_analysis.analysis.analyzers.expression.expr import (
+    analyze_type_expression,
+)
+from gyomu_python_analysis.analysis.analyzers.internal.location import (
+    calculate_decorator_location,
+)
+
+
+def analyze_decorators(
+    decorators: list[Decorator], context: SymbolContext
+) -> list[DecoratorAnalysis]:
+    returns: list[DecoratorAnalysis] = []
+    for dec in decorators:
+        returns.append(analyze_decorator(dec, context))
+
+    return returns
+
+
+def analyze_decorator(
+    decorator: Decorator, context: SymbolContext
+) -> DecoratorAnalysis:
+    value = analyze_type_expression(decorator.value, context)
+    name: str
+    arguments: list[DecoratorArgument] = []
+    if isinstance(value, LiteralValue):
+        name = str(value.value)
+
+    else:
+        name, arguments = _retrieve_expression_name(value)
+
+    return DecoratorAnalysis(
+        location=calculate_decorator_location(decorator=decorator, context=context),
+        name=name,
+        arguments=tuple(arguments),
+    )
+
+
+def _retrieve_expression_name(
+    expression: ExpressionAnalysis,
+) -> tuple[str, list[DecoratorArgument]]:
+    if isinstance(expression, NameStructureAnalysis):
+        return expression.name, []
+    elif isinstance(expression, AttributeStructureAnalysis):
+        return ".".join(_retrieve_attribute_names(expression)), []
+    elif isinstance(expression, CallStructureAnalysis):
+        name, _ = _retrieve_expression_name(expression.function)
+        arguments: list[DecoratorArgument] = []
+        for arg in expression.arguments:
+            arguments.append(_retrieve_expression_argument(arg))
+        return name, arguments
+    else:
+        logger.error(f"Unsupported Expression: {expression.kind}")
+        return "", []
+
+
+def _retrieve_expression_argument(expression: TypeExpression) -> DecoratorArgument:
+    if isinstance(expression, KeywordStructureAnalysis):
+        return DecoratorArgument(expression=expression.value, name=expression.name)
+    return DecoratorArgument(expression=expression)
+
+
+def _retrieve_attribute_names(attribute: AttributeStructureAnalysis) -> list[str]:
+    strings: list[str] = []
+    for value in attribute.values:
+        if isinstance(value, LiteralValue):
+            strings.append(str(value.value))
+        elif isinstance(value, NameStructureAnalysis):
+            strings.append(value.name)
+        elif isinstance(value, AttributeStructureAnalysis):
+            for child in _retrieve_attribute_names(value):
+                strings.append(child)
+    return strings

gyomu_python_analysis/analysis/analyzers/dependency.py

@@ -0,0 +1,134 @@
+from gyomu_schema.schemas.python.dependency import (
+    DependencyAnalysis,
+    ImportedSymbolDependency,
+    LocalFileDependency,
+)
+from gyomu_schema.schemas.python.import_analysis import ImportAnalysis, ImportKind
+from gyomu_schema.schemas.python.symbol import SymbolAnalysis
+from gyomu_schema.schemas.python.types import DeclarationIdentity, SymbolId
+
+from gyomu_python_analysis.analysis.analyzers.context import (
+    DependencyInformation,
+    SymbolContext,
+)
+
+PYTHON_RESERVED_TYPE_NAMES: frozenset[str] = frozenset(
+    {
+        # Built-in scalar types
+        "bool",
+        "int",
+        "float",
+        "complex",
+        "str",
+        "bytes",
+        "bytearray",
+        "memoryview",
+        # Built-in container types
+        "list",
+        "tuple",
+        "dict",
+        "set",
+        "frozenset",
+        # Built-in utility types
+        "range",
+        "object",
+        "type",
+        # Typing primitives
+        "Any",
+        "Never",
+        "NoReturn",
+        "Literal",
+        "Union",
+        "Optional",
+        "Annotated",
+        "Final",
+        "ClassVar",
+        "Type",
+        "Callable",
+        "TypeVar",
+        "Generic",
+        "Protocol",
+        "Self",
+    }
+)
+
+
+def register_dependency(
+    identity: DeclarationIdentity, name: str, context: SymbolContext
+) -> None:
+    if name in PYTHON_RESERVED_TYPE_NAMES:
+        return
+
+    context.dependencies.append(
+        DependencyInformation(source=identity, target_name=name)
+    )
+
+
+def _find_imported(
+    name: str,
+    imported: list[ImportAnalysis],
+) -> ImportAnalysis | None:
+    for item in imported:
+        if item.local_name == name:
+            return item
+    return None
+
+
+def _retrieve_imported_symbol_id(imported_item: ImportAnalysis) -> SymbolId:
+    if imported_item.kind == ImportKind.MODULE:
+        return SymbolId(imported_item.imported_name)
+    module_name, symbol_name = imported_item.imported_name.rsplit(".", 1)
+    return SymbolId(f"{module_name}::{symbol_name}")
+
+
+def _find_symbol(
+    name: str,
+    symbols: list[SymbolAnalysis],
+) -> SymbolAnalysis | None:
+    for symbol in symbols:
+        if symbol.name == name:
+            return symbol
+
+    return None
+
+
+def analyze_dependency(
+    record: DependencyInformation,
+    imported: list[ImportAnalysis],
+    symbols: list[SymbolAnalysis],
+) -> DependencyAnalysis | None:
+    symbol_id: SymbolId
+    if imported_item := _find_imported(record.target_name, imported):
+        symbol_id = _retrieve_imported_symbol_id(imported_item)
+        return DependencyAnalysis(
+            source=record.source, target=ImportedSymbolDependency(symbol_id=symbol_id)
+        )
+    else:
+        result = _find_symbol(record.target_name, symbols)
+        if result is None:
+            return None
+        symbol_id = result.identity.symbol_id
+        return DependencyAnalysis(
+            source=record.source, target=LocalFileDependency(symbol_id=symbol_id)
+        )
+
+
+def resolve_dependencies(
+    dependencies: list[DependencyInformation],
+    imported: list[ImportAnalysis],
+    symbols: list[SymbolAnalysis],
+) -> dict[DeclarationIdentity, tuple[DependencyAnalysis, ...]]:
+    result: dict[
+        DeclarationIdentity,
+        list[DependencyAnalysis],
+    ] = {}
+
+    for dependency in dependencies:
+        parsed = analyze_dependency(dependency, imported, symbols)
+
+        if parsed is None:
+            continue
+
+        result.setdefault(parsed.source, []).append(parsed)
+
+    return {source: tuple(items) for source, items in result.items()}