qwen-sci 0.2.0__tar.gz → 0.2.2__tar.gz

{qwen_sci-0.2.0 → qwen_sci-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: qwen-sci
-Version: 0.2.0
+Version: 0.2.2
 Summary: Qwen-Sci multi-agent research workflow
 License-File: LICENSE
 Requires-Python: <3.13,>=3.12

{qwen_sci-0.2.0 → qwen_sci-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "qwen-sci"
-version = "0.2.0"
+version = "0.2.2"
 description = "Qwen-Sci multi-agent research workflow"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"
@@ -222,12 +222,15 @@ cache-dir = ".uv-cache"
 [tool.hatch.build.targets.wheel]
 packages = ["src"]
 
-[tool.hatch.build.targets.sdist]
-include = [
-  "/README.md",
-  "/README_CN.md",
-  "/scripts",
-  "/src",
-  "/run_*.sh",
-  "/environment.yml",
-]
+[tool.hatch.build.targets.sdist]
+include = [
+  "/README.md",
+  "/README_CN.md",
+  "/scripts",
+  "/src",
+  "/run_*.sh",
+  "/environment.yml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

qwen_sci-0.2.2/src/1.txt

@@ -0,0 +1 @@
+qwensci

qwen_sci-0.2.0/src/agents/blog_agent/README.md

@@ -1,299 +0,0 @@
-# Blog Agent
-
-AI-powered blog generation agent using OpenHands SDK. Generates high-quality technical blog articles from research projects (experiment_agent) with automated image generation and quality scoring.
-
-## Architecture
-
-```
-run.py (Entry)
-    │
-    ├─ Step 1: IdeaAgent      → Explore project, find papers, create outline
-    ├─ Step 2: WriteAgent      → Write blog + generate graph method files
-    ├─ Step 3: AnalyzeAgent    → Analyze & score (quality, SEO, E-E-A-T)
-    ├─ Step 4: RefineAgent      → Loop improvement (until score > 90 or 3 iterations)
-    └─ Step 5: ImageGen        → Generate images + replace <graphN> placeholders
-```
-
-## Project Structure
-
-```
-blog_agent/
-├── agent/
-│   └── new_base_agent.py      # BaseAgent using OpenHands SDK
-├── config/
-│   ├── config.yaml            # Configuration (API keys, settings)
-│   └── loader.py              # Config loader
-├── scripts/
-│   └── run.py                 # Main entry point
-├── skills/                    # 4 skill modules
-│   ├── workspace-navigator/  # Project exploration & paper search
-│   ├── blog-writer/          # Article writing
-│   ├── blog-analyze/         # Quality analysis & scoring
-│   └── blog-refine/          # Iterative improvement
-├── tools/                     # OpenHands format tools
-│   ├── search_core_tool.py          # Search knowledge graph for papers
-│   ├── search_paper_abstract_tool.py # Get paper abstract from Semantic Scholar
-│   ├── download_paper_pdf_tool.py   # Download paper PDF
-│   ├── count_words_tool.py           # Count words in markdown
-│   ├── gengraph.py                   # Image generation via AI
-│   ├── illustrate.py                  # High-level illustrate function
-│   └── ocr.py                        # OCR text removal
-└── utils/
-    ├── search_core.py           # Knowledge graph search utilities
-    ├── semantic_scholar.py      # Semantic Scholar API utilities
-    └── deeperaser.py           # Deep learning text removal
-```
-
-## Quick Start
-
-### Setup
-```bash
-1. cd <research-agent-root>/src/agents
-2. mkdir blog_agent
-```
-3. Put these files into that folder
-4. Move `run_blog.sh` to ResearchAgent root directory
-5. Fill in the `blog:` block in `src/config/default.yaml`
-6. (Optional) Place a complete `graph.db` knowledge graph at `<repo_root>/data/processed/graph.db`, or set `BLOG_GRAPH_DB_PATH` to its location
-7. (Optional) Edit `scripts/run.py` to change the `MODEL` parameter - this controls which model is actually used
-
-> **Important**: Blog Agent reads experiment outputs from `blog.source_workspace_root` in `src/config/default.yaml`, using `<source_workspace_root>/<project_name>` by default.
-
-### Run
-
-```bash
-cd <research-agent-root>
-
-# Run full pipeline
-qwensci blog --experiment <project_name>
-
-# Explicitly use an experiment workspace path
-qwensci blog --experiment <project_name> --source-workspace "${QWENSCI_WORKSPACE_ROOT}/<project_name>"
-
-# Resume from last checkpoint
-qwensci blog --experiment <project_name> --resume
-
-# Use an experiment workspace outside the default source path
-qwensci blog --experiment <project_name> --source-workspace /abs/path/to/experiment_workspace
-```
-
-## Resume / Checkpoint
-
-The agent saves its progress after each step to `workflow_status.json`. If the process is interrupted (e.g., network error, manual stop), you can resume from where it left off.
-
-### How It Works
-
-1. **Status File**: After completing each step, the agent saves progress to:
-   ```
-   workspaces/<project_name>/workflow_status.json
-   ```
-
-   Example content:
-   ```json
-   {
-     "experiment": "dcr_v1",
-     "current_step": 3,
-     "current_loop": 2,
-     "steps_completed": ["IDEAAgent", "WRITEAgent", "ANALYZEAgent", "REFINEAgent"],
-     "last_updated": "2026-03-09T10:30:00"
-   }
-   ```
-
-2. **Step Numbers**:
-   - Step 0: Initialized (not started)
-   - Step 1: IDEAAgent completed
-   - Step 2: WRITEAgent completed
-   - Step 3: ANALYZEAgent completed
-   - Step 4: REFINEAgent loop completed
-   - Step 5: Image generation completed
-
-3. **Resume Logic**: When `--resume` is passed, the agent reads `current_step` and skips all steps less than or equal to that value:
-   ```python
-   if resume:
-       start_step = status.get("current_step", 0)
-   ```
-
-### Example
-
-If the agent stops during Step 3 (ANALYZEAgent), the status file shows `current_step: 3`. Running with `--resume` will:
-- Skip Step 1 and Step 2 (re-executes but skips internally)
-- Continue from Step 3 onwards
-- Restart the REFINE loop if needed
-
-## Configuration
-
-All configuration is in the `blog:` block of `src/config/default.yaml`.
-
-### API Keys
-
-```yaml
-blog:
-  minimax:
-    api_key: "your-minimax-api-key"
-    base_url: "https://api.minimaxi.com/v1"
-
-  openai:
-    api_key: "your-open-ai-api-key"
-    base_url: "https://api-2.xi-ai.cn/v1"
-
-  gemini:
-    api_key: "your-gemini-api-key"
-    base_url: "https://api.xi-ai.cn/v1"
-```
-
-- **minimax**: Default LLM provider for agents
-- **openai**: Alternative LLM provider
-- **gemini**: Alternative LLM provider
-
-### Model Settings
-
-```yaml
-blog:
-  model: "MiniMax-M2.5"  # Default model for all agents
-```
-
-### Image Generation (gengraph)
-
-```yaml
-blog:
-  gengraph:
-    provider: "xiai"  # Image generation provider
-    api_key: "your-image-api-key"
-
-    providers:
-      xiai:
-        base_url: "https://api.xi-ai.cn/v1"
-        model: "gemini-3-pro-image-preview"
-      openrouter:
-        base_url: "https://openrouter.ai/api/v1"
-        model: "google/gemini-3-pro-image-preview"
-      bianxie:
-        base_url: "https://api.bianxie.ai/v1"
-        model: "gemini-3-pro-image-preview"
-      gemini:
-        base_url: "https://generativelanguage.googleapis.com/v1beta"
-        model: "gemini-3-pro-image-preview"
-```
-
-- **provider**: Which AI provider to use for generating academic figures
-- **providers**: Configuration for each available provider
-
-### OCR / Text Removal
-
-```yaml
-blog:
-  deeperaser:
-    use_cuda: false  # Whether to use GPU for DeepEraser (text removal from images)
-```
-
-- **use_cuda**: Set to `true` if you have NVIDIA GPU and want faster OCR processing
-
-### Semantic Scholar API
-
-```yaml
-blog:
-  semantic_scholar:
-    api_key: ""  # Required for Semantic Scholar fallback, abstract retrieval, and PDF download
-```
-
-- **api_key**: Required whenever the Blog Agent needs Semantic Scholar. Without a usable local graph and this key, the workflow enters workspace-only mode and cites only verifiable local evidence.
-
-### Literature Retrieval Fallback
-
-Blog Agent selects one retrieval mode at startup and writes the selection to
-`retrieval_status.json` in the blog workspace:
-
-1. **graph**: use a validated SQLite graph at `data/processed/graph.db` (or `BLOG_GRAPH_DB_PATH`), with Semantic Scholar available as an optional supplement.
-2. **semantic**: if the graph is missing, empty, corrupt, or lacks the required schema, skip graph search and use Semantic Scholar instead.
-3. **workspace**: if neither source is available, skip external paper tools and use only verifiable references from the source workspace.
-
-Use `BLOG_RETRIEVAL_MODE=auto` (default), `graph`, `semantic`, or `workspace` to express a preference. An unavailable dependency always falls back to the next safe mode rather than failing the Blog Agent conversation.
-
-### Blog Illustration
-
-```yaml
-blog:
-  illustrate:
-    only_gen_img: true  # true: only generate images, false: generate + OCR cleanup
-```
-
-- **only_gen_img**:
-  - `true`: Faster, skip OCR cleanup step
-  - `false`: Slower, but removes generated text from images using OCR
-
-### Adding New Model Providers
-
-To add support for new LLM providers, modify the `get_openhands_config` function in `agent/new_base_agent.py`:
-
-```python
-def get_openhands_config(model: str) -> dict:
-    if is_minimax_model(model):
-        return {
-            "api_key": MINIMAX_API_KEY,
-            "model": 'minimax/'+model,
-            "base_url": MINIMAX_API_BASE,
-        }
-    elif is_gemini_model(model):
-        return {
-            "api_key": GEMINI_API_KEY,
-            "model": 'gemini/'+model,
-            "base_url": GEMINI_API_BASE,
-        }
-    # Add new provider here
-    elif is_new_provider(model):
-        return {
-            "api_key": NEW_PROVIDER_API_KEY,
-            "model": 'new_provider/'+model,
-            "base_url": NEW_PROVIDER_API_BASE,
-        }
-    else:
-        # Default to OpenAI
-        return {
-            "api_key": OPENAI_API_KEY,
-            "model": model,
-            "base_url": OPENAI_API_BASE,
-        }
-```
-
-You also need to:
-1. Add the new provider to the `blog:` block in `src/config/default.yaml`
-2. Add model detection function (e.g., `is_new_provider`)
-
-## Workflow
-
-1. **IdeaAgent** - Explores source project, identifies key files and structure, searches academic papers for citation, creates outline
-2. **WriteAgent** - Writes blog article based on outline, creates `<graphN>` placeholders + graph method files (graph1.md, graph2.md, etc.)
-3. **AnalyzeAgent** - Scores article (0-100), provides improvement suggestions across 5 dimensions:
-   - Content quality
-   - SEO optimization
-   - E-E-A-T signals (Experience, Expertise, Authoritativeness, Trustworthiness)
-   - Technical elements
-   - AI citation readiness
-4. **RefineAgent** - Iteratively improves based on analysis (max 3 loops)
-5. **Image Generation** - Generates images from graph method files, replaces `<graphN>` placeholders with actual markdown images
-
-## Output
-
-After running, the following files are generated in `workspaces/<project_name>/`:
-
-```
-<project_name>/
-├── blog_idea.md        # Initial blog idea and outline
-├── blog_article.md    # Final blog article with images embedded
-├── blog_analysis.md   # Quality analysis report with score
-└── test_output/
-    ├── graph1.md     # Image method file 1 (description for AI)
-    ├── figure1.png   # Generated image 1
-    ├── graph2.md
-    ├── figure2.png
-    └── ...
-```
-
-## How It Works
-
-1. IdeaAgent explores project, searches papers via knowledge graph + Semantic Scholar, downloads PDFs
-2. WriteAgent creates article with `<graphN>` placeholders where images should go
-3. Each `<graphN>` corresponds to a `graph{N}.md` file describing what image to generate
-4. AnalyzeAgent scores the article and suggests improvements
-5. RefineAgent loops to improve until score > 90 or max iterations reached
-6. Images are generated from graph method files and placeholders are replaced

qwen_sci-0.2.0/src/agents/blog_agent/agent/llm_config.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Mapping, Optional
-
-from src.llm.provider_registry import (
-    get_default_provider_name,
-    require_model_capabilities,
-    resolve_model,
-    resolve_provider,
-    resolve_role_model,
-)
-
-
-def _as_mapping(value: Any) -> Mapping[str, Any]:
-    return value if isinstance(value, Mapping) else {}
-
-
-def resolve_blog_model(
-    project_config: Any,
-    model: Optional[str] = None,
-    provider: Optional[str] = None,
-) -> str:
-    blog_config = _as_mapping(_as_mapping(project_config).get("blog"))
-    configured_model = str(model or blog_config.get("model") or "").strip()
-    if configured_model:
-        return configured_model
-
-    configured_provider = str(provider or blog_config.get("provider") or "").strip()
-    if configured_provider or _as_mapping(project_config).get("llm"):
-        return resolve_role_model(
-            project_config,
-            "blog",
-            configured_provider or get_default_provider_name(project_config),
-        ).name
-    return "MiniMax-M2.5"
-
-
-def build_openhands_config(
-    project_config: Any,
-    model: Optional[str] = None,
-    provider: Optional[str] = None,
-) -> dict[str, str]:
-    blog_config = _as_mapping(project_config).get("blog")
-    blog_config = _as_mapping(blog_config)
-    configured_model = resolve_blog_model(project_config, model, provider)
-    resolved_provider_name = str(provider or blog_config.get("provider") or "").strip()
-
-    minimax_config = _as_mapping(blog_config.get("minimax"))
-    if not resolved_provider_name and "minimax" in configured_model.lower():
-        return {
-            "api_key": str(minimax_config.get("api_key") or ""),
-            "model": f"minimax/{configured_model}",
-            "base_url": str(
-                minimax_config.get("base_url") or "https://api.minimaxi.com/v1"
-            ),
-        }
-
-    gemini_config = _as_mapping(blog_config.get("gemini"))
-    if not resolved_provider_name and "gemini" in configured_model.lower():
-        return {
-            "api_key": str(gemini_config.get("api_key") or ""),
-            "model": f"gemini/{configured_model}",
-            "base_url": str(gemini_config.get("base_url") or ""),
-        }
-
-    openai_config = _as_mapping(blog_config.get("openai"))
-    if (
-        not resolved_provider_name
-        and configured_model.lower().startswith(("gpt", "o1", "o3", "o4"))
-        and (openai_config.get("api_key") or openai_config.get("base_url"))
-    ):
-        openai_provider = resolve_provider(project_config, "openai")
-        model_spec = require_model_capabilities(
-            resolve_model(project_config, configured_model, "openai"),
-            ["chat_completions"],
-            "Blog OpenHands text agent",
-        )
-        return {
-            "api_key": str(openai_config.get("api_key") or ""),
-            "model": f"openai/{model_spec.name}",
-            "base_url": str(openai_config.get("base_url") or openai_provider.base_url),
-        }
-
-    if resolved_provider_name or _as_mapping(project_config).get("llm"):
-        provider_spec = resolve_provider(
-            project_config,
-            resolved_provider_name or get_default_provider_name(project_config),
-        )
-        model_spec = (
-            resolve_model(project_config, configured_model, provider_spec.name)
-            if configured_model
-            else resolve_role_model(project_config, "blog", provider_spec.name)
-        )
-        require_model_capabilities(
-            model_spec,
-            ["chat_completions"],
-            "Blog OpenHands text agent",
-        )
-        return {
-            "api_key": provider_spec.api_key,
-            "model": f"{provider_spec.openhands_model_prefix}/{model_spec.name}",
-            "base_url": provider_spec.base_url,
-        }
-
-    return {
-        "api_key": str(openai_config.get("api_key") or ""),
-        "model": f"openai/{configured_model or 'gpt-5.5'}",
-        "base_url": str(openai_config.get("base_url") or ""),
-    }