recon-patent 0.2.0__tar.gz

recon_patent-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RECON Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

recon_patent-0.2.0/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: recon-patent
+Version: 0.2.0
+Summary: Terminal-native patent research CLI/TUI tool
+Author-email: Anubhav Anand <anubhav@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/anubhavanand/recon
+Project-URL: Repository, https://github.com/anubhavanand/recon
+Project-URL: Documentation, https://github.com/anubhavanand/recon#readme
+Project-URL: Issues, https://github.com/anubhavanand/recon/issues
+Keywords: patent,research,cli,tui,textual
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=1.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: Pillow>=10.0
+Requires-Dist: rapidfuzz>=3.0
+Requires-Dist: typer>=0.9
+Requires-Dist: fpdf2>=2.7
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: lxml>=5.0
+Requires-Dist: ddgs>=1.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Requires-Dist: pytest-cov>=5.0; extra == "test"
+Requires-Dist: psutil>=5.9; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: psutil>=5.9; extra == "dev"
+Dynamic: license-file
+
+# RECON — Terminal-Native Patent Research Tool
+
+**RECON** is a keyboard-first, terminal-native patent research tool. It aggregates patent data from multiple sources (USPTO, PatSnap, Google Patents, WIPO, Lens.org, EPO), presents results in a clean TUI or CLI, and provides scoring, citation graphs, export, and optional local-AI translation.
+
+## Features
+
+- **Multi-source search** — USPTO API, PatSnap API, Google Patents scraping, WIPO/Lens/EPO via DuckDuckGo + BeautifulSoup
+- **Source filtering** — Include/exclude sources via CLI `--source` or TUI `S` overlay
+- **Signal scoring** — Equal-weight 20-point signals (government grants, corporate investment, academic research, temporal recency, news/media)
+- **Live preview** — Three-tab detail pane (Info / Claims / Image) with keyboard navigation
+- **Citation graph** — ASCII tree view of forward/backward citations (scraped from Google Patents or mock data)
+- **Export** — JSON, CSV, BibTeX, Markdown, PDF
+- **Translation** — Optional local translation via Ollama (opt-in, Zero-AI default)
+- **Terminal-native** — No GUI, no Electron, no modal dialogs
+
+## Installation
+
+### Via PyPI (recommended)
+
+```bash
+pipx install recon-patent
+```
+
+### Via GitHub
+
+```bash
+pipx install git+https://github.com/anubhavaanand/recon.git
+```
+
+Ensure `~/.local/bin` is in your `PATH`.
+
+### Via install script (hacker method)
+
+```bash
+curl -sSL https://raw.githubusercontent.com/anubhavaanand/recon/main/install.sh | bash
+```
+
+### Via pip
+
+```bash
+pip install recon-patent
+```
+
+### From source
+
+```bash
+git clone https://github.com/anubhavaanand/recon.git
+cd recon
+pip install -e .
+```
+
+### Development
+
+```bash
+pip install -e ".[test,dev]"
+```
+
+## Quick Start
+
+### Launch the interactive TUI
+
+```bash
+recon
+```
+
+Type a query (e.g. `solid state battery`) and press Enter. Navigate results with `j`/`k`, open detail with Enter, switch tabs with `h`/`l`.
+
+### CLI search
+
+```bash
+recon search "sulfide electrolyte"
+```
+
+Filter by source:
+
+```bash
+recon search "quantum battery" --source uspto,patsnap,google
+```
+
+### End-to-end run with export
+
+```bash
+recon run "lithium anode" --export json
+```
+
+### View saved collection
+
+```bash
+recon collection list
+recon collection clear
+```
+
+### Manage API keys
+
+```bash
+recon config show
+recon config set --patsnap-key YOUR_KEY
+recon config test
+```
+
+### Export collection
+
+```bash
+recon export --format csv
+```
+
+Formats: `json`, `csv`, `bibtex`, `markdown`, `pdf`.
+
+## TUI Key Bindings
+
+| Key | Action |
+|-----|--------|
+| `↑`/`↓` `j`/`k` | Navigate results |
+| `Enter` | Open detail view |
+| `h`/`l` or `←`/`→` | Switch preview tab |
+| `/` | Focus search input |
+| `s` | Save patent to collection |
+| `e` | Export collection overlay |
+| `S` | Source filter overlay |
+| `c` | Toggle citation graph |
+| `t` | Toggle translation |
+| `r` | Reader mode |
+| `m` | Synthesis mode |
+| `?` | Help overlay |
+| `q` / `Esc` | Back / Quit |
+
+## Architecture
+
+```
+recon/
+├── cli/main.py          — Typer CLI (search, run, config, export, collection)
+├── core/
+│   ├── models.py        — PatentRecord, CrossReference dataclasses
+│   ├── search.py        — Multi-source search orchestration + source filtering
+│   ├── scoring.py       — Signal scoring (equal-weight algorithm)
+│   ├── arbitrage.py     — Arbitrage status calculation
+│   ├── citations.py     — Citation graph fetching (Google Patents scrape + mock)
+│   ├── translation.py   — Local Ollama translation with cache
+│   └── config.py        — Config management (.env + JSON)
+├── clients/
+│   ├── patent_apis.py   — USPTO, PatSnap, Google, WIPO, Lens, EPO clients
+│   ├── scrapers.py      — DDGS + BeautifulSoup scrapers (WIPO, Lens, EPO, Google)
+│   └── base.py          — BaseAsyncClient with rate-limit + backoff
+├── tui/
+│   ├── app.py           — Textual App + CSS
+│   ├── screens.py       — SearchScreen, DetailScreen, ReaderModeScreen, etc.
+│   └── widgets/         — ResultList, InfoTab, ClaimsTab, ImageTab, CitationTree
+├── storage/
+│   └── cache.py         — SQLite cache (search results, collection, translations)
+└── tests/               — 200+ tests (pytest)
+```
+
+## Configuration
+
+Keys are stored in `~/.config/recon/config.json` (chmod 600):
+
+| Variable | Source | Required |
+|----------|--------|----------|
+| `PATSNAP_API_KEY` | PatSnap | No (scraper fallback exists for most features) |
+| `USPTO_API_KEY` | USPTO | No |
+| `EPO_CONSUMER_KEY` / `EPO_CONSUMER_SECRET` | EPO | No (scraper-only) |
+| `LENS_API_KEY` | Lens.org | No (scraper-only) |
+
+Set via `recon config set` (interactive) or `.env` file.
+
+## Translation (Ollama)
+
+RECON can optionally translate non-English patent abstracts using a local Ollama instance:
+
+```bash
+# Install Ollama: https://ollama.ai
+ollama pull llama3
+
+# RECON auto-detects non-English text and uses Ollama
+# Press t in the TUI to toggle translation
+```
+
+When Ollama is not running, RECON gracefully displays the original text.
+
+## Testing
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

recon_patent-0.2.0/README.md

@@ -0,0 +1,189 @@
+# RECON — Terminal-Native Patent Research Tool
+
+**RECON** is a keyboard-first, terminal-native patent research tool. It aggregates patent data from multiple sources (USPTO, PatSnap, Google Patents, WIPO, Lens.org, EPO), presents results in a clean TUI or CLI, and provides scoring, citation graphs, export, and optional local-AI translation.
+
+## Features
+
+- **Multi-source search** — USPTO API, PatSnap API, Google Patents scraping, WIPO/Lens/EPO via DuckDuckGo + BeautifulSoup
+- **Source filtering** — Include/exclude sources via CLI `--source` or TUI `S` overlay
+- **Signal scoring** — Equal-weight 20-point signals (government grants, corporate investment, academic research, temporal recency, news/media)
+- **Live preview** — Three-tab detail pane (Info / Claims / Image) with keyboard navigation
+- **Citation graph** — ASCII tree view of forward/backward citations (scraped from Google Patents or mock data)
+- **Export** — JSON, CSV, BibTeX, Markdown, PDF
+- **Translation** — Optional local translation via Ollama (opt-in, Zero-AI default)
+- **Terminal-native** — No GUI, no Electron, no modal dialogs
+
+## Installation
+
+### Via PyPI (recommended)
+
+```bash
+pipx install recon-patent
+```
+
+### Via GitHub
+
+```bash
+pipx install git+https://github.com/anubhavaanand/recon.git
+```
+
+Ensure `~/.local/bin` is in your `PATH`.
+
+### Via install script (hacker method)
+
+```bash
+curl -sSL https://raw.githubusercontent.com/anubhavaanand/recon/main/install.sh | bash
+```
+
+### Via pip
+
+```bash
+pip install recon-patent
+```
+
+### From source
+
+```bash
+git clone https://github.com/anubhavaanand/recon.git
+cd recon
+pip install -e .
+```
+
+### Development
+
+```bash
+pip install -e ".[test,dev]"
+```
+
+## Quick Start
+
+### Launch the interactive TUI
+
+```bash
+recon
+```
+
+Type a query (e.g. `solid state battery`) and press Enter. Navigate results with `j`/`k`, open detail with Enter, switch tabs with `h`/`l`.
+
+### CLI search
+
+```bash
+recon search "sulfide electrolyte"
+```
+
+Filter by source:
+
+```bash
+recon search "quantum battery" --source uspto,patsnap,google
+```
+
+### End-to-end run with export
+
+```bash
+recon run "lithium anode" --export json
+```
+
+### View saved collection
+
+```bash
+recon collection list
+recon collection clear
+```
+
+### Manage API keys
+
+```bash
+recon config show
+recon config set --patsnap-key YOUR_KEY
+recon config test
+```
+
+### Export collection
+
+```bash
+recon export --format csv
+```
+
+Formats: `json`, `csv`, `bibtex`, `markdown`, `pdf`.
+
+## TUI Key Bindings
+
+| Key | Action |
+|-----|--------|
+| `↑`/`↓` `j`/`k` | Navigate results |
+| `Enter` | Open detail view |
+| `h`/`l` or `←`/`→` | Switch preview tab |
+| `/` | Focus search input |
+| `s` | Save patent to collection |
+| `e` | Export collection overlay |
+| `S` | Source filter overlay |
+| `c` | Toggle citation graph |
+| `t` | Toggle translation |
+| `r` | Reader mode |
+| `m` | Synthesis mode |
+| `?` | Help overlay |
+| `q` / `Esc` | Back / Quit |
+
+## Architecture
+
+```
+recon/
+├── cli/main.py          — Typer CLI (search, run, config, export, collection)
+├── core/
+│   ├── models.py        — PatentRecord, CrossReference dataclasses
+│   ├── search.py        — Multi-source search orchestration + source filtering
+│   ├── scoring.py       — Signal scoring (equal-weight algorithm)
+│   ├── arbitrage.py     — Arbitrage status calculation
+│   ├── citations.py     — Citation graph fetching (Google Patents scrape + mock)
+│   ├── translation.py   — Local Ollama translation with cache
+│   └── config.py        — Config management (.env + JSON)
+├── clients/
+│   ├── patent_apis.py   — USPTO, PatSnap, Google, WIPO, Lens, EPO clients
+│   ├── scrapers.py      — DDGS + BeautifulSoup scrapers (WIPO, Lens, EPO, Google)
+│   └── base.py          — BaseAsyncClient with rate-limit + backoff
+├── tui/
+│   ├── app.py           — Textual App + CSS
+│   ├── screens.py       — SearchScreen, DetailScreen, ReaderModeScreen, etc.
+│   └── widgets/         — ResultList, InfoTab, ClaimsTab, ImageTab, CitationTree
+├── storage/
+│   └── cache.py         — SQLite cache (search results, collection, translations)
+└── tests/               — 200+ tests (pytest)
+```
+
+## Configuration
+
+Keys are stored in `~/.config/recon/config.json` (chmod 600):
+
+| Variable | Source | Required |
+|----------|--------|----------|
+| `PATSNAP_API_KEY` | PatSnap | No (scraper fallback exists for most features) |
+| `USPTO_API_KEY` | USPTO | No |
+| `EPO_CONSUMER_KEY` / `EPO_CONSUMER_SECRET` | EPO | No (scraper-only) |
+| `LENS_API_KEY` | Lens.org | No (scraper-only) |
+
+Set via `recon config set` (interactive) or `.env` file.
+
+## Translation (Ollama)
+
+RECON can optionally translate non-English patent abstracts using a local Ollama instance:
+
+```bash
+# Install Ollama: https://ollama.ai
+ollama pull llama3
+
+# RECON auto-detects non-English text and uses Ollama
+# Press t in the TUI to toggle translation
+```
+
+When Ollama is not running, RECON gracefully displays the original text.
+
+## Testing
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

recon_patent-0.2.0/cli/download.py

@@ -0,0 +1,35 @@
+import httpx
+import os
+from pathlib import Path
+from core.models import PatentRecord
+
+async def download_patent_assets(record: PatentRecord, base_path: str = "downloads"):
+    """
+    Download patent figures and metadata for offline archival.
+    PRD §3.5 — Download (key: d).
+    """
+    target_dir = Path(base_path) / record.id
+    target_dir.mkdir(parents=True, exist_ok=True)
+    
+    # 1. Save metadata as JSON
+    import json
+    import dataclasses
+    meta_path = target_dir / "metadata.json"
+    with open(meta_path, "w") as f:
+        json.dump(dataclasses.asdict(record), f, indent=2)
+        
+    # 2. Download figures
+    if record.image_urls:
+        async with httpx.AsyncClient(timeout=30.0, trust_env=False) as client:
+            for i, url in enumerate(record.image_urls, 1):
+                try:
+                    response = await client.get(url)
+                    if response.status_code == 200:
+                        ext = Path(url).suffix or ".jpg"
+                        img_path = target_dir / f"figure_{i}{ext}"
+                        with open(img_path, "wb") as f:
+                            f.write(response.content)
+                except Exception as e:
+                    print(f"ERR: Failed to download figure {i}: {e}")
+                    
+    return target_dir

recon_patent-0.2.0/cli/export.py

@@ -0,0 +1,165 @@
+import csv
+import json
+from pathlib import Path
+from typing import List, Any
+from core.models import PatentRecord
+import fpdf
+
+def _safe_csv_field(value: str) -> str:
+    """Sanitize a CSV field to prevent formula injection in spreadsheet apps.
+    
+    Leading =, +, -, @ can trigger DDE/formula execution in Excel/Google Sheets.
+    Prefix them with a tab to neutralize.
+    """
+    value = str(value)
+    if value and value[0] in ("=", "+", "-", "@", "\t", "\r"):
+        return "\t" + value
+    return value
+
+def _export_csv(records: List[PatentRecord], output_path: str):
+    if not records:
+        Path(output_path).touch()
+        return
+        
+    with open(output_path, mode='w', newline='', encoding='utf-8') as f:
+        writer = csv.writer(f)
+        writer.writerow(["ID", "Title", "Assignee", "Filed Date", "Status", "Score"])
+        from core.scoring import calculate_signal_score
+        for record in records:
+            score = calculate_signal_score(record.cross_references)
+            writer.writerow([
+                _safe_csv_field(record.id),
+                _safe_csv_field(record.title),
+                _safe_csv_field(record.assignee),
+                _safe_csv_field(record.dates.get("filed", "")),
+                _safe_csv_field(record.status),
+                _safe_csv_field(str(score))
+            ])
+
+def _export_json(records: List[PatentRecord], output_path: str):
+    import dataclasses
+    def _default(o: Any):
+        if dataclasses.is_dataclass(o):
+            return dataclasses.asdict(o)
+        return str(o)
+        
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump([_default(r) for r in records], f, indent=2)
+
+def _export_bibtex(records: List[PatentRecord], output_path: str):
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for record in records:
+            f.write(f"@misc{{{record.id},\n")
+            f.write(f"  title = {{{record.title}}},\n")
+            f.write(f"  author = {{{record.assignee}}},\n")
+            f.write(f"  year = {{{record.dates.get('filed', '')[:4] if record.dates.get('filed') else ''}}},\n")
+            f.write(f"  note = {{Status: {record.status}}}\n")
+            f.write("}\n\n")
+
+def _export_markdown(records: List[PatentRecord], output_path: str):
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for record in records:
+            f.write(f"# {record.title}\n\n")
+            f.write(f"**ID**: {record.id} | **Assignee**: {record.assignee} | **Filed**: {record.dates.get('filed', '[?]')}\n\n")
+            f.write(f"## Abstract\n{record.abstract}\n\n")
+            f.write("---\n\n")
+
+def _export_pdf(records: List[PatentRecord], output_path: str):
+    """Generate PDF export with title page and individual patent pages."""
+    pdf = fpdf.FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    
+    # Title page
+    pdf.add_page()
+    pdf.set_font("helvetica", style="B", size=24)
+    pdf.ln(80)
+    pdf.cell(0, 20, "RECON Export", align="C")
+    pdf.ln(15)
+    pdf.set_font("helvetica", size=18)
+    pdf.cell(0, 20, f"{len(records)} Patents", align="C")
+    pdf.set_font("helvetica", size=12)
+    pdf.ln(50)
+    pdf.cell(0, 10, f"Generated: {Path(output_path).stem}", align="C")
+    
+    # Patent pages
+    for record in records:
+        pdf.add_page()
+        pdf.set_font("helvetica", style="B", size=14)
+        safe_title = record.title.encode('latin-1', 'replace').decode('latin-1')
+        pdf.multi_cell(w=180, h=8, text=safe_title, align="L")
+        pdf.ln(3)
+        
+        # ID, Assignee, Dates row
+        pdf.set_font("helvetica", size=10)
+        pdf.multi_cell(w=180, h=6, text=f"ID: {record.id}", align="L")
+        safe_assignee = record.assignee.encode('latin-1', 'replace').decode('latin-1')
+        pdf.multi_cell(w=180, h=6, text=f"Assignee: {safe_assignee}", align="L")
+        
+        # Dates
+        dates_str = " | ".join([f"{k}: {v}" for k, v in record.dates.items()])
+        safe_dates = dates_str.encode('latin-1', 'replace').decode('latin-1')
+        pdf.multi_cell(w=180, h=6, text=safe_dates, align="L")
+        pdf.multi_cell(w=180, h=6, text=f"Status: {record.status}", align="L")
+        pdf.ln(5)
+        
+        # Abstract
+        pdf.set_font("helvetica", style="B", size=11)
+        pdf.cell(0, 8, "Abstract", align="L")
+        pdf.ln(8)
+        pdf.set_font("helvetica", size=10)
+        safe_abstract = record.abstract.encode('latin-1', 'replace').decode('latin-1')
+        pdf.multi_cell(w=180, h=6, text=safe_abstract, align="L")
+        pdf.ln(5)
+        
+        # Claims
+        if record.claims:
+            pdf.set_font("helvetica", style="B", size=11)
+            pdf.cell(0, 8, "Claims", align="L")
+            pdf.ln(8)
+            pdf.set_font("helvetica", size=10)
+            for i, claim in enumerate(record.claims, 1):
+                safe_claim = claim.encode('latin-1', 'replace').decode('latin-1')
+                claim_text = f"{i}. {safe_claim}"
+                pdf.multi_cell(w=180, h=6, text=claim_text, align="L")
+        
+    pdf.output(output_path)
+
+def export_records(records: List[PatentRecord], format: str, output_path: str):
+    format = format.lower()
+    try:
+        if format == "csv":
+            _export_csv(records, output_path)
+        elif format == "json":
+            _export_json(records, output_path)
+        elif format == "bibtex":
+            _export_bibtex(records, output_path)
+        elif format == "markdown":
+            _export_markdown(records, output_path)
+        elif format == "pdf":
+            _export_pdf(records, output_path)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+    except Exception as e:
+        print(f"ERR: Export to {format} failed. Reason: {e}")
+        raise
+
+def export_pdf(collection: List[PatentRecord], path: str) -> None:
+    """
+    Export patent collection to PDF file.
+    Generates a title page followed by one page per patent.
+    
+    Args:
+        collection: List of PatentRecord objects to export
+        path: Output file path (e.g., '/path/to/export.pdf')
+    
+    Raises:
+        ValueError: If collection is empty
+        IOError: If file cannot be written
+    """
+    if not collection:
+        raise ValueError("Cannot export empty collection.")
+    try:
+        _export_pdf(collection, path)
+    except Exception as e:
+        print(f"ERR: PDF export failed. Reason: {e}")
+        raise