mesharc 0.1.2__py3-none-any.whl

mesharc/__init__.py

@@ -0,0 +1,542 @@
+"""mesharc: the Python client for the MeshArc API.
+
+    from mesharc import MeshArc
+    arc = MeshArc("mesharc_...")                # or MeshArc() with MESHARC_API_KEY set
+
+    page = arc.scrape("https://example.com/pricing")            # one URL, waited for
+    batch = arc.scrape(["https://a.com/", "https://b.com/x"])   # many URLs, one row each
+
+    job = arc.crawl("https://docs.example.com", limit=200)      # a site, no project needed
+    for page in job.pages():                                    # pages as they land
+        print(page["url"], page["words"])
+    project = job.keep(name="Docs", schedule="weekly")          # keep it, if it is worth watching
+
+    for entry in arc.map("https://docs.example.com"):           # what the site declares
+        print(entry["url"], entry["lastmod"])
+
+Every method is one API call (or a poll loop where ``wait`` applies) and
+returns the API's JSON unwrapped, so the API reference at
+https://mesharc.dev/docs/api applies to every return value. Refused
+requests raise ``MeshArcError``; a job the client stopped waiting for
+raises ``MeshArcTimeoutError``.
+"""
+
+from __future__ import annotations
+
+import os
+import random
+import time
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Union
+from urllib.parse import parse_qs, urlparse
+
+import httpx
+
+__version__ = "0.1.2"
+__all__ = ["MeshArc", "MeshArcError", "MeshArcTimeoutError", "Crawl"]
+
+DEFAULT_BASE = "https://api.mesharc.dev"
+DEFAULT_TIMEOUT = 150.0
+DEFAULT_MAX_RETRIES = 2
+RETRY_STATUSES = frozenset({429, 502, 503, 504})
+
+Json = Dict[str, Any]
+
+
+class MeshArcError(Exception):
+    """A request the API refused, or a job that ended in error.
+
+    ``status`` is the HTTP status (0 for a network failure or a timeout),
+    ``code`` the machine-readable reason (validation, unauthorized,
+    plan_limit, not_found, rate_limited, ...) and ``request_id`` the id
+    the API logged the request under -- quote it to support.
+    """
+
+    def __init__(self, status: int, detail: Any, code: str = "", request_id: str = "") -> None:
+        super().__init__(f"{status}: {detail}" + (f" [{request_id}]" if request_id else ""))
+        self.status = status
+        self.detail = detail
+        self.code = code
+        self.request_id = request_id
+
+
+class MeshArcTimeoutError(MeshArcError, TimeoutError):
+    """A job that was still running when the client stopped waiting.
+
+    ``job_id`` names the job; poll it later with the matching ``get``
+    method. Catchable as either ``MeshArcError`` or ``TimeoutError``.
+    """
+
+    def __init__(self, message: str, job_id: str = "") -> None:
+        super().__init__(0, message, "timeout")
+        self.job_id = job_id
+
+
+def _running(status: Any) -> bool:
+    return status in ("queued", "running")
+
+
+def _cursor_of(next_url: str) -> str:
+    return (parse_qs(urlparse(next_url).query).get("cursor") or [""])[0]
+
+
+class _Http:
+    """The transport: one httpx client, bearer auth, JSON errors, retries."""
+
+    def __init__(self, api_key: str, base_url: str, timeout: float, max_retries: int) -> None:
+        self._c = httpx.Client(
+            base_url=base_url.rstrip("/") + "/api/v1",
+            headers={"Authorization": f"Bearer {api_key}", "User-Agent": f"mesharc-python/{__version__}"},
+            timeout=timeout,
+        )
+        self._max_retries = max(0, int(max_retries))
+
+    def __call__(self, method: str, path: str, idempotency_key: Optional[str] = None, **kw: Any) -> Any:
+        if idempotency_key:
+            kw.setdefault("headers", {})["Idempotency-Key"] = str(idempotency_key)
+        # A GET or DELETE is safe to repeat; a POST only when it carries an idempotency key.
+        repeatable = method in ("GET", "DELETE") or bool(idempotency_key)
+        attempt = 0
+        while True:
+            try:
+                r = self._c.request(method, path, **kw)
+            except httpx.TimeoutException as exc:
+                if repeatable and attempt < self._max_retries:
+                    attempt += 1
+                    time.sleep(self._backoff(attempt))
+                    continue
+                raise MeshArcError(0, f"request timed out: {exc}", "timeout") from exc
+            except httpx.HTTPError as exc:
+                if repeatable and attempt < self._max_retries:
+                    attempt += 1
+                    time.sleep(self._backoff(attempt))
+                    continue
+                raise MeshArcError(0, f"network error: {exc}", "network") from exc
+            if r.status_code in RETRY_STATUSES and repeatable and attempt < self._max_retries:
+                attempt += 1
+                time.sleep(self._retry_after(r) or self._backoff(attempt))
+                continue
+            if r.status_code >= 400:
+                raise self._error(r)
+            if r.status_code == 204 or not r.content:
+                return None
+            return r.json()
+
+    @staticmethod
+    def _backoff(attempt: int) -> float:
+        return 0.5 * (2 ** (attempt - 1)) + random.random() * 0.25
+
+    @staticmethod
+    def _retry_after(r: httpx.Response) -> Optional[float]:
+        header = r.headers.get("Retry-After")
+        if not header:
+            return None
+        try:
+            return max(0.0, float(header))
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _error(r: httpx.Response) -> MeshArcError:
+        code, request_id = "", r.headers.get("X-Request-Id", "")
+        try:
+            body = r.json()
+            detail = body.get("error") or body.get("detail") or r.text[:200]
+            code = body.get("code", "") or ""
+            request_id = body.get("request_id") or request_id
+        except Exception:  # noqa: BLE001 - a non-JSON body is its own detail
+            detail = r.text[:200]
+        return MeshArcError(r.status_code, detail, code, request_id)
+
+    def stream(self, method: str, path: str, **kw: Any) -> Any:
+        return self._c.stream(method, path, **kw)
+
+    def close(self) -> None:
+        self._c.close()
+
+
+class _Projects:
+    def __init__(self, http: _Http) -> None:
+        self._h = http
+
+    def list(self) -> List[Json]:
+        return self._h("GET", "/projects")
+
+    def create(self, seed: str, name: Optional[str] = None, schedule: str = "manual", retention: str = "90d",
+               config: Optional[Json] = None) -> Json:
+        body: Json = {"seed": seed, "schedule": schedule, "retention": retention}
+        if name:
+            body["name"] = name
+        if config:
+            body["config"] = config
+        return self._h("POST", "/projects", json=body)
+
+    def get(self, project_id: str) -> Json:
+        return self._h("GET", f"/projects/{project_id}")
+
+    def update(self, project_id: str, **fields: Any) -> Json:
+        return self._h("PATCH", f"/projects/{project_id}", json=fields)
+
+    def delete(self, project_id: str) -> None:
+        self._h("DELETE", f"/projects/{project_id}")
+
+
+class _Runs:
+    def __init__(self, http: _Http) -> None:
+        self._h = http
+
+    def list(self, project_id: str, limit: int = 25) -> List[Json]:
+        return self._h("GET", f"/projects/{project_id}/runs", params={"limit": limit})
+
+    def get(self, project_id: str, run_id: str) -> Json:
+        return self._h("GET", f"/projects/{project_id}/runs/{run_id}")
+
+    def start(self, project_id: str, wait: bool = False, poll: float = 3.0, timeout: float = 3600) -> Json:
+        run = self._h("POST", f"/projects/{project_id}/runs", json={"trigger": "api"})
+        return self.wait(project_id, run["id"], poll, timeout) if wait else run
+
+    def wait(self, project_id: str, run_id: str, poll: float = 3.0, timeout: float = 3600) -> Json:
+        deadline = time.time() + timeout
+        while True:
+            run = self.get(project_id, run_id)
+            if run["status"] != "running" and not run.get("queued"):
+                return run
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"run {run_id} is still {run['status']} after {timeout}s", run_id)
+            time.sleep(poll)
+
+    def cancel(self, project_id: str, run_id: str) -> Json:
+        return self._h("POST", f"/projects/{project_id}/runs/{run_id}/cancel")
+
+
+class Crawl:
+    """A crawl started by ``arc.crawl(url)``: a handle on a running job.
+
+    ``wait()`` blocks until it finishes; ``pages()`` yields pages as they
+    land, following the cursor, and ends when the job does; ``keep()``
+    turns the one-shot crawl into a project; ``cancel()`` stops it.
+    """
+
+    def __init__(self, http: _Http, envelope: Json) -> None:
+        self._h = http
+        self.id: str = envelope["id"]
+        self.url: str = envelope.get("url", "")
+        self.project_id: str = envelope.get("projectId", "")
+        #: Returned once, at creation: the secret the crawl's webhook messages are signed with.
+        self.webhook_secret: str = envelope.get("webhookSecret", "")
+        self.envelope: Json = envelope
+
+    def __repr__(self) -> str:
+        return f"<Crawl {self.id[:8]} {self.url} {self.envelope.get('status')}>"
+
+    @property
+    def status(self) -> str:
+        return self.envelope.get("status", "queued")
+
+    def refresh(self, formats: str = "markdown") -> Json:
+        """The envelope as it stands now, without its pages."""
+        self.envelope = self._h("GET", f"/crawl/{self.id}", params={"limit": 1, "formats": formats})
+        return self.envelope
+
+    def wait(self, poll: float = 3.0, timeout: float = 3600, formats: str = "markdown") -> Json:
+        """Block until the crawl finishes. Returns the envelope."""
+        deadline = time.time() + timeout
+        while True:
+            e = self.refresh(formats)
+            if not _running(e["status"]):
+                return e
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"crawl {self.id} is still {e['status']} after {timeout}s", self.id)
+            time.sleep(poll)
+
+    def pages(self, formats: str = "markdown", limit: int = 25, wait: bool = True, poll: float = 3.0,
+              timeout: float = 3600) -> Iterator[Json]:
+        """Every page of the crawl, oldest first.
+
+        While the crawl runs this waits for more pages rather than
+        stopping; ``wait=False`` yields what exists and returns.
+        """
+        deadline = time.time() + timeout
+        cursor: Optional[str] = None
+        while True:
+            params: Dict[str, Any] = {"formats": formats, "limit": limit}
+            if cursor:
+                params["cursor"] = cursor
+            page = self._h("GET", f"/crawl/{self.id}", params=params)
+            self.envelope = {k: v for k, v in page.items() if k != "data"}
+            for row in page["data"]:
+                yield row
+            # The cursor marks where this page ended, so a running crawl is never re-read from the top.
+            cursor = page.get("cursor") or cursor
+            if page.get("next"):
+                cursor = _cursor_of(page["next"]) or cursor
+                continue
+            if not wait or not _running(page["status"]):
+                return
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"crawl {self.id} is still {page['status']} after {timeout}s", self.id)
+            time.sleep(poll)
+
+    def keep(self, name: Optional[str] = None, schedule: Optional[str] = None,
+             retention: Optional[str] = None) -> Json:
+        """Make this one-shot crawl a project. Its run and pages are already in place."""
+        body = {k: v for k, v in (("name", name), ("schedule", schedule), ("retention", retention)) if v}
+        return self._h("POST", f"/crawl/{self.id}/keep", json=body)
+
+    def cancel(self) -> Json:
+        self._h("DELETE", f"/crawl/{self.id}")
+        self.envelope["status"] = "cancelled"
+        return self.envelope
+
+
+class MeshArc:
+    """One client, one API key, one workspace.
+
+    ``api_key`` falls back to the ``MESHARC_API_KEY`` environment variable.
+    ``timeout`` is the HTTP timeout per request in seconds; ``max_retries``
+    how many times a request that is safe to repeat is retried on 429,
+    502, 503, 504 or a network failure. ``base_url`` is for MeshArc's own
+    test environments; the hosted API needs nothing there.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = DEFAULT_TIMEOUT, max_retries: int = DEFAULT_MAX_RETRIES) -> None:
+        key = api_key or os.environ.get("MESHARC_API_KEY") or ""
+        if not key:
+            raise ValueError("An API key is required: MeshArc('mesharc_...') or set MESHARC_API_KEY.")
+        base = base_url or os.environ.get("MESHARC_API_URL") or DEFAULT_BASE
+        self._h = _Http(key, base, timeout, max_retries)
+        self.projects = _Projects(self._h)
+        self.runs = _Runs(self._h)
+
+    # ------------------------------------------------------------ one or many URLs
+
+    def extract(self, url: str, config: Optional[Json] = None, wait: bool = True, poll: float = 2.0,
+                timeout: float = 300) -> Json:
+        """One URL with every format, as the app's playground reads it."""
+        body: Json = {"url": url}
+        if config:
+            body["config"] = config
+        job = self._h("POST", "/playground/extract", json=body)
+        if not wait:
+            return job
+        deadline = time.time() + timeout
+        while True:
+            r = self._h("GET", f"/playground/{job['id']}")
+            if not _running(r["status"]):
+                return r
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"extraction {job['id']} is still {r['status']} after {timeout}s", job["id"])
+            time.sleep(poll)
+
+    def scrape(self, urls: Union[str, Iterable[str]], config: Optional[Json] = None,
+               webhook_url: Optional[str] = None, formats: str = "markdown", wait: bool = True,
+               poll: float = 3.0, timeout: float = 3600, idempotency_key: Optional[str] = None) -> Json:
+        """URLs in, their content out; no project.
+
+        One URL (a string) returns the page itself: the API holds the
+        request open until the page comes back. A list is a batch and
+        returns the finished batch, one row per URL, unless ``wait`` is
+        False.
+        """
+        if isinstance(urls, str):
+            return self.scrape_one(urls, config=config, formats=formats, wait=wait, poll=poll,
+                                   timeout=timeout, idempotency_key=idempotency_key)
+        body: Json = {"urls": list(urls)}
+        if config:
+            body["config"] = config
+        if webhook_url:
+            body["webhook_url"] = webhook_url
+        batch = self._h("POST", "/scrape", json=body, idempotency_key=idempotency_key)
+        if not wait:
+            return batch
+        return self.batch(batch["id"], formats=formats, wait=True, poll=poll, timeout=timeout)
+
+    def scrape_one(self, url: str, config: Optional[Json] = None, formats: str = "markdown", wait: bool = True,
+                   timeout_s: int = 60, poll: float = 2.0, timeout: float = 600,
+                   idempotency_key: Optional[str] = None) -> Json:
+        """One URL, waited for. Returns the page; ``wait=False`` returns the job envelope.
+
+        ``timeout_s`` is how long the API holds the request open for the
+        page (60 by default, 120 at most); a slower page comes back as a
+        job, which is then polled every ``poll`` seconds for up to
+        ``timeout`` seconds.
+        """
+        body: Json = {"url": url, "formats": formats, "timeout": timeout_s}
+        if config:
+            body["config"] = config
+        out = self._h("POST", "/scrape", json=body, idempotency_key=idempotency_key)
+        if not wait:
+            return out
+        deadline = time.time() + timeout
+        while True:
+            if out.get("status") == "done":
+                return (out.get("data") or [{}])[0]
+            if not _running(out.get("status")):
+                raise MeshArcError(502, out.get("error") or f"scrape {out.get('status')}", "job_failed")
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"scrape {out['id']} is still {out['status']} after {timeout}s", out["id"])
+            time.sleep(poll)
+            out = self._h("GET", f"/scrape/{out['id']}", params={"formats": formats})
+
+    def batch(self, batch_id: str, formats: str = "markdown", wait: bool = False, poll: float = 3.0,
+              timeout: float = 3600) -> Json:
+        """A batch started earlier. With ``wait``, returns once every row is in."""
+        deadline = time.time() + timeout
+        while True:
+            r = self._h("GET", f"/scrape/{batch_id}", params={"formats": formats})
+            if not wait or not _running(r["status"]):
+                return r
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"batch {batch_id} is still {r['status']} after {timeout}s", batch_id)
+            time.sleep(poll)
+
+    # ---------------------------------------------------------------- a whole site
+
+    def crawl(self, url: str, wait: bool = False, poll: float = 3.0, timeout: float = 3600,
+              idempotency_key: Optional[str] = None, **opts: Any) -> Crawl:
+        """Crawl a site once, with no project to set up first.
+
+        Returns a ``Crawl`` handle as soon as the job is queued; ``wait=True``
+        blocks until it finishes. ``opts`` are the request's own names --
+        ``limit``, ``maxDepth``, ``includePaths``, ``excludePaths``,
+        ``crawlMode``, ``maxAge``, ``maxTier``, ``scrapeOptions``,
+        ``webhook`` -- and ``config`` takes any project setting directly.
+        """
+        job = Crawl(self._h, self._h("POST", "/crawl", json={"url": url, **opts}, idempotency_key=idempotency_key))
+        if wait:
+            job.wait(poll=poll, timeout=timeout)
+        return job
+
+    def get_crawl(self, crawl_id: str) -> Crawl:
+        """A handle on a crawl started earlier or elsewhere."""
+        return Crawl(self._h, self._h("GET", f"/crawl/{crawl_id}", params={"limit": 1}))
+
+    def map(self, url: str, **opts: Any) -> List[Json]:
+        """Every URL a site declares in its sitemaps, as ``{url, lastmod, changefreq, source, file, section}``."""
+        return self.map_details(url, **opts)["data"]
+
+    def map_details(self, url: str, search: Optional[str] = None, limit: Optional[int] = None,
+                    timeout_s: int = 10, poll: float = 2.0, timeout: float = 300, **opts: Any) -> Json:
+        """A map with everything the API said about it: how the sitemaps
+        were found, the totals, what robots.txt allowed, and the URLs
+        under ``data``. ``timeout_s`` is how long the API waits for the
+        sitemap tree before answering with a job (10 by default, 60 at
+        most), which is then polled.
+        """
+        body: Json = {"url": url, "timeout": timeout_s, **opts}
+        if search:
+            body["search"] = search
+        if limit:
+            body["limit"] = limit
+        out = self._h("POST", "/map", json=body)
+        params = {k: v for k, v in (("search", search), ("limit", limit)) if v}
+        deadline = time.time() + timeout
+        while out.get("status") == "running":
+            if time.time() >= deadline:
+                raise MeshArcTimeoutError(f"map {out['id']} is still reading {url} after {timeout}s", out["id"])
+            time.sleep(poll)
+            out = self._h("GET", f"/map/{out['id']}", params=params or None)
+        if out.get("status") != "done":
+            raise MeshArcError(502, out.get("error") or "no sitemap could be read", "job_failed")
+        return out
+
+    # ---------------------------------------------------------- what a project holds
+
+    def pages(self, project_id: str, run_id: Optional[str] = None) -> Json:
+        """The pages of a run (the latest finished run by default)."""
+        return self._h("GET", f"/projects/{project_id}/pages", params={"run_id": run_id} if run_id else None)
+
+    def page(self, project_id: str, url: str, run_id: Optional[str] = None) -> Json:
+        """One page in full: bodies, head fields, structured fields, versions."""
+        params: Dict[str, Any] = {"url": url}
+        if run_id:
+            params["run_id"] = run_id
+        return self._h("GET", f"/projects/{project_id}/pages/content", params=params)
+
+    def changes(self, project_id: str, run_id: Optional[str] = None) -> Json:
+        """The change record of a run against the run before it."""
+        return self._h("GET", f"/projects/{project_id}/changes", params={"run_id": run_id} if run_id else None)
+
+    def page_diff(self, project_id: str, url: str, run_id: Optional[str] = None) -> Json:
+        """The word-level diff of one page against the run before."""
+        params: Dict[str, Any] = {"url": url}
+        if run_id:
+            params["run_id"] = run_id
+        return self._h("GET", f"/projects/{project_id}/changes/page", params=params)
+
+    def search(self, project_id: str, q: str, mode: str = "content", run_id: Optional[str] = None) -> Json:
+        """Which pages say this (``content``: words, "phrases") or contain this (``selector``: CSS or XPath)."""
+        return self._h("POST", f"/projects/{project_id}/pages/search", json={"mode": mode, "q": q, "run_id": run_id})
+
+    def recrawl(self, project_id: str, urls: Iterable[str]) -> Json:
+        """Fetch these pages again now, as a scoped run."""
+        return self._h("POST", f"/projects/{project_id}/pages/recrawl", json={"urls": list(urls)})
+
+    def sources(self, project_id: str) -> Json:
+        """The seed, sitemap, URL list, feeds and patterns, with what the last run found through each."""
+        return self._h("GET", f"/projects/{project_id}/sources")
+
+    def export(self, project_id: str, path: str, dataset: str = "pages", fmt: str = "jsonl",
+               run_id: Optional[str] = None, urls: Optional[Iterable[str]] = None) -> str:
+        """Stream a dataset (pages, markdown, changes, fields, sitemap) to ``path`` as jsonl or csv.
+
+        ``urls`` restricts the export to those pages. Returns ``path``.
+        """
+        if urls:
+            ctx = self._h.stream("POST", f"/projects/{project_id}/export",
+                                 json={"dataset": dataset, "format": fmt, "run_id": run_id, "urls": list(urls)})
+        else:
+            params: Dict[str, Any] = {"dataset": dataset, "format": fmt}
+            if run_id:
+                params["run_id"] = run_id
+            ctx = self._h.stream("GET", f"/projects/{project_id}/export", params=params)
+        with ctx as r:
+            if r.status_code >= 400:
+                r.read()
+                raise self._h._error(r)
+            with open(path, "wb") as fh:
+                for chunk in r.iter_bytes():
+                    fh.write(chunk)
+        return path
+
+    # --------------------------------------------------------------------- workspace
+
+    def me(self) -> Json:
+        """The workspace, its plan and limits, and what this key may do."""
+        return self._h("GET", "/me")
+
+    def keys(self) -> List[Json]:
+        return self._h("GET", "/me/keys")
+
+    def create_key(self, name: str = "default", scopes: Optional[List[str]] = None,
+                   projects: Optional[List[str]] = None, expires_in_days: Optional[int] = None,
+                   rpm: Optional[int] = None) -> Json:
+        """A new API key. The plaintext is in the response under ``key``, once."""
+        body: Json = {"name": name}
+        for key, value in (("scopes", scopes), ("projects", projects),
+                           ("expires_in_days", expires_in_days), ("rpm", rpm)):
+            if value is not None:
+                body[key] = value
+        return self._h("POST", "/me/keys", json=body)
+
+    def revoke_key(self, key_id: str) -> None:
+        self._h("DELETE", f"/me/keys/{key_id}")
+
+    def usage(self) -> Json:
+        return self._h("GET", "/me/usage")
+
+    def monitor(self) -> Json:
+        return self._h("GET", "/me/monitor")
+
+    def meta(self) -> Json:
+        """Verdict meanings, engine costs, the configuration defaults and the ladder."""
+        return self._h("GET", "/meta")
+
+    def close(self) -> None:
+        self._h.close()
+
+    def __enter__(self) -> "MeshArc":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

mesharc/mcp.py

@@ -0,0 +1,208 @@
+"""MeshArc as an MCP server: the API's verbs as tools an agent can call.
+
+    pip install "mesharc[mcp]"                      # Python 3.10+
+    MESHARC_API_KEY=mesharc_... mesharc-mcp         # stdio, for Claude Desktop, Claude Code, Cursor
+
+    claude mcp add mesharc -e MESHARC_API_KEY=mesharc_... -- mesharc-mcp
+
+Tools return the API's JSON, trimmed where a body would swamp a context
+window (markdown is capped per page; ask for one page to get all of it).
+Every tool is a call through the Python client, so what the agent gets
+is what the API gives.
+"""
+
+import os
+
+try:
+    from mcp.server.mcpserver import MCPServer
+except ImportError as exc:  # pragma: no cover
+    raise SystemExit('The MCP server needs the "mcp" package: pip install "mesharc[mcp]"') from exc
+
+from mesharc import MeshArc, MeshArcError
+
+MARKDOWN_CAP = 12_000
+PAGES_CAP = 50
+
+server = MCPServer(
+    "mesharc",
+    instructions=(
+        "MeshArc turns URLs into clean content and keeps a record of what changed. "
+        "Use scrape_urls for a list of pages, extract_url for one page with every format, "
+        "map_site to see what URLs a site declares before fetching any of them, and "
+        "crawl_site to crawl a whole site once without setting a project up first "
+        "(keep_crawl_as_project turns one of those into a watched project afterwards). "
+        "The project tools are for a site watched over time: its pages, its change record, "
+        "and search inside a run. Blocked pages are reported as blocked, never as missing."
+    ),
+)
+
+
+def _client():
+    key = os.environ.get("MESHARC_API_KEY") or ""
+    if not key:
+        raise RuntimeError("MESHARC_API_KEY is not set")
+    return MeshArc(key, base_url=os.environ.get("MESHARC_API_URL") or None)
+
+
+def _trim_page(p):
+    if isinstance(p, dict):
+        for k in ("markdown", "text", "cleanHtml", "html"):
+            if isinstance(p.get(k), str) and len(p[k]) > MARKDOWN_CAP:
+                p[k] = p[k][:MARKDOWN_CAP] + f"\n… [{len(p[k]) - MARKDOWN_CAP} more characters; fetch this page alone for all of it]"
+        p.pop("response", None)
+    return p
+
+
+def _safe(fn):
+    try:
+        return fn()
+    except MeshArcError as exc:
+        return {"error": exc.detail, "status": exc.status}
+    except Exception as exc:                          # noqa: BLE001
+        return {"error": f"{type(exc).__name__}: {exc}"}
+
+
+@server.tool(description="Scrape a list of URLs (up to 500) into markdown, no project needed. Waits for the batch. "
+                         "One URL is answered in the same request where the page is quick. "
+                         "`config` is any subset of a project config, e.g. {\"formats\": [\"markdown\", \"text\"], \"concurrency\": 4, \"render_js\": \"always\"}.")
+def scrape_urls(urls: list[str], config: dict | None = None, formats: str = "markdown") -> dict:
+    def go():
+        with _client() as s:
+            if len(urls) == 1:
+                # One URL takes the synchronous path: the API holds the
+                # request open for the page rather than making us poll.
+                return {"status": "done", "urls": 1,
+                        "pages": [_trim_page(s.scrape(urls[0], config=config, formats=formats))]}
+            b = s.scrape(urls, config=config, formats=formats)
+            b["pages"] = [_trim_page(p) for p in b.get("pages", [])[:PAGES_CAP]]
+            return b
+    return _safe(go)
+
+
+@server.tool(description="Extract one URL with every format a project can produce (markdown, text, cleanHtml, "
+                         "json fields, screenshot), through the fetch ladder: plain http first, a browser only "
+                         "when needed or when render_js is 'always'. Browser `actions` (click, type, select, press, "
+                         "wait, scroll; a click with repeat 'until_gone' for Load-more buttons; `each` to click "
+                         "every match of a selector and run nested steps) run before the page is read.")
+def extract_url(url: str, config: dict | None = None) -> dict:
+    def go():
+        with _client() as s:
+            r = s.extract(url, config=config)
+            if r.get("page"):
+                r["page"] = _trim_page(r["page"])
+                r["page"].pop("links", None)
+            return r
+    return _safe(go)
+
+
+@server.tool(description="Every URL a site declares in its sitemaps -- robots.txt, the well-known paths, and every "
+                         "index file walked to its children -- without fetching any of the pages. Cheap, and the right "
+                         "first step before crawling: it says how big a site is and what sections it has. `search` "
+                         "narrows to URLs containing a string.")
+def map_site(url: str, search: str | None = None, limit: int = 1000) -> dict:
+    def go():
+        with _client() as s:
+            out = s.map_details(url, search=search, limit=min(limit, 5000))
+            return {"url": out["url"], "method": out["method"], "totals": out["totals"],
+                    "urls": [u["url"] for u in out["data"]],
+                    "sections": sorted({u.get("section", "") for u in out["data"] if u.get("section")})}
+    return _safe(go)
+
+
+@server.tool(description="Crawl a whole site once and return its pages -- no project needed. Follows links from the "
+                         "URL given, reads the sitemap, and stops at `limit` pages. Returns when the crawl finishes "
+                         "(minutes for a large limit); the pages come back with markdown, capped per page. "
+                         "`crawl_id` in the result can be handed to keep_crawl_as_project.")
+def crawl_site(url: str, limit: int = 50, max_depth: int = 3, include_paths: list[str] | None = None,
+               exclude_paths: list[str] | None = None, config: dict | None = None) -> dict:
+    def go():
+        with _client() as s:
+            opts = {"limit": min(limit, 5000), "maxDepth": max_depth}
+            if include_paths:
+                opts["includePaths"] = include_paths
+            if exclude_paths:
+                opts["excludePaths"] = exclude_paths
+            if config:
+                opts["config"] = config
+            job = s.crawl(url, **opts)
+            pages = [_trim_page(p) for p in job.pages(limit=50)][:PAGES_CAP]
+            e = job.envelope
+            return {"crawl_id": job.id, "status": e.get("status"), "url": url,
+                    "pages": pages, "counts": e.get("counts"), "stop": e.get("stop", ""),
+                    "note": ("this crawl is kept for a day unless keep_crawl_as_project is called"
+                             if e.get("ephemeral") else "")}
+    return _safe(go)
+
+
+@server.tool(description="Keep a crawl from crawl_site as a project, so the site is watched over time and its changes "
+                         "are recorded. Nothing is re-fetched: the crawl's pages become the project's first run. "
+                         "schedule: manual | hourly | daily | weekly.")
+def keep_crawl_as_project(crawl_id: str, name: str | None = None, schedule: str = "manual") -> dict:
+    def go():
+        with _client() as s:
+            return s.get_crawl(crawl_id).keep(name=name, schedule=schedule)
+    return _safe(go)
+
+
+@server.tool(description="The workspace's projects: sites watched over time, with their last run's counts.")
+def list_projects() -> list | dict:
+    return _safe(lambda: [{k: p.get(k) for k in ("id", "name", "seed", "host", "schedule", "pages", "coverage", "lastRun", "health")}
+                          for p in _client().projects.list()])
+
+
+@server.tool(description="Create a project for a site (seed URL) so it is crawled on a schedule and its changes recorded. "
+                         "schedule: manual | hourly | daily | weekly.")
+def create_project(seed: str, name: str | None = None, schedule: str = "manual", config: dict | None = None) -> dict:
+    return _safe(lambda: _client().projects.create(seed, name=name, schedule=schedule, config=config))
+
+
+@server.tool(description="Start a crawl of a project now. With wait=true, returns the finished run (may take minutes).")
+def start_run(project_id: str, wait: bool = False) -> dict:
+    return _safe(lambda: _client().runs.start(project_id, wait=wait))
+
+
+@server.tool(description="The pages of a project's last finished run (or run_id): url, status, depth, words, when changed.")
+def list_pages(project_id: str, run_id: str | None = None) -> dict:
+    def go():
+        r = _client().pages(project_id, run_id)
+        r["pages"] = r.get("pages", [])[:500]
+        return r
+    return _safe(go)
+
+
+@server.tool(description="One stored page in full: markdown, head fields, fields, and its versions across runs.")
+def get_page(project_id: str, url: str, run_id: str | None = None) -> dict:
+    return _safe(lambda: _trim_page(_client().page(project_id, url, run_id)))
+
+
+@server.tool(description="What changed in a project's last run against the run before it: pages added, modified, "
+                         "removed (withheld when the crawl reached under 90% of the site), and head-field changes.")
+def get_changes(project_id: str, run_id: str | None = None) -> dict:
+    def go():
+        r = _client().changes(project_id, run_id)
+        ch = r.get("change") or {}
+        for k in ("feed", "fields", "withheld"):
+            if isinstance(ch.get(k), list):
+                ch[k] = ch[k][:200]
+        return r
+    return _safe(go)
+
+
+@server.tool(description="Search inside a project's run. mode 'content': every word must appear, \"quoted phrases\" as written, "
+                         "over the extracted markdown. mode 'selector': a CSS selector or XPath (starting with / or () over the stored html.")
+def search_pages(project_id: str, q: str, mode: str = "content", run_id: str | None = None) -> dict:
+    return _safe(lambda: _client().search(project_id, q, mode=mode, run_id=run_id))
+
+
+@server.tool(description="Fetch listed pages of a project again now, as a run of their own compared against the last full run.")
+def recrawl_pages(project_id: str, urls: list[str]) -> dict:
+    return _safe(lambda: _client().recrawl(project_id, urls))
+
+
+def main() -> None:
+    """The `mesharc-mcp` command: serve over stdio."""
+    server.run("stdio")
+
+
+if __name__ == "__main__":
+    main()

mesharc-0.1.2.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: mesharc
+Version: 0.1.2
+Summary: Python client for the MeshArc API: a URL in, clean content out, and a record of what changed.
+License: MIT
+Project-URL: Homepage, https://mesharc.dev
+Project-URL: Documentation, https://mesharc.dev/docs/sdks
+Project-URL: Source, https://github.com/mesharc-org/mesharc-python
+Project-URL: Issues, https://github.com/mesharc-org/mesharc-python/issues
+Keywords: scraping,crawler,web-data,change-detection,sitemap,markdown,llm
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; python_version >= "3.10" and extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# mesharc
+
+The Python client for the [MeshArc](https://mesharc.dev) API: a URL in, clean content out, and a record of what changed.
+
+- **Scrape** one page or a batch — markdown, text, HTML, links, structured fields, a screenshot.
+- **Crawl** a whole site with no project to set up first, and keep it as one if it turns out to be worth watching.
+- **Map** what a site declares in its sitemaps before fetching any of it.
+- **Watch** a site over time: projects, scheduled runs, and a change record — pages added, removed, modified, field by field.
+
+Python 3.9 or newer. One dependency (`httpx`). Fully typed.
+
+## Install
+
+```bash
+pip install mesharc
+```
+
+## Authentication
+
+Every call needs an API key. Create one in the app under **Settings → API keys** — it is shown once — and give it to the client, or put it in `MESHARC_API_KEY` and construct the client with nothing:
+
+```python
+from mesharc import MeshArc
+
+arc = MeshArc("mesharc_...")
+# or, with MESHARC_API_KEY in the environment:
+arc = MeshArc()
+# options: MeshArc(api_key, timeout=150.0, max_retries=2)
+```
+
+The key is only ever sent as a bearer header to `api.mesharc.dev`.
+
+A key carries the scopes it was made with (`read`, `write`, `admin`), optionally a set of projects it may see, an expiry and a rate limit. A route the key may not use answers `403`; a project it may not see answers `404`.
+
+## Quick start
+
+```python
+from mesharc import MeshArc
+
+arc = MeshArc("mesharc_...")
+
+page = arc.scrape("https://example.com/pricing")
+print(page["markdown"])
+print(page["verdict"], page["method"], page["credits"])   # ok crawler 1
+```
+
+`scrape` holds the request open until the page comes back (60 s by default), so there is nothing to poll for an ordinary page.
+
+## Reading pages
+
+### One page
+
+```python
+page = arc.scrape("https://quotes.toscrape.com/js/", config={"render_js": "always"})
+```
+
+`config` is any setting a project takes, by its API name (`render_js`, `only_main_content`, `formats`, `max_tier`, `wait_for_selector`, `actions`, …). The full list, with defaults, is at [mesharc.dev/docs/configuration](https://mesharc.dev/docs/configuration).
+
+```python
+page = arc.scrape_one(
+    "https://example.com/",
+    formats="markdown,text,cleanHtml",     # which bodies to return
+    timeout_s=120,                         # how long the API holds the request (120 max)
+    idempotency_key="pricing-2026-09-18",  # the same key returns the first answer for 24 h
+)
+```
+
+### Many pages
+
+A list of URLs is a batch: grouped by host, fetched in parallel where the config allows, and returned as one row per URL.
+
+```python
+batch = arc.scrape(["https://a.com/", "https://b.com/x"], config={"concurrency": 4})
+for row in batch["pages"]:
+    print(row["url"], row["httpStatus"], row["verdict"], row["credits"])
+```
+
+`arc.scrape(urls, wait=False)` returns the batch id at once; `arc.batch(id, wait=True)` finishes it later. Pass `webhook_url=` to be told instead of polling (`batch.finished`, signed with a secret returned once).
+
+### What a page looks like
+
+Every page row carries the same fields, whether it came from a scrape, a crawl or a project:
+
+| Field | Meaning |
+|---|---|
+| `markdown`, `text`, `cleanHtml`, `html`, `links`, `fields`, `screenshot` | The bodies you asked for |
+| `httpStatus` | The status the site answered with |
+| `verdict` | `ok`, `thin` (short, but a page), `blocked` (refused, or a 404), `skipped` |
+| `errorCode` | `OK`, or what went wrong: `BLOCKED`, `NOT_FOUND`, `TIER_LIMIT`, `CAPTCHA`, `LOGIN_REQUIRED`, `RATE_LIMITED`, `TIMEOUT` … |
+| `shape`, `warnings`, `signals` | `listing` / `table` / `form` for a short page whose markup says what it is; `short`; why the judge decided as it did |
+| `method`, `tier`, `climbedTo` | The engine that read it (`crawler`, `tls`, `minted`, `browser`, `browser-residential`, …), its tier, and how far a refused page climbed |
+| `credits`, `billedAs` | What it cost; the rung it is priced at when not the one that fetched it |
+| `words`, `language`, `head`, `reason`, `crawledAt` | Size, language, the head fields, the judge's sentence, when |
+
+A page the site refused costs 0, and so does a 404.
+
+## Crawling a site
+
+```python
+job = arc.crawl(
+    "https://docs.example.com",
+    limit=200,                          # page budget
+    maxDepth=3,                         # link hops from the seed
+    includePaths=["/docs/*"],
+    crawlMode="sitemap_first",          # what the sitemap declares first, then links
+    maxTier="browser",                  # how far a refused page may climb
+    scrapeOptions={"formats": ["markdown", "links"]},
+    config={"crawl_delay_ms": 500},     # any project setting, directly
+)
+
+for page in job.pages():                # follows the cursor while the crawl runs
+    print(page["url"], page["words"])
+print(job.status, job.envelope["counts"], job.envelope["creditsUsed"])
+```
+
+`crawl` returns a handle immediately; `job.pages()` yields pages as they land and ends when the crawl does. `wait=True` blocks until it finishes; `job.wait()`, `job.refresh()`, `job.cancel()` do what they say; `arc.get_crawl(id)` reattaches to a crawl started elsewhere.
+
+A one-shot crawl expires after 30 days. If the site is worth watching:
+
+```python
+project = job.keep(name="Docs", schedule="weekly")
+```
+
+A `webhook=` in the options (`{"url", "events", "metadata"}`) is told about `crawl.started`, `crawl.page` (fifty pages a message) and `crawl.completed`; its signing secret comes back once as `job.webhook_secret`.
+
+## Mapping a site
+
+```python
+for u in arc.map("https://docs.example.com"):
+    print(u["url"], u["lastmod"])
+
+details = arc.map_details("https://www.gov.uk/", search="visa", limit=500)
+print(details["totals"], details["creditsUsed"])   # {'files': 29, 'urls': 508431, …} 29
+```
+
+A map costs one credit per sitemap file read — most sites are one file.
+
+## Watching a site: projects and runs
+
+```python
+project = arc.projects.create(
+    "https://docs.example.com",
+    name="Docs",
+    schedule="weekly",                                        # manual | hourly | daily | weekly
+    config={"max_pages": 300, "include_paths": ["/docs/*"]},
+)
+
+run = arc.runs.start(project["id"], wait=True)                # the first run
+# ...a week later, or arc.runs.start again: the second run produces the change record
+
+record = arc.changes(project["id"])
+print(record["change"]["counts"])   # {'added': …, 'removed': …, 'modified': …, 'withheld': …}
+
+diff = arc.page_diff(project["id"], "https://docs.example.com/pricing")
+```
+
+| Method | What it does |
+|---|---|
+| `projects.list()` · `projects.get(id)` · `projects.update(id, name=, schedule=, retention=, config=)` · `projects.delete(id)` | The projects |
+| `runs.list(project_id)` · `runs.start(project_id, wait=)` · `runs.wait(project_id, run_id)` · `runs.get(project_id, run_id)` · `runs.cancel(project_id, run_id)` | Runs |
+| `pages(project_id, run_id=None)` · `page(project_id, url, run_id=None)` | The pages of a run; one page in full |
+| `changes(project_id, run_id=None)` · `page_diff(project_id, url, run_id=None)` | The change record; one page's word-level diff |
+| `search(project_id, q, mode="content" \| "selector", run_id=None)` | Which pages say this (words, `"phrases"`) or contain this (CSS / XPath) |
+| `recrawl(project_id, urls)` | Fetch these pages again, now |
+| `sources(project_id)` | The seed, sitemap, URL list, feeds and patterns with what the last run found through each |
+| `export(project_id, path, dataset="pages", fmt="jsonl", run_id=None, urls=None)` | Stream a dataset (`pages`, `markdown`, `changes`, `fields`, `sitemap`) as `jsonl` or `csv` to a file |
+
+```python
+arc.export(project["id"], "pages.csv", dataset="pages", fmt="csv")
+```
+
+## The workspace
+
+```python
+me = arc.me()               # the workspace, its plan and limits, credits used and remaining, what this key may do
+usage = arc.usage()         # pages per day, this month by engine
+monitor = arc.monitor()     # what is queued and running
+meta = arc.meta()           # verdict meanings, engine costs, the config defaults
+keys = arc.keys()
+key = arc.create_key("ci", scopes=["read", "write"], projects=[project["id"]], expires_in_days=90)   # key["key"], once
+arc.revoke_key(key["id"])
+```
+
+## Errors
+
+Every failure raises `MeshArcError`:
+
+```python
+from mesharc import MeshArc, MeshArcError
+
+try:
+    arc.crawl("https://example.com", limit=1_000_000)
+except MeshArcError as exc:
+    print(exc.status, exc.code, exc.detail, exc.request_id)
+```
+
+| `code` | Status | Meaning |
+|---|---|---|
+| `validation` | 400 / 422 | Something in the request is wrong; `detail` says what |
+| `unauthorized` | 401 | No key, or a revoked or expired one |
+| `plan_limit` | 402 | The plan does not include this, or the credits are spent |
+| `forbidden` | 403 | The key's scopes do not allow it |
+| `not_found` | 404 | No such thing — or not one this key may see |
+| `conflict` | 409 | The request contradicts current state |
+| `rate_limited` | 429 | Over the key's rate limit; `X-RateLimit-Reset` says when |
+| `internal` | 500 | Quote `request_id` to support |
+
+`request_id` is the id the API put on the response and in its own logs, so a support conversation starts from one string.
+
+Two more cases: a network failure or a request that hits `timeout` raises `MeshArcError` with `status == 0` and `code` `network` or `timeout`; a job the client stopped waiting for raises `MeshArcTimeoutError` — both a `MeshArcError` and a `TimeoutError` — which carries `job_id` so you can poll it later (`arc.get_crawl(id)`, `arc.batch(id)`).
+
+## Idempotency and timeouts
+
+- `scrape`, `scrape_one` and `crawl` take `idempotency_key=`: send the same key again within 24 hours and you get the first answer back rather than a second job.
+- Waiting calls take `wait=`, `poll=` (seconds between polls) and `timeout=` (seconds before `TimeoutError`). `wait=False` returns the envelope at once; the default polls every 3 s for up to an hour.
+- `timeout_s` on a single scrape is how long the API itself holds the request open (60 s by default, 120 at most); a slower page comes back as an id and is polled.
+- `MeshArc(..., timeout=150.0)` is the HTTP timeout per request. A request is retried on 429, 502, 503, 504 and network failures when it is safe to repeat — a GET, a DELETE, or a POST with an idempotency key — up to `max_retries` times (2), honouring `Retry-After`.
+
+## Credits
+
+Every response says what it cost: `credits` on a page, `creditsUsed` on a job envelope, `X-MeshArc-Credits` on the HTTP response. A page costs the engine that read it — a plain fetch 1, a render 4 — and a refused page or a 404 costs nothing. The schedule and the plans are at [mesharc.dev/docs/billing](https://mesharc.dev/docs/billing).
+
+## The MCP server
+
+The package also ships MeshArc as an MCP server, so Claude Desktop, Claude Code, Cursor and any MCP client can scrape, crawl, map and read change records as tools. Python 3.10+.
+
+```bash
+pip install "mesharc[mcp]"
+MESHARC_API_KEY=mesharc_... mesharc-mcp          # serves over stdio
+
+# Claude Code
+claude mcp add mesharc -e MESHARC_API_KEY=mesharc_... -- mesharc-mcp
+```
+
+Tools: `scrape_urls`, `extract_url`, `map_site`, `crawl_site`, `keep_crawl_as_project`, `list_projects`, `create_project`, `start_run`, `list_pages`, `get_page`, `get_changes`, `search_pages`, `recrawl_pages`. Every tool is a call through this client, trimmed where a body would swamp a context window (markdown is capped per page; ask for one page to get all of it).
+
+## Anything else
+
+The client is a thin wrapper: every method is one API call and returns the API's JSON as a `dict`. The full reference is at [mesharc.dev/docs/api](https://mesharc.dev/docs/api). Call `arc.close()` when you are done, or use the client as a context manager.
+
+- Documentation: [mesharc.dev/docs](https://mesharc.dev/docs)
+- Node client: `npm install mesharc` — [mesharc-node](https://github.com/mesharc-org/mesharc-node)
+- Issues and pull requests: [mesharc-python](https://github.com/mesharc-org/mesharc-python)
+- Questions: hello@mesharc.dev
+
+MIT.

mesharc-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+mesharc/__init__.py,sha256=hmvqwrTHauN2Tqvg3MjrjMLnONhxcGxYLnkXbOJfJoA,24301
+mesharc/mcp.py,sha256=GTL8mWD1rpO5uKBdg5Wr2fOGR0XMr4Dv9EXWbhcccCM,10464
+mesharc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mesharc-0.1.2.dist-info/licenses/LICENSE,sha256=gUvBXupjjMPMIBGEtujNeVFxFKCDu8RAGWpOgfV0Nas,1085
+mesharc-0.1.2.dist-info/METADATA,sha256=jKyPYYy0nE-45pDVuOJj7Vq4q8YvE55v1eJ4VehlSXI,13448
+mesharc-0.1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mesharc-0.1.2.dist-info/entry_points.txt,sha256=zqwmWOlh9U__HARPXqxApyRYJQoeHhsRbQyyCh3WNHQ,49
+mesharc-0.1.2.dist-info/top_level.txt,sha256=KXErx_IOhEs5npgSe59IMxFKY68k1jHDYX2bfU7-jKI,8
+mesharc-0.1.2.dist-info/RECORD,,

mesharc-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mesharc-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mesharc-mcp = mesharc.mcp:main

mesharc-0.1.2.dist-info/licenses/LICENSE

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

mesharc-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+mesharc