codeupipe 0.1.0__py3-none-any.whl

codeupipe/converter/filters/generate_import.py

@@ -0,0 +1,229 @@
+"""
+GenerateImportFilter: Generates CUP code from standard Python project files.
+"""
+
+import re
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class GenerateImportFilter:
+    """
+    Filter: Generate CUP Filter/Tap/Valve/Pipeline code from standard Python files.
+
+    Input payload keys:
+        - source_files (list[dict]): Files from ScanProjectFilter
+        - config (dict): Config with output dirs and roles
+        - classified_files (dict[str, list[dict]]): role → files (from ClassifyFilesFilter)
+
+    Output payload adds:
+        - cup_files (list[dict]): {"path": str, "content": str} for generated CUP code
+        - cup_pipeline (str): Generated Pipeline composition code
+    """
+
+    def call(self, payload):
+        classified_files = payload.get("classified_files", {})
+        config = payload.get("config", {})
+
+        cup_files: List[Dict[str, str]] = []
+        pipeline_steps: List[Dict[str, str]] = []
+
+        for role, files in classified_files.items():
+            cup_type = _role_to_cup_type(role, config.get("pattern", "flat"))
+
+            for file_info in files:
+                name = file_info["name"]
+                functions = _extract_functions(file_info["content"])
+
+                if not functions:
+                    continue
+
+                for fn_name, fn_sig, fn_body, returns_value in functions:
+                    if cup_type == "tap" or not returns_value:
+                        cup_code = _generate_tap_class(fn_name, fn_body)
+                        pipeline_steps.append({"name": fn_name, "type": "tap"})
+                    else:
+                        cup_code = _generate_filter_class(fn_name, fn_body)
+                        pipeline_steps.append({"name": fn_name, "type": "filter"})
+
+                    cup_files.append({
+                        "path": f"filters/{fn_name}.py",
+                        "content": cup_code,
+                    })
+
+        # Generate pipeline composition
+        pipeline_code = _generate_pipeline(pipeline_steps)
+
+        return (
+            payload
+            .insert("cup_files", cup_files)
+            .insert("cup_pipeline", pipeline_code)
+            .insert("cup_steps", pipeline_steps)
+        )
+
+
+def _role_to_cup_type(role: str, pattern: str) -> str:
+    """Map an architectural role back to a CUP type."""
+    tap_roles = {"middleware", "observability", "infrastructure", "framework"}
+    if role in tap_roles:
+        return "tap"
+    return "filter"
+
+
+def _extract_functions(source: str) -> List[tuple]:
+    """
+    Extract top-level function definitions from Python source.
+
+    Returns list of (name, signature, body, returns_value).
+    """
+    functions = []
+    # Match def function_name(args): with body
+    pattern = re.compile(
+        r'^def\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*[\w\[\], ]+)?\s*:',
+        re.MULTILINE,
+    )
+
+    for match in pattern.finditer(source):
+        fn_name = match.group(1)
+        fn_sig = match.group(2)
+        start = match.end()
+
+        # Find the body (indented block after the def)
+        body_lines = []
+        for line in source[start:].split("\n"):
+            if line.strip() == "":
+                body_lines.append("")
+                continue
+            if line and not line[0].isspace():
+                break
+            body_lines.append(line)
+
+        # Strip leading/trailing empty lines
+        while body_lines and not body_lines[0].strip():
+            body_lines.pop(0)
+        while body_lines and not body_lines[-1].strip():
+            body_lines.pop()
+
+        body = "\n".join(body_lines)
+        returns_value = "return " in body and ("return data" in body.lower() or "return {" in body)
+
+        functions.append((fn_name, fn_sig, body, returns_value))
+
+    return functions
+
+
+def _generate_filter_class(name: str, body: str) -> str:
+    """Generate a CUP Filter class wrapping a standard function."""
+    class_name = "".join(w.capitalize() for w in name.split("_")) + "Filter"
+    indented_body = _indent_body(body)
+
+    return f'''"""
+{class_name}: Imported from standard Python function '{name}'.
+"""
+
+from codeupipe import Payload
+
+
+class {class_name}:
+    """Filter wrapping the '{name}' function."""
+
+    def call(self, payload):
+        data = payload.to_dict()
+{indented_body}
+        return Payload(data)
+'''
+
+
+def _generate_tap_class(name: str, body: str) -> str:
+    """Generate a CUP Tap class wrapping a standard observation function."""
+    class_name = "".join(w.capitalize() for w in name.split("_")) + "Tap"
+    indented_body = _indent_body(body)
+
+    return f'''"""
+{class_name}: Imported from standard Python function '{name}'.
+"""
+
+from codeupipe import Payload
+
+
+class {class_name}:
+    """Tap wrapping the '{name}' function."""
+
+    def observe(self, payload):
+        data = payload.to_dict()
+{indented_body}
+'''
+
+
+def _generate_pipeline(steps: List[Dict[str, str]]) -> str:
+    """Generate Pipeline composition code."""
+    lines = [
+        '"""',
+        "Pipeline: Auto-generated from standard Python project import.",
+        '"""',
+        "",
+        "from codeupipe import Pipeline, Payload",
+        "",
+    ]
+
+    # Import each filter/tap
+    for step in steps:
+        name = step["name"]
+        class_name = "".join(w.capitalize() for w in name.split("_"))
+        if step["type"] == "tap":
+            class_name += "Tap"
+            lines.append(f"from filters.{name} import {class_name}")
+        else:
+            class_name += "Filter"
+            lines.append(f"from filters.{name} import {class_name}")
+
+    lines.extend([
+        "",
+        "",
+        "def build_pipeline() -> Pipeline:",
+        '    """Build the pipeline from imported components."""',
+        "    pipeline = Pipeline()",
+    ])
+
+    for step in steps:
+        name = step["name"]
+        class_name = "".join(w.capitalize() for w in name.split("_"))
+        if step["type"] == "tap":
+            class_name += "Tap"
+            lines.append(f'    pipeline.add_tap({class_name}(), name="{name}")')
+        else:
+            class_name += "Filter"
+            lines.append(f'    pipeline.add_filter({class_name}(), name="{name}")')
+
+    lines.extend([
+        "    return pipeline",
+        "",
+    ])
+
+    return "\n".join(lines)
+
+
+def _indent_body(body: str) -> str:
+    """Indent body to 8 spaces (inside a class method), preserving relative indentation."""
+    lines = body.split("\n")
+
+    # Find the minimum indentation of non-empty lines
+    min_indent = float("inf")
+    for line in lines:
+        stripped = line.rstrip()
+        if stripped:
+            leading = len(line) - len(line.lstrip())
+            min_indent = min(min_indent, leading)
+    if min_indent == float("inf"):
+        min_indent = 0
+
+    result = []
+    for line in lines:
+        stripped = line.rstrip()
+        if stripped:
+            # Preserve relative indent: strip min_indent, add 8 spaces
+            relative = line[min_indent:] if len(line) > min_indent else line.lstrip()
+            result.append(f"        {relative}")
+        else:
+            result.append("")
+    return "\n".join(result)

codeupipe/converter/filters/parse_config.py

@@ -0,0 +1,26 @@
+"""
+ParseConfigFilter: Reads conversion config from file or applies defaults.
+"""
+
+from pathlib import Path
+from codeupipe import Payload
+from codeupipe.converter.config import load_config
+
+
+class ParseConfigFilter:
+    """
+    Filter: Parse a .cup.json config or apply pattern defaults.
+
+    Input payload keys:
+        - config_path (str, optional): Path to .cup.json
+        - pattern (str, optional): Pattern name fallback (mvc, clean, hexagonal, flat)
+
+    Output payload adds:
+        - config (dict): Resolved configuration
+    """
+
+    def call(self, payload):
+        config_path = payload.get("config_path")
+        pattern = payload.get("pattern")
+        config = load_config(config_path=config_path, pattern=pattern)
+        return payload.insert("config", config)

codeupipe/converter/filters/scan_project.py

@@ -0,0 +1,52 @@
+"""
+ScanProjectFilter: Scans a standard Python project directory for source files.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List
+from codeupipe import Payload
+
+
+class ScanProjectFilter:
+    """
+    Filter: Scan a project directory and collect Python source files.
+
+    Input payload keys:
+        - project_path (str): Root directory to scan
+        - config (dict): Config with output dirs (used to determine role by location)
+
+    Output payload adds:
+        - source_files (list[dict]): {"path": str, "relative": str, "content": str, "dir": str}
+    """
+
+    def call(self, payload):
+        project_path = payload.get("project_path")
+        if not project_path:
+            raise ValueError("Payload must contain 'project_path' key")
+
+        root = Path(project_path)
+        if not root.is_dir():
+            raise ValueError(f"Not a directory: {project_path}")
+
+        source_files: List[Dict[str, Any]] = []
+
+        for py_file in sorted(root.rglob("*.py")):
+            # Skip __pycache__, __init__.py, and hidden dirs
+            parts = py_file.relative_to(root).parts
+            if any(p.startswith(".") or p == "__pycache__" for p in parts):
+                continue
+            if py_file.name == "__init__.py":
+                continue
+
+            relative = str(py_file.relative_to(root))
+            parent_dir = str(py_file.parent.relative_to(root)) if py_file.parent != root else ""
+
+            source_files.append({
+                "path": str(py_file),
+                "relative": relative,
+                "content": py_file.read_text(encoding="utf-8"),
+                "dir": parent_dir,
+                "name": py_file.stem,
+            })
+
+        return payload.insert("source_files", source_files)

codeupipe/converter/pipelines/__init__.py

@@ -0,0 +1,8 @@
+"""
+Converter Pipelines — CUP Pipelines for bidirectional conversion.
+"""
+
+from .export_pipeline import build_export_pipeline
+from .import_pipeline import build_import_pipeline
+
+__all__ = ["build_export_pipeline", "build_import_pipeline"]

codeupipe/converter/pipelines/export_pipeline.py

@@ -0,0 +1,40 @@
+"""
+Export Pipeline: CUP → Standard Python
+
+Analyzes a CUP Pipeline, classifies its steps by architectural role,
+and generates standard Python files in the target pattern.
+"""
+
+from codeupipe import Pipeline
+from codeupipe.converter.filters.parse_config import ParseConfigFilter
+from codeupipe.converter.filters.analyze import AnalyzePipelineFilter
+from codeupipe.converter.filters.classify import ClassifyStepsFilter
+from codeupipe.converter.filters.generate_export import GenerateExportFilter
+from codeupipe.converter.taps.conversion_log import ConversionLogTap
+
+
+def build_export_pipeline(log_tap: ConversionLogTap = None) -> Pipeline:
+    """
+    Build the CUP → Standard export pipeline.
+
+    Steps:
+    1. ParseConfig — load .cup.json or pattern defaults
+    2. AnalyzePipeline — introspect the pipeline instance
+    3. ClassifySteps — assign steps to architectural roles
+    4. GenerateExport — produce standard Python files
+
+    Returns a Pipeline ready to .run() with a Payload containing:
+        - pipeline: The CUP Pipeline instance to export
+        - config_path (optional): Path to .cup.json
+        - pattern (optional): Pattern name fallback
+    """
+    export = Pipeline()
+    export.add_filter(ParseConfigFilter(), name="parse_config")
+    export.add_filter(AnalyzePipelineFilter(), name="analyze_pipeline")
+    export.add_filter(ClassifyStepsFilter(), name="classify_steps")
+    export.add_filter(GenerateExportFilter(), name="generate_export")
+
+    if log_tap:
+        export.add_tap(log_tap, name="conversion_log")
+
+    return export

codeupipe/converter/pipelines/import_pipeline.py

@@ -0,0 +1,40 @@
+"""
+Import Pipeline: Standard Python → CUP
+
+Scans a standard Python project, classifies files by directory/role,
+and generates CUP Filter/Tap classes plus Pipeline composition code.
+"""
+
+from codeupipe import Pipeline
+from codeupipe.converter.filters.parse_config import ParseConfigFilter
+from codeupipe.converter.filters.scan_project import ScanProjectFilter
+from codeupipe.converter.filters.classify_files import ClassifyFilesFilter
+from codeupipe.converter.filters.generate_import import GenerateImportFilter
+from codeupipe.converter.taps.conversion_log import ConversionLogTap
+
+
+def build_import_pipeline(log_tap: ConversionLogTap = None) -> Pipeline:
+    """
+    Build the Standard → CUP import pipeline.
+
+    Steps:
+    1. ParseConfig — load .cup.json or pattern defaults
+    2. ScanProject — find Python files in the project
+    3. ClassifyFiles — map files to roles by directory
+    4. GenerateImport — produce CUP Filter/Tap/Pipeline code
+
+    Returns a Pipeline ready to .run() with a Payload containing:
+        - project_path: Root directory of the standard Python project
+        - config_path (optional): Path to .cup.json
+        - pattern (optional): Pattern name fallback
+    """
+    imp = Pipeline()
+    imp.add_filter(ParseConfigFilter(), name="parse_config")
+    imp.add_filter(ScanProjectFilter(), name="scan_project")
+    imp.add_filter(ClassifyFilesFilter(), name="classify_files")
+    imp.add_filter(GenerateImportFilter(), name="generate_import")
+
+    if log_tap:
+        imp.add_tap(log_tap, name="conversion_log")
+
+    return imp

codeupipe/converter/taps/__init__.py

@@ -0,0 +1,7 @@
+"""
+Converter Taps — observation points for conversion pipelines.
+"""
+
+from .conversion_log import ConversionLogTap
+
+__all__ = ["ConversionLogTap"]

codeupipe/converter/taps/conversion_log.py

@@ -0,0 +1,46 @@
+"""
+ConversionLogTap: Logs conversion progress without modifying the payload.
+"""
+
+from typing import List
+
+
+class ConversionLogTap:
+    """
+    Tap: Logs the current conversion state for observability.
+
+    Captures log entries into an internal list for inspection.
+    """
+
+    def __init__(self):
+        self.entries: List[str] = []
+
+    def observe(self, payload):
+        config = payload.get("config")
+        steps = payload.get("steps")
+        classified = payload.get("classified")
+        classified_files = payload.get("classified_files")
+        files = payload.get("files")
+        cup_files = payload.get("cup_files")
+
+        if config is not None and not steps and not classified:
+            pattern = config.get("pattern", "?")
+            self.entries.append(f"Config loaded: pattern={pattern}")
+
+        if steps and not classified:
+            self.entries.append(f"Analyzed: {len(steps)} steps")
+
+        if classified:
+            roles = list(classified.keys())
+            self.entries.append(f"Classified into roles: {roles}")
+
+        if classified_files:
+            roles = list(classified_files.keys())
+            total = sum(len(v) for v in classified_files.values())
+            self.entries.append(f"Scanned {total} files into roles: {roles}")
+
+        if files:
+            self.entries.append(f"Generated {len(files)} export files")
+
+        if cup_files:
+            self.entries.append(f"Generated {len(cup_files)} CUP files")

codeupipe/core/__init__.py

@@ -0,0 +1,20 @@
+"""
+Core Module: Base Protocols and Classes
+
+The foundation — protocols, abstract base classes, and fundamental types.
+"""
+
+from .payload import Payload, MutablePayload
+from .filter import Filter
+from .stream_filter import StreamFilter
+from .pipeline import Pipeline
+from .valve import Valve
+from .tap import Tap
+from .state import State
+from .hook import Hook
+
+__all__ = [
+    "Payload", "MutablePayload",
+    "Filter", "StreamFilter", "Pipeline", "Valve", "Tap",
+    "State", "Hook",
+]

codeupipe/core/filter.py

@@ -0,0 +1,27 @@
+"""
+Filter Protocol: The Processing Unit
+
+The Filter protocol defines the interface for payload processors.
+Each Filter takes a Payload in, processes it, and returns a (potentially transformed) Payload out.
+Enhanced with generic typing for type-safe workflows.
+"""
+
+from typing import Protocol, TypeVar
+from .payload import Payload
+
+__all__ = ["Filter"]
+
+TInput = TypeVar('TInput')
+TOutput = TypeVar('TOutput')
+
+
+class Filter(Protocol[TInput, TOutput]):
+    """
+    Processing unit — takes a payload in, returns a transformed payload out.
+    The core protocol that all filter implementations must follow.
+    Enhanced with generic typing for type-safe workflows.
+    """
+
+    async def call(self, payload: Payload[TInput]) -> Payload[TOutput]:
+        """Process the payload and return a transformed result."""
+        ...

codeupipe/core/hook.py

@@ -0,0 +1,34 @@
+"""
+Hook ABC: The Enhancement Layer
+
+The Hook ABC defines optional lifecycle hooks for pipeline execution.
+Subclasses can override any combination of before(), after(), and on_error().
+"""
+
+from abc import ABC
+from typing import Optional, TypeVar
+from .payload import Payload
+from .filter import Filter
+
+__all__ = ["Hook"]
+
+T = TypeVar('T')
+
+
+class Hook(ABC):
+    """
+    Lifecycle hook for pipeline execution.
+    Subclasses can override any combination of before(), after(), and on_error().
+    """
+
+    async def before(self, filter: Optional[Filter], payload: Payload[T]) -> None:
+        """Called before a filter executes, or before the pipeline starts (filter=None)."""
+        pass
+
+    async def after(self, filter: Optional[Filter], payload: Payload[T]) -> None:
+        """Called after a filter executes, or after the pipeline ends (filter=None)."""
+        pass
+
+    async def on_error(self, filter: Optional[Filter], error: Exception, payload: Payload[T]) -> None:
+        """Called when an error occurs."""
+        pass

codeupipe/core/payload.py

@@ -0,0 +1,94 @@
+"""
+Payload: The Data Container
+
+The Payload carries data through the pipeline — immutable by default for safety,
+mutable when flexibility is needed.
+Enhanced with generic typing for type-safe workflows.
+"""
+
+from typing import Any, Dict, Optional, TypeVar, Generic, Union
+
+__all__ = ["Payload", "MutablePayload"]
+
+T = TypeVar('T')
+TInput = TypeVar('TInput')
+TOutput = TypeVar('TOutput')
+
+
+class Payload(Generic[T]):
+    """
+    Immutable data container — holds data flowing through the pipeline.
+    Returns fresh copies on modification for safety.
+    Enhanced with generic typing for type-safe workflows.
+    """
+
+    def __init__(self, data: Optional[Union[Dict[str, Any], T]] = None):
+        if data is None:
+            self._data: Dict[str, Any] = {}
+        elif isinstance(data, dict):
+            self._data = data.copy() if data else {}
+        else:
+            try:
+                self._data = dict(data)  # type: ignore
+            except (TypeError, ValueError):
+                self._data = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Return the value for key, or default if absent."""
+        return self._data.get(key, default)
+
+    def insert(self, key: str, value: Any) -> 'Payload[T]':
+        """Return a fresh Payload with the addition."""
+        new_data = self._data.copy()
+        new_data[key] = value
+        return Payload[T](new_data)
+
+    def insert_as(self, key: str, value: Any) -> 'Payload[T]':
+        """
+        Create a new Payload with type evolution — allows clean transformation
+        between TypedDict shapes without explicit casting.
+        """
+        new_data = self._data.copy()
+        new_data[key] = value
+        return Payload[T](new_data)
+
+    def with_mutation(self) -> 'MutablePayload[T]':
+        """Convert to a mutable sibling for performance-critical sections."""
+        return MutablePayload[T](self._data.copy())
+
+    def merge(self, other: 'Payload[T]') -> 'Payload[T]':
+        """Combine payloads, with other taking precedence on conflicts."""
+        new_data = self._data.copy()
+        new_data.update(other._data)
+        return Payload[T](new_data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Express as dict for ecosystem integration."""
+        return self._data.copy()
+
+    def __repr__(self) -> str:
+        return f"Payload({self._data})"
+
+
+class MutablePayload(Generic[T]):
+    """
+    Mutable data container for performance-critical sections.
+    Enhanced with generic typing for type-safe workflows.
+    """
+
+    def __init__(self, data: Optional[Dict[str, Any]] = None):
+        self._data = data or {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Change in place."""
+        self._data[key] = value
+
+    def to_immutable(self) -> Payload[T]:
+        """Return to safety with a fresh immutable copy."""
+        return Payload[T](self._data.copy())
+
+    def __repr__(self) -> str:
+        return f"MutablePayload({self._data})"