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

scitex/cli/verify.py

@@ -262,13 +262,12 @@ def verify_chain_cmd(target_file, verbose, mermaid, as_json):
 @click.option("--session", "-s", help="Session ID to visualize")
 @click.option("--file", "-f", "target_file", help="Target file to trace chain")
 @click.option("--title", "-t", default="Verification DAG", help="Title for output")
-@click.option("--plotly", "-p", is_flag=True, help="Use Plotly (interactive)")
-def render_cmd(output_path, session, target_file, title, plotly):
+def render_cmd(output_path, session, target_file, title):
     """
     Render verification DAG to file (HTML, PNG, SVG, or Mermaid).
 
     The output format is determined by the file extension:
-    - .html: Interactive HTML (Mermaid.js or Plotly with --plotly)
+    - .html: Interactive HTML with Mermaid.js
     - .png: PNG image
     - .svg: SVG image
     - .mmd: Raw Mermaid code
@@ -276,7 +275,6 @@ def render_cmd(output_path, session, target_file, title, plotly):
     \b
     Examples:
       scitex verify render dag.html --file ./results/fig.png
-      scitex verify render dag.html --file ./results/fig.png --plotly
       scitex verify render dag.png --session 2025Y-11M-18D-09h12m03s
     """
     try:
@@ -284,24 +282,14 @@ def render_cmd(output_path, session, target_file, title, plotly):
             click.secho("Error: Specify --session or --file", fg="red", err=True)
             sys.exit(1)
 
-        if plotly:
-            from scitex.verify import render_plotly_dag
+        from scitex.verify import render_dag
 
-            result_path = render_plotly_dag(
-                output_path=output_path,
-                session_id=session,
-                target_file=target_file,
-                title=title,
-            )
-        else:
-            from scitex.verify import render_dag
-
-            result_path = render_dag(
-                output_path=output_path,
-                session_id=session,
-                target_file=target_file,
-                title=title,
-            )
+        result_path = render_dag(
+            output_path=output_path,
+            session_id=session,
+            target_file=target_file,
+            title=title,
+        )
         click.secho(f"Rendered to: {result_path}", fg="green")
 
     except Exception as e:
@@ -433,25 +421,34 @@ def mcp(ctx):
 
 
 @mcp.command("list-tools")
-def list_tools():
-    """
-    List available MCP tools for verification.
-
-    \b
-    Example:
-      scitex verify mcp list-tools
-    """
+@click.option("-v", "--verbose", count=True, help="-v params, -vv returns")
+def list_tools(verbose):
+    """List available MCP tools for verification."""
     click.secho("Verify MCP Tools", fg="cyan", bold=True)
     click.echo()
+    # (name, desc, params, returns)
     tools = [
-        ("verify_list", "List all tracked runs with verification status"),
-        ("verify_run", "Verify a specific session run"),
-        ("verify_chain", "Verify dependency chain for a target file"),
-        ("verify_status", "Show verification status (like git status)"),
-        ("verify_stats", "Show database statistics"),
+        ("verify_list", "List tracked runs", "limit=50, status_filter=None", "JSON"),
+        ("verify_run", "Verify a session run", "session_or_path: str", "JSON"),
+        ("verify_chain", "Verify dependency chain", "target_file: str", "JSON"),
+        ("verify_status", "Show status (like git status)", "", "JSON"),
+        ("verify_stats", "Show database statistics", "", "JSON"),
+        (
+            "verify_mermaid",
+            "Generate Mermaid DAG",
+            "session_id=None, target_file=None",
+            "str",
+        ),
     ]
-    for name, desc in tools:
-        click.echo(f"  {name}: {desc}")
+    for name, desc, params, returns in tools:
+        click.secho(f"  {name}", fg="green", bold=True, nl=False)
+        click.echo(f": {desc}")
+        if verbose >= 1 and params:
+            click.echo(f"    params: {params}")
+        if verbose >= 2:
+            click.echo(f"    returns: {returns}")
+        if verbose >= 1:
+            click.echo()
 
 
 @verify.command("list-python-apis")

scitex/plt/__init__.py

@@ -75,8 +75,8 @@ if _FIGRECIPE_AVAILABLE:
     from figrecipe import (
         compose,
         crop,
-        edit,
         extract_data,
+        gui,
         info,
         list_presets,
         load_style,
@@ -87,11 +87,17 @@ if _FIGRECIPE_AVAILABLE:
         validate,
     )
 
+    # Backward compatibility alias
+    edit = gui
+
     # Internal imports (not part of figrecipe public API)
     from figrecipe._api._notebook import enable_svg
     from figrecipe._api._seaborn_proxy import sns
     from figrecipe._api._style_manager import STYLE, apply_style
-    from figrecipe._composition import align_panels, distribute_panels, smart_align
+    from figrecipe._composition import align_panels, align_smart, distribute_panels
+
+    # Backward compatibility alias
+    smart_align = align_smart
     from figrecipe._graph_presets import get_preset as get_graph_preset
     from figrecipe._graph_presets import list_presets as list_graph_presets
     from figrecipe._graph_presets import register_preset as register_graph_preset
@@ -120,11 +126,13 @@ else:
     validate = _not_available
     extract_data = _not_available
     info = _not_available
-    edit = _not_available
+    gui = _not_available
+    edit = _not_available  # Backward compatibility alias
     compose = _not_available
     align_panels = _not_available
     distribute_panels = _not_available
-    smart_align = _not_available
+    align_smart = _not_available
+    smart_align = _not_available  # Backward compatibility alias
     sns = None
     enable_svg = _not_available
     get_graph_preset = _not_available
@@ -438,7 +446,8 @@ __all__ = [
     "validate",
     "extract_data",
     "info",
-    "edit",
+    "gui",
+    "edit",  # Backward compatibility alias for gui
     # Style management
     "STYLE",
     "load_style",
@@ -449,7 +458,8 @@ __all__ = [
     "compose",
     "align_panels",
     "distribute_panels",
-    "smart_align",
+    "align_smart",
+    "smart_align",  # Backward compatibility alias for align_smart
     # Graph visualization
     "draw_graph",
     "get_graph_preset",

scitex/scholar/url_finder/.tmp/open_url/KNOWN_RESOLVERS.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-08-01 13:15:00"
+# Author: Claude
+# File: KNOWN_RESOLVERS.py
+
+"""
+Known OpenURL resolvers from various institutions worldwide.
+
+This module contains a curated list of OpenURL resolvers used by
+academic institutions for accessing scholarly content.
+
+Sources:
+- Zotero OpenURL Resolver Directory: https://www.zotero.org/openurl_resolvers
+- Individual institution library websites
+- Common resolver patterns
+"""
+
+from typing import Dict, List, Optional
+
+# Major OpenURL resolver vendors
+RESOLVER_VENDORS = {
+    "ExLibris": {
+        "patterns": ["sfx", "exlibrisgroup.com"],
+        "description": "Ex Libris SFX resolver (very common)"
+    },
+    "SerialsSolutions": {
+        "patterns": ["serialssolutions.com", "360link"],
+        "description": "ProQuest SerialsSolutions 360 Link"
+    },
+    "EBSCO": {
+        "patterns": ["ebscohost.com/openurlresolver", "linkssource.ebsco.com"],
+        "description": "EBSCO Full Text Finder"
+    },
+    "OCLC": {
+        "patterns": ["worldcat.org", "oclc.org"],
+        "description": "OCLC WorldCat resolver"
+    },
+    "Ovid": {
+        "patterns": ["ovid.com", "linksolver"],
+        "description": "Ovid LinkSolver"
+    }
+}
+
+# Known institutional OpenURL resolvers
+KNOWN_RESOLVERS: Dict[str, Dict[str, str]] = {
+    # United States
+    "Harvard University": {
+        "url": "https://sfx.hul.harvard.edu/sfx_local",
+        "country": "US",
+        "vendor": "ExLibris"
+    },
+    "MIT": {
+        "url": "https://owens.mit.edu/sfx_local",
+        "country": "US",
+        "vendor": "ExLibris"
+    },
+    "Stanford University": {
+        "url": "https://stanford.idm.oclc.org/login?url=",
+        "country": "US",
+        "vendor": "OCLC"
+    },
+    "Yale University": {
+        "url": "https://yale.idm.oclc.org/login?url=",
+        "country": "US",
+        "vendor": "OCLC"
+    },
+    "University of California, Berkeley": {
+        "url": "https://ucelinks.cdlib.org:8443/sfx_ucb",
+        "country": "US",
+        "vendor": "ExLibris"
+    },
+    "UCLA": {
+        "url": "https://ucelinks.cdlib.org:8443/sfx_ucla",
+        "country": "US",
+        "vendor": "ExLibris"
+    },
+    "Columbia University": {
+        "url": "https://resolver.library.columbia.edu/openurl",
+        "country": "US",
+        "vendor": "SerialsSolutions"
+    },
+    "Princeton University": {
+        "url": "https://princeton.idm.oclc.org/login?url=",
+        "country": "US",
+        "vendor": "OCLC"
+    },
+    "University of Chicago": {
+        "url": "https://proxy.uchicago.edu/login?url=",
+        "country": "US",
+        "vendor": "Custom"
+    },
+    "Johns Hopkins": {
+        "url": "https://openurl.library.jhu.edu",
+        "country": "US",
+        "vendor": "Custom"
+    },
+    
+    # United Kingdom
+    "University of Oxford": {
+        "url": "https://fs.oxfordjournals.org/openurl",
+        "country": "UK",
+        "vendor": "Custom"
+    },
+    "University of Cambridge": {
+        "url": "https://cambridge.idm.oclc.org/login?url=",
+        "country": "UK",
+        "vendor": "OCLC"
+    },
+    "Imperial College London": {
+        "url": "https://imperial.idm.oclc.org/login?url=",
+        "country": "UK",
+        "vendor": "OCLC"
+    },
+    "UCL": {
+        "url": "https://ucl.idm.oclc.org/login?url=",
+        "country": "UK",
+        "vendor": "OCLC"
+    },
+    "University of Edinburgh": {
+        "url": "https://discovered.ed.ac.uk/openurl",
+        "country": "UK",
+        "vendor": "Custom"
+    },
+    
+    # Canada
+    "University of Toronto": {
+        "url": "https://myaccess.library.utoronto.ca/login?url=",
+        "country": "CA",
+        "vendor": "Custom"
+    },
+    "McGill University": {
+        "url": "https://mcgill.on.worldcat.org/atoztitles/link",
+        "country": "CA",
+        "vendor": "OCLC"
+    },
+    "University of British Columbia": {
+        "url": "https://ubc.summon.serialssolutions.com/link",
+        "country": "CA",
+        "vendor": "SerialsSolutions"
+    },
+    
+    # Australia
+    "University of Melbourne": {
+        "url": "https://unimelb.hosted.exlibrisgroup.com/sfxlcl41",
+        "country": "AU",
+        "vendor": "ExLibris"
+    },
+    "University of Sydney": {
+        "url": "https://ap01.alma.exlibrisgroup.com/view/uresolver/61USYD_INST/openurl",
+        "country": "AU",
+        "vendor": "ExLibris"
+    },
+    "Australian National University": {
+        "url": "https://anu.hosted.exlibrisgroup.com/primo-explore/openurl",
+        "country": "AU",
+        "vendor": "ExLibris"
+    },
+    "University of Queensland": {
+        "url": "https://uq.summon.serialssolutions.com/link",
+        "country": "AU",
+        "vendor": "SerialsSolutions"
+    },
+    "Monash University": {
+        "url": "https://monash.hosted.exlibrisgroup.com/sfx_local",
+        "country": "AU",
+        "vendor": "ExLibris"
+    },
+    
+    # Germany
+    "Max Planck Society": {
+        "url": "http://sfx.mpg.de/sfx_local",
+        "country": "DE",
+        "vendor": "ExLibris"
+    },
+    "University of Munich (LMU)": {
+        "url": "https://sfx.bib.uni-muenchen.de/sfx_lmu",
+        "country": "DE",
+        "vendor": "ExLibris"
+    },
+    "Heidelberg University": {
+        "url": "https://sfx.bib.uni-heidelberg.de/sfx_heidelberg",
+        "country": "DE",
+        "vendor": "ExLibris"
+    },
+    
+    # Netherlands
+    "University of Amsterdam": {
+        "url": "https://vu-nl.idm.oclc.org/login?url=",
+        "country": "NL",
+        "vendor": "OCLC"
+    },
+    "Delft University of Technology": {
+        "url": "https://tudelft.idm.oclc.org/login?url=",
+        "country": "NL",
+        "vendor": "OCLC"
+    },
+    
+    # France
+    "Sorbonne University": {
+        "url": "https://accesdistant.sorbonne-universite.fr/login?url=",
+        "country": "FR",
+        "vendor": "Custom"
+    },
+    "École Polytechnique": {
+        "url": "https://portail.polytechnique.edu/openurl",
+        "country": "FR",
+        "vendor": "Custom"
+    },
+    
+    # Switzerland
+    "ETH Zurich": {
+        "url": "https://www.library.ethz.ch/openurl",
+        "country": "CH",
+        "vendor": "Custom"
+    },
+    "EPFL": {
+        "url": "https://sfx.epfl.ch/sfx_local",
+        "country": "CH",
+        "vendor": "ExLibris"
+    },
+    
+    # Japan
+    "University of Tokyo": {
+        "url": "https://vs2ga4mq9g.search.serialssolutions.com",
+        "country": "JP",
+        "vendor": "SerialsSolutions"
+    },
+    "Kyoto University": {
+        "url": "https://kuline.kulib.kyoto-u.ac.jp/portal/openurl",
+        "country": "JP",
+        "vendor": "Custom"
+    },
+    
+    # Singapore
+    "National University of Singapore": {
+        "url": "https://libproxy.nus.edu.sg/login?url=",
+        "country": "SG",
+        "vendor": "Custom"
+    },
+    "Nanyang Technological University": {
+        "url": "https://ap01.alma.exlibrisgroup.com/view/uresolver/65NTU_INST/openurl",
+        "country": "SG",
+        "vendor": "ExLibris"
+    },
+    
+    # China
+    "Tsinghua University": {
+        "url": "http://sfx.lib.tsinghua.edu.cn/sfx_local",
+        "country": "CN",
+        "vendor": "ExLibris"
+    },
+    "Peking University": {
+        "url": "http://sfx.lib.pku.edu.cn/sfx_pku",
+        "country": "CN",
+        "vendor": "ExLibris"
+    },
+    
+    # South Korea
+    "Seoul National University": {
+        "url": "https://sfx.snu.ac.kr/sfx_local",
+        "country": "KR",
+        "vendor": "ExLibris"
+    },
+    "KAIST": {
+        "url": "https://library.kaist.ac.kr/openurl",
+        "country": "KR",
+        "vendor": "Custom"
+    },
+    
+    # Brazil
+    "University of São Paulo": {
+        "url": "http://www.buscaintegrada.usp.br/openurl",
+        "country": "BR",
+        "vendor": "Custom"
+    },
+    
+    # Mexico
+    "UNAM": {
+        "url": "https://pbidi.unam.mx/login?url=",
+        "country": "MX",
+        "vendor": "Custom"
+    },
+    
+    # India
+    "IIT Delhi": {
+        "url": "https://libproxy.iitd.ac.in/login?url=",
+        "country": "IN",
+        "vendor": "Custom"
+    },
+    "Indian Institute of Science": {
+        "url": "https://library.iisc.ac.in/openurl",
+        "country": "IN",
+        "vendor": "Custom"
+    }
+}
+
+# Generic OpenURL resolver patterns
+GENERIC_PATTERNS = [
+    # ExLibris SFX patterns
+    r"https?://[^/]+/sfx[^/]*",
+    r"https?://sfx\.[^/]+",
+    r"https?://[^/]+\.exlibrisgroup\.com",
+    
+    # SerialsSolutions patterns
+    r"https?://[^/]+\.serialssolutions\.com",
+    r"https?://[^/]+/360link",
+    
+    # OCLC patterns
+    r"https?://[^/]+\.idm\.oclc\.org",
+    r"https?://[^/]+\.worldcat\.org",
+    
+    # Common proxy patterns
+    r"https?://[^/]+/login\?url=",
+    r"https?://libproxy\.[^/]+",
+    r"https?://proxy\.[^/]+",
+    
+    # OpenURL patterns
+    r"https?://[^/]+/openurl",
+    r"https?://[^/]+/openurlresolver",
+]
+
+
+def get_resolver_by_institution(institution_name: str) -> Optional[Dict[str, str]]:
+    """
+    Get OpenURL resolver information by institution name.
+    
+    Args:
+        institution_name: Name of the institution
+        
+    Returns:
+        Dict with 'url', 'country', and 'vendor' if found, None otherwise
+    """
+    # Try exact match first
+    if institution_name in KNOWN_RESOLVERS:
+        return KNOWN_RESOLVERS[institution_name].copy()
+    
+    # Try case-insensitive match
+    institution_lower = institution_name.lower()
+    for name, info in KNOWN_RESOLVERS.items():
+        if name.lower() == institution_lower:
+            return info.copy()
+    
+    # Try partial match
+    for name, info in KNOWN_RESOLVERS.items():
+        if institution_lower in name.lower() or name.lower() in institution_lower:
+            return info.copy()
+    
+    return None
+
+
+def get_resolvers_by_country(country_code: str) -> Dict[str, Dict[str, str]]:
+    """
+    Get all OpenURL resolvers for a specific country.
+    
+    Args:
+        country_code: Two-letter country code (e.g., 'US', 'UK', 'AU')
+        
+    Returns:
+        Dict of institution names to resolver info
+    """
+    country_code = country_code.upper()
+    return {
+        name: info 
+        for name, info in KNOWN_RESOLVERS.items() 
+        if info.get('country') == country_code
+    }
+
+
+def get_resolvers_by_vendor(vendor_name: str) -> Dict[str, Dict[str, str]]:
+    """
+    Get all OpenURL resolvers using a specific vendor.
+    
+    Args:
+        vendor_name: Vendor name (e.g., 'ExLibris', 'OCLC')
+        
+    Returns:
+        Dict of institution names to resolver info
+    """
+    return {
+        name: info 
+        for name, info in KNOWN_RESOLVERS.items() 
+        if info.get('vendor', '').lower() == vendor_name.lower()
+    }
+
+
+def validate_resolver_url(url: str) -> bool:
+    """
+    Check if a URL looks like a valid OpenURL resolver.
+    
+    Args:
+        url: URL to validate
+        
+    Returns:
+        True if URL matches known resolver patterns
+    """
+    import re
+
+    # Check against known resolver URLs
+    for info in KNOWN_RESOLVERS.values():
+        if url.startswith(info['url']):
+            return True
+    
+    # Check against generic patterns
+    for pattern in GENERIC_PATTERNS:
+        if re.match(pattern, url):
+            return True
+    
+    return False
+
+
+def get_all_resolvers() -> List[Dict[str, str]]:
+    """
+    Get all known resolvers as a list.
+    
+    Returns:
+        List of dicts with 'name', 'url', 'country', 'vendor'
+    """
+    return [
+        {
+            'name': name,
+            'url': info['url'],
+            'country': info.get('country', 'Unknown'),
+            'vendor': info.get('vendor', 'Unknown')
+        }
+        for name, info in KNOWN_RESOLVERS.items()
+    ]
+
+
+# Common test DOIs for different publishers
+TEST_DOIS = {
+    "Nature": "10.1038/nature12373",
+    "Science": "10.1126/science.1234567",
+    "Cell": "10.1016/j.cell.2020.01.001",
+    "Elsevier": "10.1016/j.neuroimage.2020.116584",
+    "Wiley": "10.1111/jnc.15327",
+    "Springer": "10.1007/s00401-021-02283-6",
+    "Oxford": "10.1093/brain/awaa123",
+    "IEEE": "10.1109/TPAMI.2020.2984611",
+    "ACS": "10.1021/acs.jmedchem.0c00606",
+    "PNAS": "10.1073/pnas.1921909117"
+}
+
+
+if __name__ == "__main__":
+    # Example usage
+    print(f"Total known resolvers: {len(KNOWN_RESOLVERS)}")
+    print(f"\nCountries represented: {len(set(info['country'] for info in KNOWN_RESOLVERS.values()))}")
+    print(f"Vendors: {set(info.get('vendor', 'Unknown') for info in KNOWN_RESOLVERS.values())}")
+    
+    # Example: Find resolver for an institution
+    resolver = get_resolver_by_institution("Harvard")
+    if resolver:
+        print(f"\nHarvard resolver: {resolver['url']}")
+    
+    # Example: Get all US resolvers
+    us_resolvers = get_resolvers_by_country("US")
+    print(f"\nUS institutions with resolvers: {len(us_resolvers)}")
+    
+    # Example: Get all ExLibris resolvers
+    exlibris = get_resolvers_by_vendor("ExLibris")
+    print(f"Institutions using ExLibris SFX: {len(exlibris)}")