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

scitex/template/_mcp_handlers.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/template/_mcp_handlers.py
+# ----------------------------------------
+
+"""
+MCP Handler implementations for SciTeX Template module.
+
+Provides async handlers for project scaffolding operations:
+- list_templates_handler: List available templates
+- get_template_info_handler: Get template details
+- clone_template_handler: Create project from template
+- list_git_strategies_handler: List git strategies
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+
+async def list_templates_handler() -> dict:
+    """
+    List all available SciTeX project templates.
+
+    Returns
+    -------
+    dict
+        Success status and list of templates with basic info
+    """
+    try:
+        from scitex.template import get_available_templates_info
+
+        templates = get_available_templates_info()
+
+        # Simplify for listing
+        template_list = [
+            {
+                "id": t["id"],
+                "name": t["name"],
+                "description": t["description"],
+                "use_case": t["use_case"],
+            }
+            for t in templates
+        ]
+
+        return {
+            "success": True,
+            "count": len(template_list),
+            "templates": template_list,
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+
+async def get_template_info_handler(template_id: str) -> dict:
+    """
+    Get detailed information about a specific template.
+
+    Parameters
+    ----------
+    template_id : str
+        Template identifier (research, pip_project, singularity, paper_directory)
+
+    Returns
+    -------
+    dict
+        Success status and template details
+    """
+    try:
+        from scitex.template import get_available_templates_info
+
+        templates = get_available_templates_info()
+
+        # Find the requested template
+        template = None
+        for t in templates:
+            if t["id"] == template_id:
+                template = t
+                break
+
+        if template is None:
+            return {
+                "success": False,
+                "error": f"Template not found: {template_id}",
+                "available_templates": [t["id"] for t in templates],
+            }
+
+        return {
+            "success": True,
+            "template": template,
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+
+async def clone_template_handler(
+    template_id: str,
+    project_name: str,
+    target_dir: Optional[str] = None,
+    git_strategy: str = "child",
+    branch: Optional[str] = None,
+    tag: Optional[str] = None,
+) -> dict:
+    """
+    Create a new project by cloning a template.
+
+    Parameters
+    ----------
+    template_id : str
+        Template to clone (research, pip_project, singularity, paper_directory)
+    project_name : str
+        Name for the new project
+    target_dir : str, optional
+        Parent directory for the project (default: current directory)
+    git_strategy : str, optional
+        Git initialization strategy (child, parent, origin, none)
+    branch : str, optional
+        Specific branch to clone
+    tag : str, optional
+        Specific tag to clone
+
+    Returns
+    -------
+    dict
+        Success status and project path
+    """
+    try:
+        # Map template_id to clone function
+        clone_functions = {
+            "research": "clone_research",
+            "pip_project": "clone_pip_project",
+            "singularity": "clone_singularity",
+            "paper_directory": "clone_writer_directory",
+        }
+
+        if template_id not in clone_functions:
+            return {
+                "success": False,
+                "error": f"Unknown template: {template_id}",
+                "available_templates": list(clone_functions.keys()),
+            }
+
+        # Import the specific clone function
+        import scitex.template as template_module
+
+        clone_func = getattr(template_module, clone_functions[template_id])
+
+        # Build project path
+        if target_dir:
+            project_path = str(Path(target_dir) / project_name)
+        else:
+            project_path = project_name
+
+        # Handle git_strategy='none'
+        git_strat = None if git_strategy == "none" else git_strategy
+
+        # Run clone in executor (blocking operation)
+        loop = asyncio.get_event_loop()
+        success = await loop.run_in_executor(
+            None,
+            lambda: clone_func(
+                project_dir=project_path,
+                git_strategy=git_strat,
+                branch=branch,
+                tag=tag,
+            ),
+        )
+
+        if success:
+            # Resolve the actual path
+            resolved_path = Path(project_path)
+            if not resolved_path.is_absolute():
+                resolved_path = Path.cwd() / resolved_path
+
+            return {
+                "success": True,
+                "project_path": str(resolved_path),
+                "template": template_id,
+                "git_strategy": git_strategy,
+                "message": f"Successfully created {template_id} project at {resolved_path}",
+            }
+        else:
+            return {
+                "success": False,
+                "error": f"Failed to clone template: {template_id}",
+                "project_name": project_name,
+            }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+
+async def list_git_strategies_handler() -> dict:
+    """
+    List available git initialization strategies.
+
+    Returns
+    -------
+    dict
+        Success status and list of strategies with descriptions
+    """
+    strategies = [
+        {
+            "id": "child",
+            "name": "Child Repository",
+            "description": "Create an isolated git repository in the project directory",
+            "recommended": True,
+            "preserves_template_history": False,
+        },
+        {
+            "id": "parent",
+            "name": "Parent Repository",
+            "description": "Use the parent directory's git repository (project becomes part of parent repo)",
+            "recommended": False,
+            "preserves_template_history": False,
+        },
+        {
+            "id": "origin",
+            "name": "Preserve Origin",
+            "description": "Keep the template's original git history (maintains connection to template repo)",
+            "recommended": False,
+            "preserves_template_history": True,
+        },
+        {
+            "id": "none",
+            "name": "No Git",
+            "description": "Skip git initialization entirely",
+            "recommended": False,
+            "preserves_template_history": False,
+        },
+    ]
+
+    return {
+        "success": True,
+        "count": len(strategies),
+        "strategies": strategies,
+        "default": "child",
+    }
+
+
+__all__ = [
+    "list_templates_handler",
+    "get_template_info_handler",
+    "clone_template_handler",
+    "list_git_strategies_handler",
+]
+
+# EOF

scitex/template/_mcp_tool_schemas.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/template/_mcp_tool_schemas.py
+# ----------------------------------------
+
+"""
+MCP Tool schemas for SciTeX Template module.
+
+Defines available tools for project scaffolding:
+- list_templates: List available project templates
+- get_template_info: Get detailed information about a template
+- clone_template: Create a new project from a template
+"""
+
+from __future__ import annotations
+
+import mcp.types as types
+
+
+def get_tool_schemas() -> list[types.Tool]:
+    """Return list of available MCP tools for template operations."""
+    return [
+        # List available templates
+        types.Tool(
+            name="list_templates",
+            description="List all available SciTeX project templates with their descriptions",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        ),
+        # Get template information
+        types.Tool(
+            name="get_template_info",
+            description="Get detailed information about a specific project template",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "template_id": {
+                        "type": "string",
+                        "description": "Template identifier (research, pip_project, singularity, paper_directory)",
+                        "enum": [
+                            "research",
+                            "pip_project",
+                            "singularity",
+                            "paper_directory",
+                        ],
+                    },
+                },
+                "required": ["template_id"],
+            },
+        ),
+        # Clone template
+        types.Tool(
+            name="clone_template",
+            description="Create a new project by cloning a template. Supports research projects, Python packages, Singularity containers, and paper directories.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "template_id": {
+                        "type": "string",
+                        "description": "Template to clone (research, pip_project, singularity, paper_directory)",
+                        "enum": [
+                            "research",
+                            "pip_project",
+                            "singularity",
+                            "paper_directory",
+                        ],
+                    },
+                    "project_name": {
+                        "type": "string",
+                        "description": "Name for the new project (will be used as directory name)",
+                    },
+                    "target_dir": {
+                        "type": "string",
+                        "description": "Parent directory where project will be created (default: current directory)",
+                    },
+                    "git_strategy": {
+                        "type": "string",
+                        "description": "Git initialization strategy",
+                        "enum": ["child", "parent", "origin", "none"],
+                        "default": "child",
+                    },
+                    "branch": {
+                        "type": "string",
+                        "description": "Specific branch to clone (optional)",
+                    },
+                    "tag": {
+                        "type": "string",
+                        "description": "Specific tag/release to clone (optional)",
+                    },
+                },
+                "required": ["template_id", "project_name"],
+            },
+        ),
+        # Get git strategies
+        types.Tool(
+            name="list_git_strategies",
+            description="List available git initialization strategies for template cloning",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        ),
+    ]
+
+
+__all__ = ["get_tool_schemas"]
+
+# EOF

scitex/template/mcp_server.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+# Timestamp: 2026-01-08
+# File: src/scitex/template/mcp_server.py
+# ----------------------------------------
+
+"""
+MCP Server for SciTeX Template - Project Scaffolding Framework
+
+Provides tools for:
+- Listing available project templates
+- Getting detailed template information
+- Creating new projects from templates
+- Managing git initialization strategies
+"""
+
+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__ = ["TemplateServer", "main", "MCP_AVAILABLE"]
+
+
+class TemplateServer:
+    """MCP Server for Project Template Management."""
+
+    def __init__(self):
+        self.server = Server("scitex-template")
+        self.setup_handlers()
+
+    def setup_handlers(self):
+        """Set up MCP server handlers."""
+        from ._mcp_handlers import (
+            clone_template_handler,
+            get_template_info_handler,
+            list_git_strategies_handler,
+            list_templates_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):
+            # List templates
+            if name == "list_templates":
+                return await self._wrap_result(list_templates_handler())
+
+            # Get template info
+            elif name == "get_template_info":
+                return await self._wrap_result(get_template_info_handler(**arguments))
+
+            # Clone template
+            elif name == "clone_template":
+                return await self._wrap_result(clone_template_handler(**arguments))
+
+            # List git strategies
+            elif name == "list_git_strategies":
+                return await self._wrap_result(list_git_strategies_handler())
+
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+
+        @self.server.list_resources()
+        async def handle_list_resources():
+            """List available template resources."""
+            resources = [
+                types.Resource(
+                    uri="template://templates",
+                    name="Available Templates",
+                    description="List of all available project templates",
+                    mimeType="application/json",
+                ),
+                types.Resource(
+                    uri="template://git-strategies",
+                    name="Git Strategies",
+                    description="Available git initialization strategies",
+                    mimeType="application/json",
+                ),
+            ]
+            return resources
+
+        @self.server.read_resource()
+        async def handle_read_resource(uri: str):
+            """Read a template resource."""
+            import json
+
+            if uri == "template://templates":
+                result = await list_templates_handler()
+                return types.TextResourceContents(
+                    uri=uri,
+                    mimeType="application/json",
+                    text=json.dumps(result, indent=2),
+                )
+
+            elif uri == "template://git-strategies":
+                result = await list_git_strategies_handler()
+                return types.TextResourceContents(
+                    uri=uri,
+                    mimeType="application/json",
+                    text=json.dumps(result, indent=2),
+                )
+
+            else:
+                raise ValueError(f"Unknown resource URI: {uri}")
+
+    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 = TemplateServer()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="scitex-template",
+                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:
+        import sys
+
+        print("=" * 60)
+        print("MCP Server 'scitex-template' requires the 'mcp' package.")
+        print()
+        print("Install with:")
+        print("  pip install mcp")
+        print()
+        print("Or install scitex with MCP support:")
+        print("  pip install scitex[mcp]")
+        print("=" * 60)
+        sys.exit(1)
+
+    asyncio.run(_run_server())
+
+
+if __name__ == "__main__":
+    main()
+
+
+# EOF

scitex/utils/_verify_scitex_format.py

@@ -206,7 +206,7 @@ def _check_run_main_unchanged(content: str) -> bool:
         r"import matplotlib\.pyplot as plt",
         r"import scitex as stx",
         r"args = parse_args\(\)",
-        r"CONFIG, sys\.stdout, sys\.stderr, plt, CC, rng_manager = stx\.session\.start\(",
+        r"CONFIG, sys\.stdout, sys\.stderr, plt, CC, rng = stx\.session\.start\(",
         r"exit_status = main\(args\)",
         r"stx\.session\.close\(",
     ]
@@ -535,7 +535,7 @@ def run_main() -> None:
 
     args = parse_args()
 
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng_manager = stx.session.start(
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
         sys,
         plt,
         args=args,

scitex/utils/template.py

@@ -96,7 +96,7 @@ def run_main() -> None:
 
     args = parse_args()
 
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng_manager = stx.session.start(
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
         sys,
         plt,
         args=args,

scitex/web/__init__.py

@@ -1,28 +1,29 @@
 #!/usr/bin/env python3
 """Web-related utilities module for scitex."""
 
+from ._scraping import get_image_urls, get_urls
 from ._search_pubmed import (
-    search_pubmed,
-    _search_pubmed,
     _fetch_details,
-    _parse_abstract_xml,
     _get_citation,
-    get_crossref_metrics,
-    save_bibtex,
-    format_bibtex,
-    fetch_async,
+    _parse_abstract_xml,
+    _search_pubmed,
     batch__fetch_details,
+    fetch_async,
+    format_bibtex,
+    get_crossref_metrics,
     parse_args,
     run_main,
+    save_bibtex,
+    search_pubmed,
 )
 from ._summarize_url import (
-    summarize_url,
-    extract_main_content,
-    crawl_url,
     crawl_to_json,
+    crawl_url,
+    extract_main_content,
     summarize_all,
+    summarize_url,
 )
-from ._scraping import get_urls, download_images, get_image_urls
+from .download_images import download_images
 
 __all__ = [
     "search_pubmed",