dingo-python 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

dingo/config/input_args.py

@@ -132,7 +132,6 @@ class InputArgs(BaseModel):
     output_path: str = "outputs/"
 
     log_level: str = "WARNING"
-    use_browser: bool = False
 
     dataset: DatasetArgs = DatasetArgs()
     executor: ExecutorArgs = ExecutorArgs()

dingo/exec/local.py

@@ -3,8 +3,6 @@ import copy
 import itertools
 import json
 import os
-import subprocess
-import sys
 import time
 import uuid
 from typing import Generator, List, Optional
@@ -154,30 +152,6 @@ class LocalExecutor(ExecProto):
         self.summary = self.summarize(self.summary)
         self.write_summary(self.summary.output_path, self.input_args, self.summary)
 
-        # Open browser if use_browser is True
-        if self.input_args.use_browser:
-            try:
-                # 使用 sys.executable 获取当前 Python 解释器路径
-                # 将命令作为列表传递，避免 shell 注入风险
-                cmd = [sys.executable, "-m", "dingo.run.vsl", "--input", self.summary.output_path]
-                log.warning(f"Opening browser with command: {' '.join(cmd)}")
-
-                # 使用 subprocess.Popen 在后台启动服务器
-                # start_new_session=True 让子进程独立运行，不受父进程退出影响
-                # stdout/stderr=DEVNULL 避免管道缓冲区死锁问题
-                subprocess.Popen(
-                    cmd,
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                    start_new_session=True
-                )
-
-                # 给服务器一点时间启动
-                time.sleep(1)
-                log.warning("Browser server started in background")
-            except Exception as e:
-                log.warning(f"Failed to open browser: {e}")
-
         return self.summary
 
     def evaluate_single_data(self, dingo_id: str, eval_fields: dict, eval_type: str, map_data: dict, eval_list: list) -> ResultInfo:

dingo/model/llm/agent/agent_article_fact_checker.py

@@ -55,13 +55,16 @@ Available Tools:
 
 2. arxiv_search: Search academic papers and verify metadata
    - Use for claims about research papers, academic publications
-   - Provides paper metadata: title, authors, abstract, publication date
-   - Authors in papers often indicate institutional affiliations in abstracts
-   - NOTE: Affiliations are in unstructured text, not dedicated fields
-   - Best for: paper titles, author names, publication dates, and
-     institutional claims when a related paper exists
-   - For institutional claims: use arxiv_search FIRST to find the paper,
-     then tavily_search to cross-verify affiliations
+   - Provides paper metadata: title, authors list, abstract, publication date
+   - Results may include 'affiliations_text': a compact author+institution string
+     parsed from the HTML paper page (e.g. "1 Shanghai AI Laboratory  2 Abaka AI").
+     When present, use it as the AUTHORITATIVE source for institutional claims —
+     it lists every author's institution, making affiliation verification direct.
+   - Best for: paper titles, author names, publication dates, institutional claims
+   - For institutional/attribution claims:
+     1. Call arxiv_search to find the paper
+     2. Check 'affiliations_text' in the result — if present, verify directly
+     3. If 'affiliations_text' is absent, fall back to tavily_search
 
 3. tavily_search: General web search for fact verification
    - Use for general factual claims, current events, companies, products
@@ -95,11 +98,12 @@ STEP 2: Verify Each Claim (Autonomous Tool Selection)
 
    Claim-Type Specific Rules:
    - INSTITUTIONAL/ATTRIBUTION claims (e.g., "released by X University and Y Lab"):
-     You MUST use arxiv_search FIRST to find the actual paper and check author
-     affiliations, THEN use tavily_search to cross-verify. Do NOT rely on
-     tavily_search alone for institutional claims — web sources often give
-     vague or incomplete attribution. The paper's author list is the
-     authoritative source for institutional affiliations.
+     You MUST use arxiv_search FIRST to find the actual paper.
+     Check the 'affiliations_text' field in the result: when present it lists every
+     author's institution (e.g. "1 Shanghai AI Laboratory  2 Abaka AI") and is the
+     AUTHORITATIVE source — use it directly to confirm or refute the claim.
+     If 'affiliations_text' is absent, fall back to tavily_search to cross-verify.
+     Do NOT rely on tavily_search alone — web sources often give vague attribution.
      For CHINESE institution names: translate to English before arxiv_search
      (e.g., "清华大学" → "Tsinghua University", "达摩院" → "Alibaba DAMO Academy",
       "上海人工智能实验室" → "Shanghai AI Laboratory")
@@ -278,6 +282,12 @@ Verdict Rules:
 - FALSE: Found specific evidence CONTRADICTING the claim
 - UNVERIFIABLE: Could not find clear confirming OR contradicting evidence
 
+For INSTITUTIONAL/ATTRIBUTION claims (e.g. "paper released by X University"):
+  Use arxiv_search first. If the result contains an 'affiliations_text' field,
+  it lists every author's institution (e.g. "1 Shanghai AI Lab  2 MIT") and is
+  the authoritative source — use it to confirm or refute the claim directly.
+  Fall back to tavily_search only when 'affiliations_text' is absent.
+
 CRITICAL: Start with search, then produce JSON only. No text outside the JSON."""
 
     @classmethod

dingo/model/llm/agent/tools/arxiv_search.py

@@ -15,6 +15,9 @@ Configuration:
     rate_limit_delay: Delay between requests in seconds (default: 3.0)
     timeout: Request timeout in seconds (default: 30)
     api_key: Not required for arXiv (public API)
+    fetch_affiliations: Fetch author+institution text from arXiv HTML paper page (default: False).
+        When enabled, adds an ``affiliations_text`` field to each result by scraping
+        the ``ltx_authors`` section.  Silently skipped for papers without HTML version.
 """
 
 import re
@@ -22,6 +25,7 @@ import threading
 import time
 from typing import Any, Dict, List, Optional
 
+import requests as _requests
 from pydantic import Field
 
 from dingo.io.input import RequiredField
@@ -38,6 +42,14 @@ class ArxivConfig(ToolConfig):
     sort_order: str = Field(default="descending", pattern="^(ascending|descending)$")
     rate_limit_delay: float = Field(default=3.0, ge=0.0)
     timeout: int = Field(default=30, ge=1)
+    fetch_affiliations: bool = Field(
+        default=False,
+        description=(
+            "Fetch author+institution text from arXiv HTML page for each result. "
+            "Adds 'affiliations_text' field. Requires one extra HTTP request per result. "
+            "Enable for institutional/attribution claim verification."
+        ),
+    )
 
 
 @tool_register
@@ -99,9 +111,14 @@ class ArxivSearch(BaseTool):
     name = "arxiv_search"
     description = (
         "Search arXiv for academic papers by ID, DOI, title, or author. "
-        "Returns comprehensive paper metadata including title, authors, abstract, "
-        "publication date, PDF URL, and citations. Useful for verifying academic "
-        "claims, finding research papers, and checking paper details."
+        "Returns paper metadata: title, authors list, abstract, publication date, "
+        "PDF URL, and categories. "
+        "When fetch_affiliations is enabled, results also include 'affiliations_text': "
+        "a compact author+institution string parsed from the HTML paper page "
+        "(e.g. '1 Shanghai AI Laboratory  2 Abaka AI  3 2077AI'), which is the "
+        "authoritative source for institutional attribution claims. "
+        "Use this tool for verifying claims about academic papers, author names, "
+        "publication dates, and institutional/organizational affiliations."
     )
     config: ArxivConfig = ArxivConfig()
 
@@ -216,9 +233,23 @@ class ArxivSearch(BaseTool):
 
             # Execute search and collect results
             results = []
+            entry_ids = []
             client = arxiv.Client()
             for paper in client.results(search):
                 results.append(cls._format_paper(paper))
+                entry_ids.append(paper.entry_id)
+
+            # Optionally enrich results with author+institution text from HTML pages.
+            # The arXiv Atom API rarely includes affiliation data; the HTML page is
+            # the only reliable machine-readable source.
+            if cls.config.fetch_affiliations and results:
+                for i, entry_id in enumerate(entry_ids):
+                    html_url = entry_id.replace('/abs/', '/html/')
+                    affiliations_text = cls._fetch_html_affiliations(
+                        html_url, timeout=cls.config.timeout
+                    )
+                    if affiliations_text is not None:
+                        results[i]['affiliations_text'] = affiliations_text
 
             # Format response
             result = {
@@ -241,8 +272,8 @@ class ArxivSearch(BaseTool):
                 error_msg = "Search request timed out"
             elif "network" in error_str or "connection" in error_str:
                 error_msg = "Network connection error"
-            elif "rate limit" in error_str:
-                error_msg = "Rate limit exceeded"
+            elif "rate limit" in error_str or "429" in error_str:
+                error_msg = "Rate limit exceeded (HTTP 429) — arXiv API throttled this request"
             else:
                 error_msg = f"Search failed: {type(e).__name__}"
 
@@ -458,6 +489,43 @@ class ArxivSearch(BaseTool):
             'dois': dois
         }
 
+    @classmethod
+    def _fetch_html_affiliations(cls, html_url: str, timeout: int = 15) -> Optional[str]:
+        """
+        Fetch author+institution text from an arXiv HTML paper page.
+
+        Extracts the ``ltx_authors`` div from the LaTeXML-rendered HTML page,
+        which contains author names with footnoted institution identifiers
+        (e.g. "1 Shanghai AI Laboratory  2 Abaka AI").
+
+        Args:
+            html_url: Full URL, e.g. ``https://arxiv.org/html/2412.07626v2``.
+            timeout: HTTP request timeout in seconds.
+
+        Returns:
+            Cleaned plain-text of the ``ltx_authors`` section, or ``None`` if
+            unavailable (no HTML version, network error, or missing element).
+        """
+        try:
+            resp = _requests.get(
+                html_url,
+                headers={"user-agent": "dingo-arxiv-tool/1.0"},
+                timeout=timeout,
+            )
+            if resp.status_code != 200:
+                log.debug("arXiv HTML page unavailable (%d): %s", resp.status_code, html_url)
+                return None
+            match = re.search(r'class="ltx_authors"[^>]*>(.*?)</div>', resp.text, re.DOTALL)
+            if not match:
+                log.debug("ltx_authors section not found in HTML page: %s", html_url)
+                return None
+            text = re.sub(r'<[^>]+>', ' ', match.group(1))
+            text = re.sub(r'\s+', ' ', text).strip()
+            return text if text else None
+        except Exception as exc:
+            log.debug("Failed to fetch HTML affiliations from %s: %s", html_url, exc)
+            return None
+
     @classmethod
     def validate_config(cls):
         """

dingo/run/cli.py

@@ -1,41 +1,281 @@
 import argparse
 import json
-import os
+import sys
 
 import prettytable as pt
 
 from dingo.config import InputArgs
 from dingo.exec import Executor
 from dingo.model import Model
-from dingo.utils import log
+
+EXIT_OK = 0
+EXIT_CONFIG_ERROR = 1
+EXIT_EVAL_ERROR = 2
+EXIT_IO_ERROR = 3
 
 
 def parse_args():
-    parser = argparse.ArgumentParser("dingo run with local script. (CLI)")
+    parser = argparse.ArgumentParser(
+        prog="dingo",
+        description="Dingo: A Comprehensive AI Data, Model and Application Quality Evaluation Tool",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # --- dingo eval ---
+    eval_parser = subparsers.add_parser("eval", help="Run data quality evaluation")
+    eval_parser.add_argument(
+        "-i", "--input",
+        type=str,
+        required=True,
+        help="Path to JSON config file",
+    )
+    eval_parser.add_argument(
+        "--json",
+        action="store_true",
+        default=False,
+        help="Output result as JSON to stdout (for agent/automation consumption)",
+    )
+
+    # --- dingo info ---
+    info_parser = subparsers.add_parser("info", help="List available evaluators and rule groups")
+    info_parser.add_argument(
+        "--rules", action="store_true", help="List rule-based evaluators",
+    )
+    info_parser.add_argument(
+        "--llm", action="store_true", help="List LLM-based evaluators",
+    )
+    info_parser.add_argument(
+        "--groups", action="store_true", help="List rule groups",
+    )
+    info_parser.add_argument(
+        "--json",
+        action="store_true",
+        default=False,
+        help="Output as JSON",
+    )
+
+    # --- dingo serve ---
+    serve_parser = subparsers.add_parser("serve", help="Start MCP server for AI agent integration")
+    serve_parser.add_argument(
+        "--transport",
+        type=str,
+        choices=["sse", "stdio"],
+        default="sse",
+        help="MCP transport type (default: sse)",
+    )
+    serve_parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind (default: 0.0.0.0)",
+    )
+    serve_parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to listen on (default: 8000)",
+    )
+
+    # Backward compatibility: bare `dingo --input config.json`
     parser.add_argument(
-        "-i",
-        "--input",
+        "-i", "--input",
         type=str,
         default=None,
-        help="Please input config file path",
+        help=argparse.SUPPRESS,
     )
 
-    return parser.parse_args()
+    return parser.parse_args(), parser
 
 
 def get_config(path: str) -> dict:
     with open(path, 'r', encoding='utf-8') as f:
         data = json.load(f)
-
     return data
 
 
+def _json_error(error_type: str, message: str, exit_code: int):
+    """Output error as JSON and exit with the given code."""
+    json.dump({
+        "status": "error",
+        "error_type": error_type,
+        "message": message,
+    }, sys.stderr, indent=2, ensure_ascii=False)
+    sys.stderr.write("\n")
+    sys.exit(exit_code)
+
+
+def cmd_eval(args):
+    """Run evaluation from a config file."""
+    use_json = args.json
+
+    try:
+        input_data = get_config(args.input)
+    except FileNotFoundError:
+        if use_json:
+            _json_error("ConfigError", f"Config file not found: {args.input}", EXIT_IO_ERROR)
+        raise
+    except json.JSONDecodeError as e:
+        if use_json:
+            _json_error("ConfigError", f"Invalid JSON in {args.input}: {e}", EXIT_CONFIG_ERROR)
+        raise
+
+    try:
+        input_args = InputArgs(**input_data)
+    except Exception as e:
+        if use_json:
+            _json_error("ConfigError", f"Invalid config: {e}", EXIT_CONFIG_ERROR)
+        raise
+
+    try:
+        executor = Executor.exec_map["local"](input_args)
+        result = executor.execute()
+    except Exception as e:
+        if use_json:
+            _json_error("EvalError", str(e), EXIT_EVAL_ERROR)
+        raise
+
+    if use_json:
+        json.dump(result.to_dict(), sys.stdout, indent=2, ensure_ascii=False)
+        sys.stdout.write("\n")
+    else:
+        print(result)
+
+
+def cmd_info(args):
+    """List available evaluators and groups."""
+    Model.load_model()
+
+    show_all = not (args.rules or args.llm or args.groups)
+
+    info = {}
+
+    if show_all or args.rules:
+        rules = {}
+        for name, cls in sorted(Model.rule_name_map.items()):
+            metric_type = getattr(cls, 'metric_type', '')
+            groups = getattr(cls, 'group', [])
+            required = [f.value for f in getattr(cls, '_required_fields', [])]
+            rules[name] = {
+                "metric_type": metric_type,
+                "groups": groups,
+                "required_fields": required,
+            }
+        info["rules"] = rules
+
+    if show_all or args.llm:
+        llm_evals = {}
+        for name, cls in sorted(Model.llm_name_map.items()):
+            required = [f.value for f in getattr(cls, '_required_fields', [])]
+            llm_evals[name] = {
+                "required_fields": required,
+            }
+        info["llm_evaluators"] = llm_evals
+
+    if show_all or args.groups:
+        groups = {}
+        for group_name, rule_list in sorted(Model.rule_groups.items()):
+            groups[group_name] = [cls.__name__ for cls in rule_list]
+        info["groups"] = groups
+
+    if args.json:
+        json.dump(info, sys.stdout, indent=2, ensure_ascii=False)
+        sys.stdout.write("\n")
+    else:
+        _print_info_table(info)
+
+
+def _print_info_table(info):
+    """Pretty-print evaluator info as tables."""
+    if "rules" in info:
+        table = pt.PrettyTable()
+        table.field_names = ["Rule", "Metric Type", "Groups", "Required Fields"]
+        table.align = "l"
+        for name, meta in info["rules"].items():
+            table.add_row([
+                name,
+                meta["metric_type"],
+                ", ".join(meta["groups"]) if meta["groups"] else "-",
+                ", ".join(meta["required_fields"]) if meta["required_fields"] else "-",
+            ])
+        print(f"\n=== Rule Evaluators ({len(info['rules'])}) ===")
+        print(table)
+
+    if "llm_evaluators" in info:
+        table = pt.PrettyTable()
+        table.field_names = ["LLM Evaluator", "Required Fields"]
+        table.align = "l"
+        for name, meta in info["llm_evaluators"].items():
+            table.add_row([
+                name,
+                ", ".join(meta["required_fields"]) if meta["required_fields"] else "-",
+            ])
+        print(f"\n=== LLM Evaluators ({len(info['llm_evaluators'])}) ===")
+        print(table)
+
+    if "groups" in info:
+        table = pt.PrettyTable()
+        table.field_names = ["Group", "Rules"]
+        table.align = "l"
+        table.max_width["Rules"] = 80
+        for group_name, rule_names in info["groups"].items():
+            table.add_row([group_name, ", ".join(rule_names)])
+        print(f"\n=== Rule Groups ({len(info['groups'])}) ===")
+        print(table)
+
+
+def cmd_serve(args):
+    """Start the MCP server for AI agent integration."""
+    import importlib.util
+    import os
+
+    project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    mcp_server_path = os.path.join(project_root, "mcp_server.py")
+
+    if not os.path.exists(mcp_server_path):
+        print(f"Error: mcp_server.py not found at {mcp_server_path}", file=sys.stderr)
+        print("Make sure you are running from the dingo project directory.", file=sys.stderr)
+        sys.exit(1)
+
+    spec = importlib.util.spec_from_file_location("mcp_server", mcp_server_path)
+    mcp_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mcp_module)
+
+    mcp = mcp_module.mcp
+
+    print(f"Starting Dingo MCP server (transport={args.transport})")
+    print("Available tools: run_dingo_evaluation, list_dingo_components, get_rule_details, "
+          "get_llm_details, get_prompt_details, run_quick_evaluation")
+
+    if args.transport == "sse":
+        mcp.settings.host = args.host
+        mcp.settings.port = args.port
+        print(f"Listening on {args.host}:{args.port}")
+        mcp.run(transport="sse")
+    else:
+        mcp.run(transport="stdio")
+
+
+def main():
+    args, parser = parse_args()
+
+    # Backward compatibility: `dingo --input config.json` (no subcommand)
+    if args.command is None and args.input:
+        input_data = get_config(args.input)
+        input_args = InputArgs(**input_data)
+        executor = Executor.exec_map["local"](input_args)
+        result = executor.execute()
+        print(result)
+        return
+
+    if args.command == "eval":
+        cmd_eval(args)
+    elif args.command == "info":
+        cmd_info(args)
+    elif args.command == "serve":
+        cmd_serve(args)
+    else:
+        parser.print_help()
+
+
 if __name__ == "__main__":
-    args = parse_args()
-    input_data = get_config(args.input)
-    # print(args.input)
-    # print(input_data)
-    input_args = InputArgs(**input_data)
-    executor = Executor.exec_map["local"](input_args)
-    result = executor.execute()
-    print(result)
+    main()

dingo/utils/exception.py

@@ -1,28 +1,26 @@
-from fastapi import HTTPException
-
 # tokens
 
 
-class TokensException(HTTPException):
+class TokensException(Exception):
     pass
 
 
 class ExceedMaxTokens(TokensException):
-    status_code = 400
 
     def __init__(self, detail="Exceeded maximum allowed tokens."):
         self.detail = detail
+        super().__init__(detail)
 
 
 # convert
 
 
-class ConvertError(HTTPException):
+class ConvertError(Exception):
     pass
 
 
 class ConvertJsonError(ConvertError):
-    status_code = 500
 
     def __init__(self, detail="Failed to convert JSON data."):
         self.detail = detail
+        super().__init__(detail)