scitex 2.17.0__py3-none-any.whl → 2.17.4__py3-none-any.whl

scitex/scholar/metadata_engines/individual/OpenAlexLocalEngine.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-02-03"
+# File: src/scitex/scholar/metadata_engines/individual/OpenAlexLocalEngine.py
+# ----------------------------------------
+from __future__ import annotations
+
+import os
+
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import json
+from typing import Dict, List, Optional, Union
+
+from scitex import logging
+
+from ..utils import standardize_metadata
+from ._BaseDOIEngine import BaseDOIEngine
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAlexLocalEngine(BaseDOIEngine):
+    """OpenAlex Local Engine using local FastAPI or external public API
+
+    Supports both:
+    - Internal API: http://openalex:31292 (Docker network)
+    - External API: https://scitex.ai/scholar/api/openalex (Public internet)
+
+    Automatically detects API format and adjusts endpoints accordingly.
+    """
+
+    def __init__(
+        self,
+        email: str = "research@example.com",
+        api_url: str = "http://127.0.0.1:31292",
+    ):
+        super().__init__(email)
+        self.api_url = api_url.rstrip("/")
+
+        # Detect API type: external (public) vs internal (Docker/local)
+        self._is_external_api = (
+            "/api/openalex" in self.api_url or "scitex.ai" in self.api_url
+        )
+
+    @property
+    def name(self) -> str:
+        return "OpenAlexLocal"
+
+    @property
+    def rate_limit_delay(self) -> float:
+        return 0.01
+
+    def _build_endpoint_url(self, endpoint: str) -> str:
+        """Build the correct endpoint URL based on API type
+
+        Args:
+            endpoint: Endpoint name (e.g., 'works', 'info')
+
+        Returns
+        -------
+            Full URL for the endpoint
+
+        Examples
+        --------
+            Internal: http://openalex:31292/works
+            External: https://scitex.ai/scholar/api/openalex/works
+        """
+        if self._is_external_api:
+            # External API: base URL already includes /scholar/api/openalex
+            return f"{self.api_url}/{endpoint}"
+        else:
+            # Internal API: direct endpoint
+            return f"{self.api_url}/{endpoint}"
+
+    def search(
+        self,
+        title: Optional[str] = None,
+        year: Optional[Union[int, str]] = None,
+        authors: Optional[List[str]] = None,
+        doi: Optional[str] = None,
+        max_results=1,
+        return_as: Optional[str] = "dict",
+        **kwargs,
+    ) -> Optional[Dict]:
+        """Search using local OpenAlex API with all parameters"""
+        if doi:
+            return self._search_by_doi(doi, return_as)
+        else:
+            return self._search_by_metadata(title, year, authors, max_results, return_as)
+
+    def _search_by_doi(self, doi: str, return_as: str) -> Optional[Dict]:
+        """Get work metadata by DOI"""
+        doi = doi.replace("https://doi.org/", "").replace("http://doi.org/", "")
+        url = self._build_endpoint_url(f"works/{doi}")
+
+        try:
+            assert return_as in [
+                "dict",
+                "json",
+            ], "return_as must be either 'dict' or 'json'"
+
+            response = self.session.get(url, timeout=10)
+            if response.status_code == 404:
+                return self._create_minimal_metadata(doi=doi, return_as=return_as)
+            response.raise_for_status()
+            data = response.json()
+
+            return self._extract_metadata_from_work(data, return_as)
+
+        except Exception as e:
+            if "Connection refused" in str(e) or "Max retries exceeded" in str(e):
+                logger.warning(
+                    f"OpenAlex Local server not available at {self.api_url} (connection refused)"
+                )
+            else:
+                logger.warning(f"OpenAlex Local DOI search error: {e}")
+            return self._create_minimal_metadata(doi=doi, return_as=return_as)
+
+    def _search_by_metadata(
+        self,
+        title: Optional[str],
+        year: Optional[Union[int, str]],
+        authors: Optional[List[str]],
+        max_results: int,
+        return_as: str,
+    ) -> Optional[Dict]:
+        """Search by metadata (title, year, authors)"""
+        if not title:
+            return self._create_minimal_metadata(
+                title=title,
+                year=year,
+                authors=authors,
+                return_as=return_as,
+            )
+
+        # Build search query
+        query = title
+        if year:
+            query = f"{query} {year}"
+        if authors and isinstance(authors, list) and authors:
+            query = f"{query} {authors[0]}"
+
+        url = self._build_endpoint_url("works")
+        params = {"q": query, "limit": max(5, max_results)}
+
+        try:
+            assert return_as in [
+                "dict",
+                "json",
+            ], "return_as must be either 'dict' or 'json'"
+
+            response = self.session.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+
+            results = data.get("results", [])
+            if not results:
+                return self._create_minimal_metadata(
+                    title=title,
+                    year=year,
+                    authors=authors,
+                    return_as=return_as,
+                )
+
+            # Find best matching result
+            for work in results:
+                work_title = work.get("title", "")
+                if work_title and work_title.endswith("."):
+                    work_title = work_title[:-1]
+                if work_title and self._is_title_match(title, work_title):
+                    return self._extract_metadata_from_work(work, return_as)
+
+            # Return first result if no exact match
+            return self._extract_metadata_from_work(results[0], return_as)
+
+        except Exception as e:
+            if "Connection refused" in str(e) or "Max retries exceeded" in str(e):
+                logger.warning(
+                    f"OpenAlex Local server not available at {self.api_url} (connection refused)"
+                )
+            else:
+                logger.warning(f"OpenAlex Local search error: {e}")
+            return self._create_minimal_metadata(
+                title=title,
+                year=year,
+                authors=authors,
+                return_as=return_as,
+            )
+
+    def _extract_metadata_from_work(self, data: dict, return_as: str) -> Optional[Dict]:
+        """Extract metadata from OpenAlex work data"""
+        if not data:
+            return self._create_minimal_metadata(return_as=return_as)
+
+        # Extract title
+        title = data.get("title")
+        if title and title.endswith("."):
+            title = title[:-1]
+
+        # Extract DOI
+        doi = data.get("doi")
+        if doi:
+            doi = doi.replace("https://doi.org/", "").replace("http://doi.org/", "")
+
+        # Extract authors
+        authors = data.get("authors", [])
+        if not authors:
+            authors = []
+
+        # Extract publication info
+        year = data.get("year")
+        journal = data.get("source")
+        issn = data.get("issn")
+        volume = data.get("volume")
+        issue = data.get("issue")
+        pages = data.get("pages")
+        publisher = None  # Not directly available in response
+
+        # Extract citation count
+        cited_by_count = data.get("cited_by_count")
+
+        # Extract concepts/keywords
+        concepts = data.get("concepts", [])
+        keywords = [c.get("name") for c in concepts if c.get("name")]
+
+        # Extract OA info
+        is_oa = data.get("is_oa", False)
+        oa_url = data.get("oa_url")
+
+        # Extract OpenAlex ID
+        openalex_id = data.get("openalex_id")
+
+        metadata = {
+            "id": {
+                "doi": doi if doi else None,
+                "doi_engines": [self.name] if doi else None,
+                "openalex_id": openalex_id if openalex_id else None,
+                "openalex_id_engines": [self.name] if openalex_id else None,
+            },
+            "basic": {
+                "title": title if title else None,
+                "title_engines": [self.name] if title else None,
+                "year": year if year else None,
+                "year_engines": [self.name] if year else None,
+                "authors": authors if authors else None,
+                "authors_engines": [self.name] if authors else None,
+                "keywords": keywords if keywords else None,
+                "keywords_engines": [self.name] if keywords else None,
+            },
+            "publication": {
+                "journal": journal if journal else None,
+                "journal_engines": [self.name] if journal else None,
+                "issn": issn if issn else None,
+                "issn_engines": [self.name] if issn else None,
+                "volume": volume if volume else None,
+                "volume_engines": [self.name] if volume else None,
+                "issue": issue if issue else None,
+                "issue_engines": [self.name] if issue else None,
+                "pages": pages if pages else None,
+                "pages_engines": [self.name] if pages else None,
+            },
+            "citation_count": {
+                "total": cited_by_count if cited_by_count else None,
+                "total_engines": [self.name] if cited_by_count else None,
+            },
+            "url": {
+                "doi": f"https://doi.org/{doi}" if doi else None,
+                "doi_engines": [self.name] if doi else None,
+                "pdf": oa_url if oa_url else None,
+                "pdf_engines": [self.name] if oa_url else None,
+            },
+            "open_access": {
+                "is_oa": is_oa,
+                "is_oa_engines": [self.name] if is_oa is not None else None,
+                "oa_url": oa_url if oa_url else None,
+                "oa_url_engines": [self.name] if oa_url else None,
+            },
+            "system": {
+                f"searched_by_{self.name}": True,
+            },
+        }
+
+        metadata = standardize_metadata(metadata)
+
+        if return_as == "dict":
+            return metadata
+        if return_as == "json":
+            return json.dumps(metadata, indent=2)
+
+
+if __name__ == "__main__":
+
+    from scitex.scholar.metadata_engines.individual import OpenAlexLocalEngine
+
+    TITLE = "deep learning"
+    DOI = "10.1038/nature12373"
+
+    # Example 1: Internal API (Docker network or localhost)
+    print("\n" + "=" * 60)
+    print("INTERNAL API EXAMPLE")
+    print("=" * 60)
+    engine_internal = OpenAlexLocalEngine(
+        "test@example.com", api_url="http://openalex:31292"
+    )
+    print(f"API URL: {engine_internal.api_url}")
+    print(f"Is External: {engine_internal._is_external_api}")
+    print(f"Works endpoint: {engine_internal._build_endpoint_url('works')}")
+
+    # Example 2: External API (public internet)
+    print("\n" + "=" * 60)
+    print("EXTERNAL API EXAMPLE")
+    print("=" * 60)
+    engine_external = OpenAlexLocalEngine(
+        "test@example.com", api_url="https://scitex.ai/scholar/api/openalex"
+    )
+    print(f"API URL: {engine_external.api_url}")
+    print(f"Is External: {engine_external._is_external_api}")
+    print(f"Works endpoint: {engine_external._build_endpoint_url('works')}")
+
+    # Test search (use internal for demo)
+    print("\n" + "=" * 60)
+    print("SEARCH TEST")
+    print("=" * 60)
+    engine = OpenAlexLocalEngine("test@example.com")
+    result = engine.search(doi=DOI)
+    if result:
+        print(f"Title: {result.get('basic', {}).get('title')}")
+        print(f"DOI: {result.get('id', {}).get('doi')}")
+        print(f"Year: {result.get('basic', {}).get('year')}")
+    else:
+        print("No results found")
+
+
+# Usage examples:
+#
+# Internal API (from NAS Docker):
+#   export SCITEX_SCHOLAR_OPENALEX_API_URL=http://openalex:31292
+#   python -m scitex.scholar.metadata_engines.individual.OpenAlexLocalEngine
+#
+# External API (from anywhere):
+#   export SCITEX_SCHOLAR_OPENALEX_API_URL=https://scitex.ai/scholar/api/openalex
+#   python -m scitex.scholar.metadata_engines.individual.OpenAlexLocalEngine
+
+# EOF

scitex/scholar/metadata_engines/individual/__init__.py

@@ -2,6 +2,7 @@ from .ArXivEngine import ArXivEngine
 from .CrossRefEngine import CrossRefEngine
 from .CrossRefLocalEngine import CrossRefLocalEngine
 from .OpenAlexEngine import OpenAlexEngine
+from .OpenAlexLocalEngine import OpenAlexLocalEngine
 from .PubMedEngine import PubMedEngine
 from .SemanticScholarEngine import SemanticScholarEngine
 from .URLDOIEngine import URLDOIEngine

scitex/template/__init__.py

@@ -22,6 +22,7 @@ from .clone_pip_project import TEMPLATE_REPO_URL as PIP_PROJECT_URL
 from .clone_pip_project import clone_pip_project
 from .clone_research import TEMPLATE_REPO_URL as RESEARCH_URL
 from .clone_research import clone_research
+from .clone_research_minimal import clone_research_minimal
 from .clone_singularity import TEMPLATE_REPO_URL as SINGULARITY_URL
 from .clone_singularity import clone_singularity
 from .clone_writer_directory import (
@@ -54,9 +55,24 @@ def get_available_templates_info():
     ...     print(f"{template['name']}: {template['description']}")
     """
     return [
+        {
+            "id": "research_minimal",
+            "name": "Research Minimal",
+            "description": "Minimal SciTeX structure with writer, scholar, visualizer, and console",
+            "github_url": RESEARCH_URL,
+            "branch": "minimal",
+            "use_case": "Focused research workflow with essential SciTeX modules only",
+            "features": [
+                "scitex/writer/ - LaTeX manuscript writing",
+                "scitex/scholar/ - Bibliography management",
+                "scitex/visualizer/ - Figure creation",
+                "scitex/console/ - Code execution",
+                "scitex/management/ - Project management",
+            ],
+        },
         {
             "id": "research",
-            "name": "Research Project",
+            "name": "Research Project (Full)",
             "description": "Full scientific workflow structure for research projects",
             "github_url": RESEARCH_URL,
             "use_case": "Scientific research with data analysis, experiments, and paper writing",
@@ -113,6 +129,7 @@ def get_available_templates_info():
 
 __all__ = [
     "clone_research",
+    "clone_research_minimal",
     "clone_pip_project",
     "clone_singularity",
     "clone_writer_directory",

scitex/template/clone_research_minimal.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/template/clone_research_minimal.py
+# ----------------------------------------
+from __future__ import annotations
+
+import os
+
+__FILE__ = "./src/scitex/template/clone_research_minimal.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Create a new minimal research project from the scitex_template_research template.
+
+Uses the 'minimal' branch which contains only the scitex/ directory with:
+- writer/ - LaTeX manuscript writing
+- scholar/ - Bibliography management
+- visualizer/ - Figure creation
+- console/ - Code execution
+- management/ - Project management
+"""
+
+import sys
+from typing import Optional
+
+from ._clone_project import clone_project
+
+TEMPLATE_REPO_URL = "https://github.com/ywatanabe1989/scitex-minimal-template.git"
+
+
+def clone_research_minimal(
+    project_dir: str,
+    git_strategy: Optional[str] = "child",
+    branch: Optional[str] = None,
+    tag: Optional[str] = None,
+) -> bool:
+    """
+    Create a new minimal research project from the scitex-minimal-template.
+
+    This template contains only the essential scitex/ directory structure:
+    - writer/ - Full LaTeX manuscript writing with compilation scripts
+    - scholar/ - Bibliography management
+    - visualizer/ - Figure creation
+    - console/ - Code execution
+
+    Parameters
+    ----------
+    project_dir : str
+        Path to project directory (will be created). Can be a simple name like "my_project"
+        or a full path like "./projects/my_project"
+    git_strategy : str, optional
+        Git initialization strategy ('child', 'parent', None). Default is 'child'.
+    branch : str, optional
+        Specific branch of the template repository to clone.
+    tag : str, optional
+        Specific tag/release of the template repository to clone.
+
+    Returns
+    -------
+    bool
+        True if successful, False otherwise
+
+    Example
+    -------
+    >>> from scitex.template import clone_research_minimal
+    >>> clone_research_minimal("my_research_project")
+    >>> clone_research_minimal("./projects/my_project")
+    """
+    return clone_project(
+        project_dir,
+        TEMPLATE_REPO_URL,
+        "scitex-minimal-template",
+        git_strategy,
+        branch=branch,
+        tag=tag,
+    )
+
+
+def main(args: list = None) -> None:
+    """
+    Command-line interface for clone_research_minimal.
+
+    Parameters
+    ----------
+    args : list, optional
+        Command-line arguments. If None, uses sys.argv[1:]
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    if len(args) < 1:
+        print("Usage: python -m scitex clone_research_minimal <project-dir>")
+        print("")
+        print("Arguments:")
+        print("  project-dir   Path to project directory (will be created)")
+        print("                Can be a simple name like 'my_project' or a full path")
+        print("")
+        print("Example:")
+        print("  python -m scitex clone_research_minimal my_research_project")
+        sys.exit(1)
+
+    project_dir = args[0]
+
+    success = clone_research_minimal(project_dir)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
+
+# EOF

scitex/verify/README.md

@@ -34,7 +34,6 @@ scitex/verify/
 ├── _visualize.py        # Re-exports from _viz/
 └── _viz/
     ├── _mermaid.py      # Mermaid DAG generation
-    ├── _plotly.py       # Interactive Plotly DAGs
     ├── _json.py         # JSON DAG export
     ├── _format.py       # Terminal output formatting
     ├── _colors.py       # Color constants
@@ -199,17 +198,6 @@ render_dag("dag.mmd", target_file="output.csv")  # Mermaid code
 render_dag("dag.json", target_file="output.csv")  # Graph structure
 ```
 
-### Interactive Plotly
-
-```python
-from scitex.verify import generate_plotly_dag, render_plotly_dag
-
-fig = generate_plotly_dag(target_file="output.csv")
-fig.show()  # Opens browser
-
-render_plotly_dag("dag_plotly.html", target_file="output.csv")
-```
-
 ## Integration Hooks (`_integration.py`)
 
 Automatically called by `@stx.session` and `stx.io`:

scitex/verify/__init__.py

@@ -109,10 +109,8 @@ from ._visualize import (
     format_status,
     generate_html_dag,
     generate_mermaid_dag,
-    generate_plotly_dag,
     print_verification_summary,
     render_dag,
-    render_plotly_dag,
 )
 
 
@@ -191,9 +189,7 @@ __all__ = [
     "format_list",
     "generate_mermaid_dag",
     "generate_html_dag",
-    "generate_plotly_dag",
     "render_dag",
-    "render_plotly_dag",
     "print_verification_summary",
     # Convenience functions
     "list_runs",

scitex/verify/_visualize.py

@@ -22,10 +22,8 @@ from ._viz import (
     format_status,
     generate_html_dag,
     generate_mermaid_dag,
-    generate_plotly_dag,
     print_verification_summary,
     render_dag,
-    render_plotly_dag,
 )
 
 __all__ = [
@@ -38,9 +36,7 @@ __all__ = [
     "format_list",
     "generate_mermaid_dag",
     "generate_html_dag",
-    "generate_plotly_dag",
     "render_dag",
-    "render_plotly_dag",
     "print_verification_summary",
 ]
 

scitex/verify/_viz/__init__.py

@@ -7,7 +7,6 @@ Provides multiple visualization backends:
 - Terminal: Colored text output with status icons
 - Mermaid: Text-based diagrams for docs/GitHub
 - HTML: Interactive web visualization
-- Plotly: Interactive Python-based visualization (optional)
 """
 
 from ._colors import Colors, VerificationLevel
@@ -21,21 +20,6 @@ from ._format import (
 from ._mermaid import generate_html_dag, generate_mermaid_dag, render_dag
 from ._utils import print_verification_summary
 
-# Optional Plotly support
-try:
-    from ._plotly import generate_plotly_dag, render_plotly_dag
-
-    _HAS_PLOTLY = True
-except ImportError:
-    _HAS_PLOTLY = False
-
-    def generate_plotly_dag(*args, **kwargs):
-        raise ImportError("plotly required: pip install plotly")
-
-    def render_plotly_dag(*args, **kwargs):
-        raise ImportError("plotly required: pip install plotly")
-
-
 __all__ = [
     "Colors",
     "VerificationLevel",
@@ -48,8 +32,6 @@ __all__ = [
     "generate_html_dag",
     "render_dag",
     "print_verification_summary",
-    "generate_plotly_dag",
-    "render_plotly_dag",
 ]
 
 

{scitex-2.17.0.dist-info → scitex-2.17.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scitex
-Version: 2.17.0
+Version: 2.17.4
 Summary: A comprehensive Python library for scientific computing and data analysis
 Project-URL: Homepage, https://github.com/ywatanabe1989/scitex-python
 Project-URL: Documentation, https://scitex.readthedocs.io
@@ -442,6 +442,7 @@ Requires-Dist: matplotlib; extra == 'utils'
 Requires-Dist: natsort; extra == 'utils'
 Requires-Dist: tqdm; extra == 'utils'
 Requires-Dist: xarray; extra == 'utils'
+Provides-Extra: verify
 Provides-Extra: web
 Requires-Dist: aiohttp; extra == 'web'
 Requires-Dist: anthropic; extra == 'web'