scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/diagram/__init__.py

@@ -1,38 +1,59 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: 2025-12-15
+# Timestamp: 2026-01-24
 # Author: ywatanabe / Claude
 # File: scitex/diagram/__init__.py
 
 """
 SciTeX Diagram - Paper-optimized diagram generation.
 
-This module provides a semantic layer above Mermaid/Graphviz/D2 that
-understands paper constraints (column width, reading direction, emphasis)
-and compiles to backend formats with appropriate layout hints.
-
-Key insight: LLMs are good at generating CONSTRAINTS, not pixel layouts.
-SciTeX Diagram defines "what this diagram means for a paper" and compiles
-that to backend-specific layout directives.
+This module delegates entirely to figrecipe._diagram.
+figrecipe is the single source of truth for diagram functionality.
 
 Example
 -------
->>> from scitex.diagram import Diagram
+>>> import scitex as stx
+>>>
+>>> # Recommended: Use stx.Diagram directly
+>>> d = stx.Diagram(type="pipeline")
+>>> d.add_node("input", "Raw Data")
+>>> d.add_node("process", "Transform", emphasis="primary")
+>>> d.add_edge("input", "process")
+>>> d.to_mermaid("pipeline.mmd")
 >>>
->>> diagram = Diagram.from_yaml("workflow.diagram.yaml")
->>> diagram.to_mermaid("workflow.mmd")
->>> diagram.to_graphviz("workflow.dot")
+>>> # From YAML spec
+>>> d = stx.Diagram.from_yaml("workflow.diagram.yaml")
+>>> d.to_mermaid("workflow.mmd")
+>>> d.to_graphviz("workflow.dot")
 """
 
-from scitex.diagram._schema import DiagramSpec, PaperConstraints, LayoutHints, PaperMode
-from scitex.diagram._diagram import Diagram
-from scitex.diagram._compile import compile_to_mermaid, compile_to_graphviz
-from scitex.diagram._presets import WORKFLOW_PRESET, DECISION_PRESET, PIPELINE_PRESET
-from scitex.diagram._split import split_diagram, SplitConfig, SplitStrategy, SplitResult
+# Import everything from figrecipe._diagram (single source of truth)
+from figrecipe._diagram import (
+    DECISION_PRESET,
+    PIPELINE_PRESET,
+    SCIENTIFIC_PRESET,
+    WORKFLOW_PRESET,
+    Diagram,
+    DiagramSpec,
+    DiagramType,
+    EdgeSpec,
+    LayoutHints,
+    NodeSpec,
+    PaperConstraints,
+    PaperMode,
+    SplitConfig,
+    SplitResult,
+    SplitStrategy,
+    get_preset,
+    list_presets,
+)
+from figrecipe._diagram._compile import compile_to_graphviz, compile_to_mermaid
 
 __all__ = [
     "Diagram",
     "DiagramSpec",
+    "DiagramType",
+    "NodeSpec",
+    "EdgeSpec",
     "PaperConstraints",
     "LayoutHints",
     "PaperMode",
@@ -41,7 +62,9 @@ __all__ = [
     "WORKFLOW_PRESET",
     "DECISION_PRESET",
     "PIPELINE_PRESET",
-    "split_diagram",
+    "SCIENTIFIC_PRESET",
+    "get_preset",
+    "list_presets",
     "SplitConfig",
     "SplitStrategy",
     "SplitResult",

scitex/diagram/mcp_server.py

@@ -1,148 +1,36 @@
 #!/usr/bin/env python3
-# Timestamp: 2026-01-08
+# Timestamp: 2026-01-24
 # File: src/scitex/diagram/mcp_server.py
-# ----------------------------------------
 
 """
-MCP Server for SciTeX diagram - Paper-optimized diagram generation.
+MCP Server for SciTeX diagram - delegates to figrecipe.
 
-Provides tools for:
-- Creating diagrams from YAML specs
-- Compiling to Mermaid/Graphviz formats
-- Using workflow/decision/pipeline presets
-- Splitting large diagrams for publication layouts
+This is a thin wrapper that redirects to figrecipe's MCP server.
+figrecipe is the single source of truth for diagram functionality.
 """
 
 from __future__ import annotations
 
-import asyncio
-
-# Graceful MCP dependency handling
-try:
-    import mcp.types as types
-    from mcp.server import NotificationOptions, Server
-    from mcp.server.models import InitializationOptions
-    from mcp.server.stdio import stdio_server
-
-    MCP_AVAILABLE = True
-except ImportError:
-    MCP_AVAILABLE = False
-    types = None  # type: ignore
-    Server = None  # type: ignore
-    NotificationOptions = None  # type: ignore
-    InitializationOptions = None  # type: ignore
-    stdio_server = None  # type: ignore
-
-__all__ = ["DiagramServer", "main", "MCP_AVAILABLE"]
-
-
-class DiagramServer:
-    """MCP Server for Paper-Optimized Diagram Generation."""
-
-    def __init__(self):
-        self.server = Server("scitex-diagram")
-        self.setup_handlers()
-
-    def setup_handlers(self):
-        """Set up MCP server handlers."""
-        from ._mcp_handlers import (
-            compile_graphviz_handler,
-            compile_mermaid_handler,
-            create_diagram_handler,
-            get_paper_modes_handler,
-            get_preset_handler,
-            list_presets_handler,
-            split_diagram_handler,
-        )
-        from ._mcp_tool_schemas import get_tool_schemas
-
-        @self.server.list_tools()
-        async def handle_list_tools():
-            return get_tool_schemas()
-
-        @self.server.call_tool()
-        async def handle_call_tool(name: str, arguments: dict):
-            if name == "create_diagram":
-                return await self._wrap_result(create_diagram_handler(**arguments))
-
-            elif name == "compile_mermaid":
-                return await self._wrap_result(compile_mermaid_handler(**arguments))
-
-            elif name == "compile_graphviz":
-                return await self._wrap_result(compile_graphviz_handler(**arguments))
-
-            elif name == "list_presets":
-                return await self._wrap_result(list_presets_handler())
-
-            elif name == "get_preset":
-                return await self._wrap_result(get_preset_handler(**arguments))
-
-            elif name == "split_diagram":
-                return await self._wrap_result(split_diagram_handler(**arguments))
-
-            elif name == "get_paper_modes":
-                return await self._wrap_result(get_paper_modes_handler())
-
-            else:
-                raise ValueError(f"Unknown tool: {name}")
-
-    async def _wrap_result(self, coro):
-        """Wrap handler result as MCP TextContent."""
-        import json
-
-        try:
-            result = await coro
-            return [
-                types.TextContent(
-                    type="text",
-                    text=json.dumps(result, indent=2, default=str),
-                )
-            ]
-        except Exception as e:
-            return [
-                types.TextContent(
-                    type="text",
-                    text=json.dumps({"success": False, "error": str(e)}, indent=2),
-                )
-            ]
-
-
-async def _run_server():
-    """Run the MCP server (internal)."""
-    server = DiagramServer()
-    async with stdio_server() as (read_stream, write_stream):
-        await server.server.run(
-            read_stream,
-            write_stream,
-            InitializationOptions(
-                server_name="scitex-diagram",
-                server_version="0.1.0",
-                capabilities=server.server.get_capabilities(
-                    notification_options=NotificationOptions(),
-                    experimental_capabilities={},
-                ),
-            ),
-        )
-
 
 def main():
-    """Main entry point for the MCP server."""
-    if not MCP_AVAILABLE:
+    """Main entry point - delegates to figrecipe's MCP server."""
+    try:
+        from figrecipe._mcp.server import mcp
+
+        mcp.run()
+    except ImportError as e:
         import sys
 
         print("=" * 60)
-        print("MCP Server 'scitex-diagram' requires the 'mcp' package.")
+        print("scitex-diagram requires figrecipe with MCP support.")
         print()
         print("Install with:")
-        print("  pip install mcp")
+        print("  pip install figrecipe[mcp]")
         print()
-        print("Or install scitex with MCP support:")
-        print("  pip install scitex[mcp]")
+        print(f"Error: {e}")
         print("=" * 60)
         sys.exit(1)
 
-    asyncio.run(_run_server())
-
 
 if __name__ == "__main__":
     main()

scitex/git/_init.py

@@ -86,9 +86,9 @@ def create_child_git(project_dir: Path) -> Optional[Path]:
             repo = Repo(project_dir)
             logger.info(f"Project is already a git repository at {project_dir}")
             # Validate project structure even if repo already exists
-            from scitex.writer._validate_tree_structures import validate_tree_structures
+            from scitex.writer._verify_tree_structure import verify_tree_structure
 
-            validate_tree_structures(project_dir)
+            verify_tree_structure(project_dir)
             return project_dir
         except InvalidGitRepositoryError:
             logger.info(f"Initializing new git repository at {project_dir}")

scitex/introspect/__init__.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-01-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/introspect/__init__.py
+
+"""
+Introspection utilities for Python packages.
+
+Provides IPython-like introspection capabilities for any Python package.
+
+Basic Introspection:
+- get_signature: Function/class signature with type hints (like `func?`)
+- get_docstring: Docstring extraction with parsing
+- get_source: Full source code (like `func??`)
+- list_members: List attributes/methods (like `dir()`)
+- get_exports: Module's __all__ contents
+- find_examples: Find usage examples in tests/examples
+
+Advanced Introspection:
+- get_class_hierarchy: Inheritance tree (MRO + subclasses)
+- get_mro: Method Resolution Order only
+- get_type_hints_detailed: Detailed type annotation analysis
+- get_class_annotations: Class variable and method annotations
+- get_imports: Static import analysis using AST
+- get_dependencies: Module dependency analysis
+- get_call_graph: Function call graph (with timeout protection)
+- get_function_calls: Simple outgoing calls list
+"""
+
+from ._core import (
+    # Basic
+    find_examples,
+    # Advanced - Call graph
+    get_call_graph,
+    # Advanced - Type hints
+    get_class_annotations,
+    # Advanced - Class hierarchy
+    get_class_hierarchy,
+    # Advanced - Imports
+    get_dependencies,
+    get_docstring,
+    get_exports,
+    get_function_calls,
+    get_imports,
+    get_mro,
+    get_signature,
+    get_source,
+    get_type_hints_detailed,
+    get_type_info,
+    list_members,
+    resolve_object,
+)
+
+__all__ = [
+    # Basic
+    "get_signature",
+    "get_docstring",
+    "get_source",
+    "list_members",
+    "get_exports",
+    "find_examples",
+    "resolve_object",
+    "get_type_info",
+    # Advanced - Class hierarchy
+    "get_class_hierarchy",
+    "get_mro",
+    # Advanced - Type hints
+    "get_type_hints_detailed",
+    "get_class_annotations",
+    # Advanced - Imports
+    "get_imports",
+    "get_dependencies",
+    # Advanced - Call graph
+    "get_call_graph",
+    "get_function_calls",
+]

scitex/introspect/_call_graph.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+# Timestamp: 2025-01-20
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/introspect/_call_graph.py
+
+"""Call graph analysis using AST with timeout protection."""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import signal
+from contextlib import contextmanager
+from pathlib import Path
+
+from ._resolve import get_type_info, resolve_object
+
+
+class TimeoutError(Exception):
+    """Raised when operation times out."""
+
+    pass
+
+
+@contextmanager
+def timeout(seconds: int):
+    """Context manager for timeout (Unix only)."""
+
+    def handler(signum, frame):
+        raise TimeoutError(f"Operation timed out after {seconds}s")
+
+    # Only works on Unix
+    try:
+        old_handler = signal.signal(signal.SIGALRM, handler)
+        signal.alarm(seconds)
+        try:
+            yield
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+    except (ValueError, AttributeError):
+        # Windows or signal not available - no timeout
+        yield
+
+
+def get_call_graph(
+    dotted_path: str,
+    max_depth: int = 2,
+    timeout_seconds: int = 10,
+    internal_only: bool = True,
+) -> dict:
+    """
+    Get the call graph of a function or module using static AST analysis.
+
+    Parameters
+    ----------
+    dotted_path : str
+        Dotted path to the function or module
+    max_depth : int
+        Maximum depth to traverse calls
+    timeout_seconds : int
+        Timeout in seconds (0 = no timeout)
+    internal_only : bool
+        Only show calls to functions in the same module
+
+    Returns
+    -------
+    dict
+        calls: list[dict] - Functions this function calls
+        called_by: list[dict] - Functions that call this (if module)
+        graph: dict - Full call graph tree
+
+    Examples
+    --------
+    >>> get_call_graph("scitex.audio.speak")
+    """
+    try:
+        if timeout_seconds > 0:
+            with timeout(timeout_seconds):
+                return _analyze_call_graph(dotted_path, max_depth, internal_only)
+        else:
+            return _analyze_call_graph(dotted_path, max_depth, internal_only)
+    except TimeoutError as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "partial": True,
+        }
+
+
+def _analyze_call_graph(
+    dotted_path: str,
+    max_depth: int,
+    internal_only: bool,
+) -> dict:
+    """Perform the actual call graph analysis."""
+    obj, error = resolve_object(dotted_path)
+    if error:
+        return {"success": False, "error": error}
+
+    type_info = get_type_info(obj)
+
+    # Get source file
+    try:
+        source_file = inspect.getfile(obj)
+        source = Path(source_file).read_text()
+        tree = ast.parse(source)
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Cannot parse source: {e}",
+            "type_info": type_info,
+        }
+
+    # Build function index for the module
+    func_index = _build_function_index(tree)
+
+    if inspect.isfunction(obj):
+        # Analyze single function
+        func_name = obj.__name__
+        if func_name not in func_index:
+            return {
+                "success": False,
+                "error": f"Function '{func_name}' not found in source",
+                "type_info": type_info,
+            }
+
+        calls = _get_function_calls(func_index[func_name], internal_only, func_index)
+        called_by = _find_callers(func_name, func_index)
+
+        return {
+            "success": True,
+            "function": func_name,
+            "calls": calls,
+            "call_count": len(calls),
+            "called_by": called_by,
+            "caller_count": len(called_by),
+            "type_info": type_info,
+        }
+
+    elif inspect.ismodule(obj):
+        # Analyze entire module
+        graph = {}
+        for func_name, func_node in func_index.items():
+            calls = _get_function_calls(func_node, internal_only, func_index)
+            graph[func_name] = {
+                "calls": calls,
+                "line": func_node.lineno,
+            }
+
+        return {
+            "success": True,
+            "module": dotted_path,
+            "graph": graph,
+            "function_count": len(graph),
+            "type_info": type_info,
+        }
+
+    else:
+        return {
+            "success": False,
+            "error": "Can only analyze functions or modules",
+            "type_info": type_info,
+        }
+
+
+def _build_function_index(tree: ast.AST) -> dict[str, ast.FunctionDef]:
+    """Build index of all functions in the AST."""
+    index = {}
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            index[node.name] = node
+    return index
+
+
+def _get_function_calls(
+    func_node: ast.FunctionDef,
+    internal_only: bool,
+    func_index: dict,
+) -> list[dict]:
+    """Extract all function calls from a function."""
+    calls = []
+    seen = set()
+
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Call):
+            call_info = _extract_call_info(node)
+            if call_info and call_info["name"] not in seen:
+                # Filter to internal only if requested
+                if internal_only and call_info["name"] not in func_index:
+                    continue
+                seen.add(call_info["name"])
+                calls.append(call_info)
+
+    return calls
+
+
+def _extract_call_info(node: ast.Call) -> dict | None:
+    """Extract information about a function call."""
+    func = node.func
+
+    if isinstance(func, ast.Name):
+        # Simple call: func()
+        return {
+            "name": func.id,
+            "type": "function",
+            "line": node.lineno,
+        }
+    elif isinstance(func, ast.Attribute):
+        # Method call: obj.method()
+        if isinstance(func.value, ast.Name):
+            return {
+                "name": f"{func.value.id}.{func.attr}",
+                "type": "method",
+                "object": func.value.id,
+                "method": func.attr,
+                "line": node.lineno,
+            }
+        else:
+            return {
+                "name": func.attr,
+                "type": "method",
+                "method": func.attr,
+                "line": node.lineno,
+            }
+
+    return None
+
+
+def _find_callers(
+    func_name: str,
+    func_index: dict[str, ast.FunctionDef],
+) -> list[dict]:
+    """Find all functions that call the given function."""
+    callers = []
+
+    for caller_name, caller_node in func_index.items():
+        if caller_name == func_name:
+            continue
+
+        for node in ast.walk(caller_node):
+            if isinstance(node, ast.Call):
+                call_info = _extract_call_info(node)
+                if call_info and call_info["name"] == func_name:
+                    callers.append(
+                        {
+                            "name": caller_name,
+                            "line": caller_node.lineno,
+                        }
+                    )
+                    break
+
+    return callers
+
+
+def get_function_calls(
+    dotted_path: str,
+    include_methods: bool = True,
+    include_builtins: bool = False,
+) -> dict:
+    """
+    Get just the outgoing calls from a function.
+
+    Simpler version of get_call_graph for quick lookup.
+
+    Parameters
+    ----------
+    dotted_path : str
+        Dotted path to the function
+    include_methods : bool
+        Include method calls (obj.method())
+    include_builtins : bool
+        Include builtin function calls
+
+    Returns
+    -------
+    dict
+        calls: list[str] - Names of called functions
+    """
+    result = get_call_graph(dotted_path, max_depth=1, internal_only=False)
+
+    if not result.get("success"):
+        return result
+
+    calls = result.get("calls", [])
+
+    # Filter
+    filtered = []
+    builtins = {"print", "len", "range", "str", "int", "float", "list", "dict", "set"}
+
+    for call in calls:
+        name = call["name"]
+        if not include_methods and call.get("type") == "method":
+            continue
+        if not include_builtins and name in builtins:
+            continue
+        filtered.append(name)
+
+    return {
+        "success": True,
+        "function": dotted_path,
+        "calls": filtered,
+        "call_count": len(filtered),
+    }