scrapemend 0.0.1__py3-none-any.whl

scrapemend/__init__.py

@@ -0,0 +1,14 @@
+"""scrapemend — self-healing web scraping for Python.
+
+Describe the data you want once. scrapemend extracts it with cached
+selectors; when a site changes its markup and those selectors stop
+matching, a language model inspects the new page and repairs them
+automatically, then caches the fix so the next run is free again.
+"""
+
+from scrapemend.result import ExtractionResult
+from scrapemend.schema import Field, Schema
+from scrapemend.scraper import Scraper
+
+__all__ = ["ExtractionResult", "Field", "Schema", "Scraper"]
+__version__ = "0.0.1"

scrapemend/cache.py

@@ -0,0 +1,57 @@
+"""On-disk selector cache keyed by (schema, site).
+
+The cache is what makes the common path free: once selectors are known
+for a given schema and host, extraction is pure parsing with no LLM call.
+Healing only writes here when the cached selectors stop matching.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+class SelectorCache:
+    """Maps a schema+host to the CSS selectors last known to work.
+
+    Stored as a single JSON file so it is trivial to inspect, diff, and
+    commit to a repo if a team wants to share healed selectors. (Shared,
+    hosted cache sync is a candidate Pro feature later.)
+    """
+
+    def __init__(self, path: str | Path = ".scrapemend-cache.json") -> None:
+        self.path = Path(path)
+        self._data: dict[str, dict[str, str]] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if self.path.exists():
+            try:
+                self._data = json.loads(self.path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                self._data = {}
+
+    def _flush(self) -> None:
+        self.path.write_text(
+            json.dumps(self._data, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+
+    @staticmethod
+    def _key(schema_name: str, url: str) -> str:
+        host = urlparse(url).netloc or "unknown"
+        return f"{schema_name}@{host}"
+
+    def get(self, schema_name: str, url: str) -> dict[str, str] | None:
+        """Return cached {field_name: css_selector} or None if unknown."""
+        return self._data.get(self._key(schema_name, url))
+
+    def put(self, schema_name: str, url: str, selectors: dict[str, str]) -> None:
+        """Store healed selectors for this schema+host and persist."""
+        self._data[self._key(schema_name, url)] = selectors
+        self._flush()
+
+    def drop(self, schema_name: str, url: str) -> None:
+        """Forget selectors for a schema+host (forces a re-heal next run)."""
+        self._data.pop(self._key(schema_name, url), None)
+        self._flush()

scrapemend/condense.py

@@ -0,0 +1,60 @@
+"""Shrink HTML before it goes into a healing prompt.
+
+The model only needs the page's *structure* to pick CSS selectors, not
+its scripts, styles, or inline data payloads. Stripping those cuts prompt
+tokens sharply (cheaper healing) and removes noise that can mislead the
+model (more accurate selectors). This directly serves the library's
+"robust but cheap" promise.
+"""
+
+from __future__ import annotations
+
+import re
+
+from selectolax.lexbor import LexborHTMLParser
+
+#: Tags that carry no structural signal for selector discovery.
+_DROP_TAGS = ("script", "style", "noscript", "template", "svg", "iframe")
+
+#: The only attributes that matter for building CSS selectors.
+_KEEP_ATTRS = ("class", "id")
+
+_WS = re.compile(r"\s+")
+
+
+def condense(html: str, limit: int = 6000) -> str:
+    """Return a stripped-down version of ``html`` for prompting.
+
+    Removes non-structural tags, drops every attribute except class/id,
+    collapses whitespace, and finally caps length as a hard token guard.
+
+    Falls back to a plain truncation if parsing fails for any reason, so
+    healing never breaks just because a page is malformed.
+    """
+    try:
+        tree = LexborHTMLParser(html)
+    except Exception:  # noqa: BLE001  # pragma: no cover - last-resort guard; never let healing crash on a weird page
+        return _WS.sub(" ", html)[:limit]
+
+    for tag in _DROP_TAGS:
+        for node in tree.css(tag):
+            node.decompose()
+
+    body = tree.body if tree.body is not None else tree.root
+    if body is None:
+        return _WS.sub(" ", html)[:limit]
+
+    for node in body.traverse(include_text=False):
+        attrs = getattr(node, "attributes", None)
+        if not attrs:
+            continue
+        for name in list(attrs.keys()):
+            if name not in _KEEP_ATTRS:
+                try:
+                    del node.attrs[name]
+                except (KeyError, TypeError):  # pragma: no cover - defensive
+                    pass
+
+    cleaned = body.html or ""
+    cleaned = _WS.sub(" ", cleaned).strip()
+    return cleaned[:limit]

scrapemend/healer.py

@@ -0,0 +1,49 @@
+"""Selector discovery/repair via the LLM.
+
+Given a page and a schema, ask the model for one CSS selector per field.
+The healer is only invoked when cached selectors are missing or have
+stopped matching, so its token cost is paid rarely, not per request.
+"""
+
+from __future__ import annotations
+
+import json
+
+from scrapemend.condense import condense
+from scrapemend.llm import LLMClient
+from scrapemend.schema import Schema
+
+_SYSTEM = (
+    "You map data fields to CSS selectors for a web page. "
+    "Return ONLY a JSON object mapping each field name to a single CSS "
+    "selector string that selects the element holding that field's value. "
+    "No prose, no code fences."
+)
+
+
+def build_prompt(schema: Schema, html: str) -> str:
+    lines = [f"- {f.name}: {f.describe}" for f in schema.fields]
+    return (
+        "Fields to locate:\n"
+        + "\n".join(lines)
+        + "\n\nPage HTML (condensed, possibly truncated):\n"
+        + condense(html)
+    )
+
+
+def heal(schema: Schema, html: str, client: LLMClient) -> dict[str, str]:
+    """Ask the LLM for fresh selectors. Returns {field_name: selector}.
+
+    Unknown or malformed replies yield an empty mapping rather than
+    raising, so the caller can record a clean failure and move on.
+    """
+    reply = client.complete(_SYSTEM, build_prompt(schema, html))
+    try:
+        parsed = json.loads(reply)
+    except json.JSONDecodeError:
+        return {}
+    if not isinstance(parsed, dict):
+        return {}
+    # Keep only known fields with string selectors.
+    valid = set(schema.field_names())
+    return {k: v for k, v in parsed.items() if k in valid and isinstance(v, str)}

scrapemend/llm.py

@@ -0,0 +1,60 @@
+"""The shared LLM layer.
+
+This module is deliberately generic: a provider-agnostic client plus a
+token/cost ledger. scrapemend uses it only for selector healing, but it
+carries no scraping concepts, so the planned LLM-developer-tooling product
+can reuse it wholesale. Keep it free of any scraping imports.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class Usage:
+    """Running tally of tokens spent, so callers can report real cost."""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+
+    @property
+    def total(self) -> int:
+        return self.prompt_tokens + self.completion_tokens
+
+    def add(self, prompt: int, completion: int) -> None:
+        self.prompt_tokens += prompt
+        self.completion_tokens += completion
+
+
+@runtime_checkable
+class LLMClient(Protocol):
+    """Minimal contract any provider adapter must satisfy.
+
+    Kept tiny on purpose: one text-in/text-out call. Concrete adapters
+    (OpenAI, local models, etc.) live in submodules and record usage.
+    """
+
+    usage: Usage
+
+    def complete(self, system: str, user: str) -> str:
+        """Return the model's text response to a system+user prompt."""
+        ...
+
+
+@dataclass
+class EchoClient:
+    """A no-network stub used in tests and offline development.
+
+    It never contacts a provider; it just returns a fixed string. This
+    lets the whole heal/extract pipeline run in CI without API keys.
+    """
+
+    reply: str = "{}"
+    usage: Usage = field(default_factory=Usage)
+
+    def complete(self, system: str, user: str) -> str:
+        # Pretend we spent a few tokens so cost tracking has something to show.
+        self.usage.add(prompt=len(user) // 4, completion=len(self.reply) // 4)
+        return self.reply

scrapemend/providers/__init__.py

@@ -0,0 +1,6 @@
+"""Concrete LLM provider adapters.
+
+Each adapter implements the :class:`scrapemend.llm.LLMClient` protocol
+(a ``usage`` ledger plus a ``complete(system, user)`` call) and is kept
+import-light so the core library never hard-depends on any one provider.
+"""

scrapemend/providers/deepseek_client.py

@@ -0,0 +1,83 @@
+"""DeepSeek-backed adapter for selector healing.
+
+DeepSeek exposes an OpenAI-compatible API, so this adapter reuses the
+``openai`` SDK and only swaps the base URL, key source, and model name.
+It supports JSON output mode, which is exactly what the healer wants
+(a strict JSON object mapping fields to selectors).
+
+DeepSeek is a strong default here: it is reachable from mainland China
+without extra setup and is cheap enough that infrequent healing calls
+are effectively free. Install the SDK with:
+
+    pip install "scrapemend[openai]"
+
+and set DEEPSEEK_API_KEY in your environment.
+"""
+
+from __future__ import annotations
+
+import os
+
+from scrapemend.llm import Usage
+
+#: DeepSeek's OpenAI-compatible endpoint.
+DEEPSEEK_BASE_URL = "https://api.deepseek.com"
+
+#: Alias that always points at DeepSeek's current main chat model, so this
+#: adapter keeps working across model version bumps.
+DEEPSEEK_DEFAULT_MODEL = "deepseek-chat"
+
+
+class DeepSeekClient:
+    """Calls DeepSeek's chat API (OpenAI-compatible) and tracks usage.
+
+    Args:
+        model: Chat model name. Defaults to the ``deepseek-chat`` alias.
+        api_key: Overrides the ``DEEPSEEK_API_KEY`` environment variable.
+        base_url: Overrides the default DeepSeek endpoint (useful for
+            proxies or OpenAI-compatible gateways).
+        temperature: Kept low for deterministic, parseable selector JSON.
+    """
+
+    def __init__(
+        self,
+        model: str = DEEPSEEK_DEFAULT_MODEL,
+        api_key: str | None = None,
+        base_url: str = DEEPSEEK_BASE_URL,
+        temperature: float = 0.0,
+    ) -> None:
+        try:
+            from openai import OpenAI
+        except ImportError as exc:  # pragma: no cover - import guard
+            raise ImportError(
+                "The DeepSeek adapter uses the OpenAI SDK. "
+                'Install it with: pip install "scrapemend[openai]"'
+            ) from exc
+
+        key = api_key or os.environ.get("DEEPSEEK_API_KEY")
+        if not key:
+            raise ValueError(
+                "No API key. Pass api_key=... or set DEEPSEEK_API_KEY in the environment."
+            )
+
+        self._client = OpenAI(api_key=key, base_url=base_url)
+        self.model = model
+        self.temperature = temperature
+        self.usage = Usage()
+
+    def complete(self, system: str, user: str) -> str:
+        resp = self._client.chat.completions.create(
+            model=self.model,
+            temperature=self.temperature,
+            response_format={"type": "json_object"},
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+        )
+        if resp.usage is not None:
+            self.usage.add(
+                prompt=resp.usage.prompt_tokens,
+                completion=resp.usage.completion_tokens,
+            )
+        return resp.choices[0].message.content or "{}"

scrapemend/providers/openai_client.py

@@ -0,0 +1,67 @@
+"""OpenAI-backed adapter for selector healing.
+
+Implements the LLMClient protocol. The ``openai`` package is imported
+lazily so that merely importing scrapemend never requires it — only
+constructing an :class:`OpenAIClient` does. Install with:
+
+    pip install "scrapemend[openai]"
+"""
+
+from __future__ import annotations
+
+import os
+
+from scrapemend.llm import Usage
+
+
+class OpenAIClient:
+    """Calls an OpenAI chat model and tracks token usage.
+
+    Args:
+        model: Chat model name. A small, cheap model is the sensible
+            default since healing is infrequent and the task is narrow.
+        api_key: Overrides the ``OPENAI_API_KEY`` environment variable.
+        temperature: Kept low for deterministic, parseable selector JSON.
+    """
+
+    def __init__(
+        self,
+        model: str = "gpt-4o-mini",
+        api_key: str | None = None,
+        temperature: float = 0.0,
+    ) -> None:
+        try:
+            from openai import OpenAI
+        except ImportError as exc:  # pragma: no cover - import guard
+            raise ImportError(
+                "The OpenAI adapter needs the 'openai' package. "
+                'Install it with: pip install "scrapemend[openai]"'
+            ) from exc
+
+        key = api_key or os.environ.get("OPENAI_API_KEY")
+        if not key:
+            raise ValueError(
+                "No API key. Pass api_key=... or set OPENAI_API_KEY in the environment."
+            )
+
+        self._client = OpenAI(api_key=key)
+        self.model = model
+        self.temperature = temperature
+        self.usage = Usage()
+
+    def complete(self, system: str, user: str) -> str:
+        resp = self._client.chat.completions.create(
+            model=self.model,
+            temperature=self.temperature,
+            response_format={"type": "json_object"},
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+        )
+        if resp.usage is not None:
+            self.usage.add(
+                prompt=resp.usage.prompt_tokens,
+                completion=resp.usage.completion_tokens,
+            )
+        return resp.choices[0].message.content or "{}"

scrapemend/result.py

@@ -0,0 +1,37 @@
+"""Return type carrying extracted data plus a little provenance.
+
+Beyond the data itself, each extraction reports *how* it was produced:
+whether cached selectors worked or the LLM had to heal them, and the
+token cost of any healing. That provenance is what later powers cost
+tracking — the shared layer the planned LLM-tooling product reuses.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ExtractionResult:
+    """Outcome of a single extraction.
+
+    Attributes:
+        data: Mapping of field name to extracted value(s).
+        healed: True when selectors had to be repaired by the LLM this run.
+        from_cache: True when every field was served from cached selectors.
+        tokens: Tokens spent on healing this run (0 when nothing healed).
+        notes: Human-readable diagnostics, e.g. which fields failed.
+    """
+
+    data: dict[str, Any] = field(default_factory=dict)
+    healed: bool = False
+    from_cache: bool = True
+    tokens: int = 0
+    notes: list[str] = field(default_factory=list)
+
+    def __getitem__(self, key: str) -> Any:
+        return self.data[key]
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.data.get(key, default)

scrapemend/schema.py

@@ -0,0 +1,51 @@
+"""User-facing description of *what* to extract.
+
+A ``Schema`` is a plain, declarative description of the fields the user
+wants off a page. It carries no selectors — selectors are discovered and
+healed at runtime and live in the cache, not here. This keeps the thing
+the user writes stable even as target sites change their markup.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Field:
+    """One piece of data to pull off a page.
+
+    Args:
+        name: Key the extracted value appears under in the result.
+        describe: Plain-language description used by the LLM to locate the
+            value when selectors need to be (re)discovered. Example:
+            "the product price including currency symbol".
+        many: If True, collect every match as a list instead of the first.
+        attr: Optional HTML attribute to read (e.g. "href"). When None, the
+            element's text content is used.
+    """
+
+    name: str
+    describe: str
+    many: bool = False
+    attr: str | None = None
+
+
+@dataclass
+class Schema:
+    """A named collection of :class:`Field` objects.
+
+    The ``name`` is used as the cache namespace so that selectors healed
+    for one schema/site pair do not collide with another.
+    """
+
+    name: str
+    fields: list[Field] = field(default_factory=list)
+
+    def add(self, name: str, describe: str, *, many: bool = False, attr: str | None = None) -> Schema:
+        """Add a field and return self so calls can be chained."""
+        self.fields.append(Field(name=name, describe=describe, many=many, attr=attr))
+        return self
+
+    def field_names(self) -> list[str]:
+        return [f.name for f in self.fields]

scrapemend/scraper.py

@@ -0,0 +1,99 @@
+"""The public entry point tying cache, parsing, and healing together.
+
+Flow per extraction:
+    1. Try cached selectors (free, fast).
+    2. If any required field fails to match, the page likely changed —
+       invoke the LLM healer, re-extract, and cache the repaired selectors.
+
+This "cache first, heal only on miss" policy is the whole point: you get
+AI robustness without paying an LLM call on every request.
+"""
+
+from __future__ import annotations
+
+import httpx
+from selectolax.lexbor import LexborHTMLParser as HTMLParser
+
+from scrapemend.cache import SelectorCache
+from scrapemend.healer import heal
+from scrapemend.llm import EchoClient, LLMClient
+from scrapemend.result import ExtractionResult
+from scrapemend.schema import Schema
+
+
+class Scraper:
+    """Extracts data described by a :class:`Schema` from web pages.
+
+    Args:
+        client: LLM adapter used for healing. Defaults to an offline stub
+            so the library imports and runs without any API key; pass a
+            real provider adapter to enable actual healing.
+        cache: Selector cache. Defaults to a JSON file in the cwd.
+    """
+
+    def __init__(self, client: LLMClient | None = None, cache: SelectorCache | None = None) -> None:
+        self.client = client or EchoClient()
+        self.cache = cache or SelectorCache()
+
+    def fetch(self, url: str) -> str:
+        resp = httpx.get(url, follow_redirects=True, timeout=30)
+        resp.raise_for_status()
+        return resp.text
+
+    def extract(self, url: str, schema: Schema, *, html: str | None = None) -> ExtractionResult:
+        """Extract ``schema`` from ``url`` (or supplied ``html``)."""
+        page = html if html is not None else self.fetch(url)
+        tree = HTMLParser(page)
+
+        selectors = self.cache.get(schema.name, url)
+        if selectors is not None:
+            result = self._apply(tree, schema, selectors)
+            if not result.notes:  # every field matched
+                result.from_cache = True
+                return result
+            # Cached selectors went stale — fall through to healing.
+
+        return self._heal_and_extract(url, schema, page, tree)
+
+    def _heal_and_extract(
+        self, url: str, schema: Schema, page: str, tree: HTMLParser
+    ) -> ExtractionResult:
+        before = self.client.usage.total
+        selectors = heal(schema, page, self.client)
+        spent = self.client.usage.total - before
+
+        if not selectors:
+            return ExtractionResult(
+                from_cache=False,
+                healed=True,
+                tokens=spent,
+                notes=["healing failed: model returned no usable selectors"],
+            )
+
+        result = self._apply(tree, schema, selectors)
+        result.from_cache = False
+        result.healed = True
+        result.tokens = spent
+        if not any("no match" in n for n in result.notes):
+            self.cache.put(schema.name, url, selectors)
+        return result
+
+    @staticmethod
+    def _apply(tree: HTMLParser, schema: Schema, selectors: dict[str, str]) -> ExtractionResult:
+        out = ExtractionResult()
+        for f in schema.fields:
+            sel = selectors.get(f.name)
+            nodes = tree.css(sel) if sel else []
+            if not nodes:
+                out.notes.append(f"{f.name}: no match")
+                out.data[f.name] = [] if f.many else None
+                continue
+            values = [_read(n, f.attr) for n in nodes]
+            out.data[f.name] = values if f.many else values[0]
+        return out
+
+
+def _read(node, attr: str | None) -> str:
+    if attr is not None:
+        return node.attributes.get(attr, "") or ""
+    return node.text(strip=True)

scrapemend-0.0.1.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.5
+Name: scrapemend
+Version: 0.0.1
+Summary: Self-healing web scraping for Python. Describe what you want in plain language; when a site changes and your selectors break, an LLM repairs them automatically.
+Project-URL: Homepage, https://github.com/FengYue427/scrapemend
+Project-URL: Repository, https://github.com/FengYue427/scrapemend
+Project-URL: Issues, https://github.com/FengYue427/scrapemend/issues
+Author: FengYue427
+License: MIT
+License-File: LICENSE
+Keywords: ai,crawler,data-extraction,llm,scraping,self-healing,web-scraping
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: selectolax>=0.3.21
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# scrapemend
+
+**Self-healing web scraping for Python.** Describe the data you want once.
+scrapemend extracts it with cached CSS selectors — and when a site changes
+its markup and those selectors break, a language model inspects the new page,
+repairs the selectors, and caches the fix. The next run is free again.
+
+> Traditional scrapers break every time a site is redesigned. scrapemend
+> treats a broken selector as a cache miss, not a crash.
+
+---
+
+## Why
+
+Every scraper hits the same wall: you write selectors, the site ships a
+redesign, your selectors silently return nothing, and you go rewrite them by
+hand. Cloud "AI scraping" services solve the robustness problem but are
+expensive, send your target data through someone else's servers, and run an
+LLM call on *every* request.
+
+scrapemend takes the middle path:
+
+- **Cache first.** Known selectors run with zero LLM cost — it's just parsing.
+- **Heal on miss.** The LLM is only called when selectors stop matching.
+- **Self-hosted.** It's a library, not a service. Your keys, your data.
+
+## Install
+
+```bash
+pip install scrapemend
+```
+
+## Quickstart
+
+```python
+from scrapemend import Scraper, Schema
+
+schema = (
+    Schema("product")
+    .add("title", "the product name")
+    .add("price", "the product price with currency")
+)
+
+scraper = Scraper()  # offline stub by default; plug in a real LLM to heal
+result = scraper.extract("https://shop.example/p/1", schema)
+
+print(result["title"], result["price"])
+print("healed:", result.healed, "tokens:", result.tokens)
+```
+
+You describe *what* you want in plain language. You never hand-write a CSS
+selector — scrapemend discovers them, and re-discovers them when they break.
+
+## How it works
+
+```
+extract(url, schema)
+      │
+      ├─ cached selectors exist? ──► apply them
+      │                               ├─ all fields matched ──► return (free)
+      │                               └─ some field missed ──┐
+      │                                                      ▼
+      └─ no cache ─────────────────────────────────► LLM heals selectors
+                                                      apply, cache, return
+```
+
+Because healing only runs on a miss, steady-state scraping costs nothing in
+tokens. You pay the model exactly when a site actually changes.
+
+## Status
+
+Early alpha (`0.0.1`). The core pipeline — cache, parse, heal, re-cache — works
+and is covered by tests that run fully offline. A real OpenAI adapter is the
+next step; the LLM layer is provider-agnostic by design.
+
+## Roadmap
+
+- [x] Cache-first / heal-on-miss pipeline
+- [x] Offline, key-free test path
+- [ ] OpenAI adapter
+- [ ] Local-model adapter
+- [x] HTML condensing for cheaper prompts
+- [ ] Pluggable cost/budget guards
+
+## License
+
+MIT

scrapemend-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+scrapemend/__init__.py,sha256=UiSV6ygPHOosILNHykrgudKqNSOru3JkiF_cGAWXRh0,543
+scrapemend/cache.py,sha256=yoNEupOBNc1rRoqtlWyGal7LQZmv8lAxK3dBTw3y7ME,2066
+scrapemend/condense.py,sha256=vSgPpwQWvLchxYgVTC8WDh-RRg71Jej3tXdP0oKKYk8,2047
+scrapemend/healer.py,sha256=yWNWwpRN7Eh3_tGRVyC12SFVdrKZ-j4jopqRdfKZ57Y,1639
+scrapemend/llm.py,sha256=QekhWfk9Syih6BPynKqwrNecbMq4CNSCPL6BtdJkbtI,1807
+scrapemend/result.py,sha256=W4OWeLr0-tfE_0Y3mvidZWC9sHImyDUP8cs93l5Sycg,1261
+scrapemend/schema.py,sha256=w1wsSG5C32-nlbuhTXS1GsjY-nIXcedKvK4gnUUfX6E,1707
+scrapemend/scraper.py,sha256=vhc2iR7VRSGhpaaSH8vKFOvo3ndzvbJZ-f_IzWRBPJs,3667
+scrapemend/providers/__init__.py,sha256=QUGFwbWQ6v83e-lhYtjFL5xZReLXIQgER7gZAZAjF8M,256
+scrapemend/providers/deepseek_client.py,sha256=aiOTJk2MyQBnZz_pKcFD262h_5xYlN8MnRhhfPKHyXk,2896
+scrapemend/providers/openai_client.py,sha256=EqYdx7FxXjNaj991qVyfiZblkD-ADEbrZx-Oo3a0vmw,2195
+scrapemend-0.0.1.dist-info/METADATA,sha256=XbKxRvfEyjQE-vCzBULmlpeaXVfPwWaaZR9g9EJg-D4,4227
+scrapemend-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+scrapemend-0.0.1.dist-info/licenses/LICENSE,sha256=IPczPPdAVaxv7gISsUvTNmtnHRpQoOo119XeNIZXSnw,1067
+scrapemend-0.0.1.dist-info/RECORD,,

scrapemend-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

scrapemend-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OriginTown
+
+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.