gyomu-concept 0.5.0__tar.gz

gyomu_concept-0.5.0/.gitignore

@@ -0,0 +1,29 @@
+venv/
+.idea/
+
+/build/
+/dist/
+/src/gyomu.egg-info/
+/.coverage
+/htmlcov/
+__pycache__/
+*.py[cod]
+
+.env
+.env.*
+!.env.example
+
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+*.egg-info/
+log/
+
+
+# gyomu ai related
+**/.gyomu/cache
+**/.gyomu/snapshot
+**/.gyomu/checkpoint
+
+# snapshot
+__snapshots__

gyomu_concept-0.5.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.5
+Name: gyomu-concept
+Version: 0.5.0
+Summary: Gyomu Concept
+Author: Yoshihisa Matsumoto
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Requires-Dist: gyomu-ai-compiler
+Requires-Dist: gyomu-infra
+Requires-Dist: gyomu-python-analysis
+Requires-Dist: gyomu-schema
+Requires-Dist: returns
+Description-Content-Type: text/markdown
+
+# gyomu-concept
+
+concept components for Gyomu Python.

gyomu_concept-0.5.0/README.md

@@ -0,0 +1,3 @@
+# gyomu-concept
+
+concept components for Gyomu Python.

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "directory-concept-fixture"
+version = "1.0"
+description = "Gyomu Test Fixture"
+requires-python = ">=3.13"
+dependencies = [
+    "pydantic"
+]
+license = "MIT"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.ruff]
+target-version = "py313"
+line-length = 88
+exclude = [
+    "packages/infra/src/gyomu_infra/db/model/generated",
+    "packages/python_analysis/python_analysis_test_support/fixtures",
+    "packages/python_analysis/experiments",
+    "version",
+    "docs"
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+    "SIM"
+]
+
+[tool.ruff.format]
+quote-style = "double"

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/common/result.py

@@ -0,0 +1,19 @@
+# result.py
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class Result(Generic[T]):
+    value: T | None
+    error: str | None
+
+    @classmethod
+    def success(cls, value: T) -> "Result[T]":
+        return cls(value=value, error=None)
+
+    @classmethod
+    def failure(cls, error: str) -> "Result[T]":
+        return cls(value=None, error=error)

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/order/__init__.py

@@ -0,0 +1,2 @@
+# service/order/__init__.py
+"""Order management services."""

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/order/model.py

@@ -0,0 +1,11 @@
+# model.py
+from dataclasses import dataclass
+
+from service.user.model import User
+
+
+@dataclass(frozen=True)
+class Order:
+    order_id: int
+    user: User
+    amount: int

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/order/repository.py

@@ -0,0 +1,18 @@
+# repository.py
+from service.order.model import Order
+from service.user.model import User
+
+
+class OrderRepository:
+    def find_by_id(self, order_id: int) -> Order | None:
+        if order_id <= 0:
+            return None
+
+        return Order(
+            order_id=order_id,
+            user=User(
+                user_id=1,
+                name="user-1",
+            ),
+            amount=1000,
+        )

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/order/service.py

@@ -0,0 +1,11 @@
+# service.py
+from service.order.model import Order
+from service.order.repository import OrderRepository
+
+
+class OrderService:
+    def __init__(self, repository: OrderRepository) -> None:
+        self._repository = repository
+
+    def find_order(self, order_id: int) -> Order | None:
+        return self._repository.find_by_id(order_id)

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/user/__init__.py

@@ -0,0 +1,2 @@
+# service/user/__init__.py
+"""User management services."""

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/user/model.py

@@ -0,0 +1,8 @@
+# model.py
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class User:
+    user_id: int
+    name: str

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/user/repository.py

@@ -0,0 +1,13 @@
+# repository.py
+from service.user.model import User
+
+
+class UserRepository:
+    def find_by_id(self, user_id: int) -> User | None:
+        if user_id <= 0:
+            return None
+
+        return User(
+            user_id=user_id,
+            name=f"user-{user_id}",
+        )

gyomu_concept-0.5.0/concept_test_support/fixtures/directory/src/service/user/service.py

@@ -0,0 +1,11 @@
+# service.py
+from service.user.model import User
+from service.user.repository import UserRepository
+
+
+class UserService:
+    def __init__(self, repository: UserRepository) -> None:
+        self._repository = repository
+
+    def find_user(self, user_id: int) -> User | None:
+        return self._repository.find_by_id(user_id)

gyomu_concept-0.5.0/concept_test_support/helpers.py

@@ -0,0 +1,38 @@
+from difflib import unified_diff
+from pathlib import Path
+
+from gyomu_python_analysis.analysis.initialize import initialize_project_context
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.schemas.python.types import (
+    ProjectRelativePath,
+)
+from gyomu_schema.schemas.types import FullPath
+
+FIXTURES_ROOT = FullPath(Path(__file__).parent / "fixtures")
+
+
+def assert_text_file_equals(
+    root_path: Path, source_path: Path, expected_path: Path
+) -> None:
+    actual_path = root_path / source_path
+    expected_path = root_path / expected_path
+    actual = actual_path.read_text(encoding="utf-8")
+    expected = expected_path.read_text(encoding="utf-8")
+
+    diff = "".join(
+        unified_diff(
+            expected.splitlines(keepends=True),
+            actual.splitlines(keepends=True),
+            fromfile=str(expected_path),
+            tofile=str(actual_path),
+        )
+    )
+
+    assert actual == expected, f"\n{diff}"
+
+
+def _create_directory_project_context() -> ProjectContext:
+    return initialize_project_context(
+        project_root=FIXTURES_ROOT / "directory",
+        source_root=ProjectRelativePath(Path("src")),
+    ).unwrap()

gyomu_concept-0.5.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "gyomu-concept"
+dynamic = ["version"]
+description = "Gyomu Concept"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "gyomu-schema",
+    "gyomu-infra",
+    "gyomu-python-analysis",
+    "gyomu-ai-compiler",
+    "returns",
+]
+license = "MIT"
+authors = [
+    { name = "Yoshihisa Matsumoto" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.uv.sources]
+gyomu-schema = { workspace = true }
+gyomu-infra = { workspace = true }
+gyomu-python-analysis = { workspace = true }
+gyomu-ai-compiler = {workspace = true}
+
+[tool.hatch.version]
+path = "../../version/__about__.py"

gyomu_concept-0.5.0/src/gyomu_concept/directory/build.py

@@ -0,0 +1,34 @@
+from gyomu_concept.directory.internal.build import build_directory_concept_from_path
+from gyomu_concept.directory.types import BuildRootResult
+from gyomu_concept.error.concept import ConceptError
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.option.concept import ConceptOption
+from gyomu_schema.schemas.concept.directory.concept import DirectoryConcept
+from gyomu_schema.schemas.types import FullPath
+from returns.result import Failure, Result, Success
+
+
+async def build_directory_concept(
+    context: ProjectContext, option: ConceptOption | None = None
+) -> Result[BuildRootResult, ConceptError]:
+    root_path_items: tuple[FullPath, ...] = (
+        (FullPath(context.project_root / option.target_folder),)
+        if option is not None and option.target_folder is not None
+        else tuple(
+            FullPath(context.project_root / root) for root in context.package_roots
+        )
+    )
+    is_changed = False
+    concepts: list[DirectoryConcept] = []
+    for root_path in root_path_items:
+        result = await build_directory_concept_from_path(context, root_path, option)
+        if isinstance(result, Failure):
+            return result
+
+        item_result = result.unwrap()
+        concepts.append(item_result.concept)
+
+        if item_result.changed:
+            is_changed = True
+
+    return Success(BuildRootResult(concepts=tuple(concepts), changed=is_changed))

gyomu_concept-0.5.0/src/gyomu_concept/directory/internal/build.py

@@ -0,0 +1,168 @@
+from gyomu_concept.directory.internal.file_summary import build_file_summary_record
+from gyomu_concept.directory.internal.load import load_directory_concept
+from gyomu_concept.directory.internal.process import process_directory_concept
+from gyomu_concept.directory.internal.save import save_directory_concept
+from gyomu_concept.directory.types import BuildResult
+from gyomu_concept.error.concept import ConceptError
+from gyomu_python_analysis.analysis.load_file_context import load_file_analysis_context
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.option.concept import ConceptOption
+from gyomu_schema.schemas.concept.directory.input import (
+    DirectoryConceptInput,
+    SubDirectoryInput,
+)
+from gyomu_schema.schemas.python.types import (
+    DirectoryRelativePath,
+    ProjectRelativePath,
+)
+from gyomu_schema.schemas.types import FullPath
+from returns.result import Failure, Result, Success
+
+
+async def build_directory_concept_from_path(
+    context: ProjectContext,
+    target_directory: FullPath,
+    option: ConceptOption | None = None,
+) -> Result[BuildResult, ConceptError]:
+    target_directory_relative_path = ProjectRelativePath(
+        target_directory.relative_to(context.project_root)
+    )
+
+    entries = sorted(
+        target_directory.iterdir(),
+        key=lambda path: path.name,
+    )
+
+    folders = [path for path in entries if path.is_dir()]
+
+    files = [
+        path
+        for path in entries
+        if path.is_file()
+        and ProjectRelativePath(path.relative_to(context.project_root))
+        in context.included_files
+    ]
+
+    is_changed = _is_directory_changed(
+        target_directory_relative_path=target_directory_relative_path,
+        option=option,
+    )
+
+    if not is_changed:
+        loaded = load_directory_concept(
+            context=context,
+            target_directory=target_directory_relative_path,
+            option=option,
+        )
+
+        if isinstance(loaded, Success):
+            concept = loaded.unwrap()
+
+            if concept is not None:
+                return Success(
+                    BuildResult(
+                        concept=concept,
+                        changed=False,
+                    )
+                )
+
+    directory_concepts: list[SubDirectoryInput] = []
+
+    for folder in folders:
+        directory_result = await build_directory_concept_from_path(
+            context=context,
+            target_directory=folder,
+            option=option,
+        )
+
+        if isinstance(directory_result, Failure):
+            return directory_result
+
+        build_result = directory_result.unwrap()
+
+        if build_result.changed:
+            is_changed = True
+
+        directory_concepts.append(
+            SubDirectoryInput(
+                path=DirectoryRelativePath(folder.relative_to(target_directory)),
+                concept=build_result.concept,
+            )
+        )
+
+    file_summaries = []
+
+    for file in files:
+        file_relative_path = ProjectRelativePath(file.relative_to(context.project_root))
+
+        file_result = load_file_analysis_context(
+            context=context,
+            file_path=file_relative_path,
+        )
+
+        if isinstance(file_result, Failure):
+            return Failure(
+                ConceptError(
+                    message="fail to load file analysis context",
+                    file_path=file_relative_path,
+                    package_name=context.config.name,
+                    phase="directory-summary",
+                    identity=None,
+                ).chain(file_result.failure())
+            )
+
+        file_summaries.append(
+            build_file_summary_record(
+                project_context=context,
+                file_context=file_result.unwrap(),
+            )
+        )
+
+    input_context = DirectoryConceptInput(
+        files=tuple(file_summaries),
+        sub_directories=tuple(directory_concepts),
+    )
+
+    generated = await process_directory_concept(
+        package_name=context.config.name,
+        target_directory=target_directory_relative_path,
+        concept=input_context,
+    )
+
+    if isinstance(generated, Failure):
+        return generated
+
+    concept = generated.unwrap()
+
+    saved = save_directory_concept(
+        context=context,
+        target_directory=target_directory_relative_path,
+        concept=concept,
+        option=option,
+    )
+
+    if isinstance(saved, Failure):
+        return saved
+
+    return Success(
+        BuildResult(
+            concept=concept,
+            changed=is_changed,
+        )
+    )
+
+
+def _is_directory_changed(
+    target_directory_relative_path: ProjectRelativePath,
+    option: ConceptOption | None,
+) -> bool:
+    if option is None or option.changed_files is None:
+        return False
+
+    return any(
+        changed_file.project_relative_path == target_directory_relative_path
+        or changed_file.project_relative_path.is_relative_to(
+            target_directory_relative_path
+        )
+        for changed_file in option.changed_files
+    )

gyomu_concept-0.5.0/src/gyomu_concept/directory/internal/file_summary.py

@@ -0,0 +1,90 @@
+from gyomu_python_analysis.path.conversion import (
+    source_relative_path_to_project_relative_path,
+)
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.schemas.concept.file_summary import (
+    DependencySummary,
+    FileSummary,
+    PublicDeclarationSummary,
+)
+from gyomu_schema.schemas.python.dependency import ImportedSymbolDependency
+from gyomu_schema.schemas.python.file_analysis import FileAnalysisContext
+from gyomu_schema.schemas.python.symbol import SymbolAnalysis
+from gyomu_schema.schemas.python.symbol_base import DeclarationKind
+from gyomu_schema.schemas.python.visibility import Visibility
+
+
+def build_file_summary_record(
+    project_context: ProjectContext, file_context: FileAnalysisContext
+) -> FileSummary:
+    package_name = file_context.analysis.module_name.split(".")[0]
+    return FileSummary(
+        path=source_relative_path_to_project_relative_path(
+            path=file_context.analysis.path, context=project_context
+        ),
+        exports=tuple(
+            [
+                _build_export_summary(item)
+                for item in file_context.analysis.symbols
+                if item.visibility == Visibility.PUBLIC
+            ]
+        ),
+        dependencies=_aggregate_dependencies(
+            file_context=file_context, package_name=package_name
+        ),
+    )
+
+
+def _build_export_summary(item: SymbolAnalysis) -> PublicDeclarationSummary:
+    summary = ""
+    if (
+        item.docstring is not None
+        and item.docstring.summary is not None
+        and item.docstring.summary != ""
+    ):
+        summary = item.docstring.summary
+    elif (
+        item.kind == DeclarationKind.VARIABLE
+        and item.pydantic is not None
+        and item.pydantic.description is not None
+    ):
+        summary = item.pydantic.description
+    return PublicDeclarationSummary(
+        symbol=item.identity.symbol_id, kind=item.kind, summary=summary
+    )
+
+
+def _aggregate_dependencies(
+    file_context: FileAnalysisContext, package_name: str
+) -> tuple[DependencySummary, ...]:
+    dependencies = [
+        dependency.target
+        for symbol in file_context.analysis.symbols
+        for dependency in symbol.dependencies
+        if isinstance(dependency.target, ImportedSymbolDependency)
+    ]
+
+    summaries = {
+        (
+            summary.target,
+            summary.external,
+        ): summary
+        for dependency in dependencies
+        for summary in [
+            _build_dependency_summary(
+                import_item=dependency,
+                package_name=package_name,
+            )
+        ]
+    }
+
+    return tuple(summaries.values())
+
+
+def _build_dependency_summary(
+    import_item: ImportedSymbolDependency, package_name: str
+) -> DependencySummary:
+    return DependencySummary(
+        target=import_item.symbol_id,
+        external=not import_item.symbol_id.startswith(package_name),
+    )

gyomu_concept-0.5.0/src/gyomu_concept/directory/internal/load.py

@@ -0,0 +1,27 @@
+from gyomu_concept.directory.internal.path import get_directory_concept_path
+from gyomu_concept.error.concept import ConceptError
+from gyomu_infra.filesystem.file_io import read_json
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.option.concept import ConceptOption
+from gyomu_schema.schemas.concept.directory.concept import DirectoryConcept
+from gyomu_schema.schemas.python.types import ProjectRelativePath
+from returns.result import Result, Success
+
+
+def load_directory_concept(
+    context: ProjectContext,
+    target_directory: ProjectRelativePath,
+    option: ConceptOption | None = None,
+) -> Result[DirectoryConcept | None, ConceptError]:
+    concept_full_path = get_directory_concept_path(context, target_directory, option)
+    if not concept_full_path.exists():
+        return Success(None)
+    return read_json(path=concept_full_path, model_type=DirectoryConcept).alt(
+        lambda error: ConceptError(
+            message="fail to load Directory Concept",
+            file_path=target_directory,
+            package_name=context.config.name,
+            phase="directory-summary",
+            identity=None,
+        ).chain(error)
+    )

gyomu_concept-0.5.0/src/gyomu_concept/directory/internal/path.py

@@ -0,0 +1,21 @@
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.option.concept import ConceptOption
+from gyomu_schema.schemas.python.types import ProjectRelativePath
+from gyomu_schema.schemas.types import FullPath
+
+
+def get_directory_concept_path(
+    context: ProjectContext,
+    target_directory: ProjectRelativePath,
+    option: ConceptOption | None = None,
+) -> FullPath:
+    return FullPath(
+        context.project_root
+        / (
+            "cache"
+            if option and option.action and option.action.write_to_temp_folder
+            else "concept"
+        )
+        / target_directory
+        / "$Directory.json"
+    )

gyomu_concept-0.5.0/src/gyomu_concept/directory/internal/process.py

@@ -0,0 +1,26 @@
+from gyomu_ai_compiler.pipelines.directory_concept.executor.generate import (
+    generate_directory_concept,
+)
+from gyomu_concept.error.concept import ConceptError
+from gyomu_schema.schemas.concept.directory.concept import DirectoryConcept
+from gyomu_schema.schemas.concept.directory.input import DirectoryConceptInput
+from gyomu_schema.schemas.python.types import ProjectRelativePath
+from returns.result import Result
+
+
+async def process_directory_concept(
+    package_name: str,
+    target_directory: ProjectRelativePath,
+    concept: DirectoryConceptInput,
+) -> Result[DirectoryConcept, ConceptError]:
+    result = await generate_directory_concept(context=concept)
+    return result.alt(
+        lambda error: ConceptError(
+            message="fail to generate Directory Concept",
+            file_path=target_directory,
+            package_name=package_name,
+            phase="directory-summary",
+            identity=None,
+            details=vars(concept),
+        ).chain(error)
+    )