llms-ink 0.1.0__py3-none-any.whl

llms_ink/__init__.py

@@ -0,0 +1,41 @@
+"""Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt.
+
+    >>> from llms_ink import Client
+    >>> Client().llms("llmstxt.org").text
+"""
+
+__version__ = "0.1.0"
+
+from .client import (  # noqa: E402
+    DEFAULT_BASE_URL,
+    BrokenLink,
+    CheckIssue,
+    CheckLinks,
+    CheckResult,
+    CheckSummary,
+    Client,
+    Media,
+    Result,
+    Segment,
+    Transcript,
+)
+from .errors import InvalidKey, LlmsInkError, QuotaExceeded, RateLimited  # noqa: E402
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "BrokenLink",
+    "CheckIssue",
+    "CheckLinks",
+    "CheckResult",
+    "CheckSummary",
+    "Client",
+    "InvalidKey",
+    "LlmsInkError",
+    "Media",
+    "QuotaExceeded",
+    "RateLimited",
+    "Result",
+    "Segment",
+    "Transcript",
+    "__version__",
+]

llms_ink/__main__.py

@@ -0,0 +1,45 @@
+"""python -m llms_ink <url> [--full] [--fresh] [--json]: prints llms.txt (or llms-full.txt) for a link."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .client import Client
+from .errors import LlmsInkError, QuotaExceeded, RateLimited
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="python -m llms_ink",
+        description="Print llms.txt for any link: a site, docs section, page, GitHub repo, PDF or video.",
+        epilog="Uses LLMS_INK_KEY as the API key when set (optional).",
+    )
+    parser.add_argument("url", help="any public link, e.g. llmstxt.org")
+    parser.add_argument("--full", action="store_true", help="llms-full.txt (the content) instead of the index")
+    parser.add_argument("--fresh", action="store_true", help="skip the cache and rebuild")
+    parser.add_argument("--json", action="store_true", help="the whole API result as JSON")
+    parser.add_argument("--version", action="version", version=f"llms-ink {__version__}")
+    args = parser.parse_args(argv)
+
+    try:
+        result = Client().llms(args.url, mode="full" if args.full else "llms", fresh=args.fresh)
+    except LlmsInkError as err:
+        message = err.detail
+        if isinstance(err, (RateLimited, QuotaExceeded)) and err.retry_after is not None:
+            message += f" Try again in {err.retry_after}s."
+        print(f"llms-ink: {message}", file=sys.stderr)
+        return 1
+
+    if args.json:
+        print(json.dumps(result.raw, indent=2, ensure_ascii=False))
+    else:
+        sys.stdout.write(result.text if result.text.endswith("\n") else result.text + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

llms_ink/client.py

@@ -0,0 +1,289 @@
+"""The llms.ink JSON API (https://llms.ink/docs/) over the standard library's urllib."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from typing import Any, Dict, List, Optional
+
+from . import __version__
+from .errors import LlmsInkError, error_for
+
+DEFAULT_BASE_URL = "https://llms.ink"
+MODES = ("llms", "full")
+
+
+@dataclass
+class Segment:
+    """A transcript line; ``start`` and ``end`` are seconds into the source video."""
+
+    start: float
+    end: float
+    text: str
+
+
+@dataclass
+class Transcript:
+    source: str
+    segments: List[Segment]
+
+
+@dataclass
+class Media:
+    """Video results only: what ``/api/v0/frame`` and ``/api/v0/media`` can serve."""
+
+    duration: Optional[float]
+    has_video: bool
+    has_audio: bool
+    thumbnail: Optional[str]
+    downloads: List[str]
+    is_live: Optional[bool] = None
+    transcript: Optional[Transcript] = None
+
+    @classmethod
+    def from_json(cls, d: Dict[str, Any]) -> "Media":
+        t = d.get("transcript")
+        return cls(
+            duration=d.get("duration"),
+            has_video=bool(d.get("hasVideo")),
+            has_audio=bool(d.get("hasAudio")),
+            thumbnail=d.get("thumbnail"),
+            downloads=list(d.get("downloads") or []),
+            is_live=d.get("isLive"),
+            transcript=Transcript(
+                source=t.get("source", ""),
+                segments=[Segment(s["start"], s["end"], s["text"]) for s in t.get("segments") or []],
+            )
+            if t
+            else None,
+        )
+
+
+@dataclass
+class Result:
+    """``GET /api/v0/llms``: the llms.txt or llms-full.txt of a link and what it was built from.
+
+    ``kind`` is ``site``, ``section``, ``page``, ``repo``, ``document`` or ``video``; ``source`` is ``native``
+    (published by the site) or ``generated`` (made by llms.ink). ``text`` is the Markdown file.
+    """
+
+    url: str
+    kind: str
+    source: str
+    mode: str
+    title: str
+    text: str
+    tokens: int
+    pages: int
+    model: Optional[str]
+    cached: bool
+    generated_at: str
+    media: Optional[Media] = None
+    raw: Dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+    @classmethod
+    def from_json(cls, d: Dict[str, Any]) -> "Result":
+        return cls(
+            url=d.get("url", ""),
+            kind=d.get("kind", ""),
+            source=d.get("source", ""),
+            mode=d.get("mode", ""),
+            title=d.get("title", ""),
+            text=d.get("text", ""),
+            tokens=d.get("tokens", 0),
+            pages=d.get("pages", 0),
+            model=d.get("model"),
+            cached=bool(d.get("cached")),
+            generated_at=d.get("generatedAt", ""),
+            media=Media.from_json(d["media"]) if d.get("media") else None,
+            raw=d,
+        )
+
+
+@dataclass
+class CheckIssue:
+    """``level`` is ``error``, ``warning`` or ``info``; ``code`` names the check (``missing_title``, ``broken_link``…)."""
+
+    level: str
+    code: str
+    line: Optional[int]
+    message: str
+
+
+@dataclass
+class BrokenLink:
+    url: str
+    status: int  # 0 when it didn't answer in time
+
+
+@dataclass
+class CheckLinks:
+    total: int
+    checked: int
+    broken: List[BrokenLink]
+
+
+@dataclass
+class CheckSummary:
+    errors: int
+    warnings: int
+
+
+@dataclass
+class CheckResult:
+    """``GET /api/v0/check``: a published llms.txt checked against the format and its links."""
+
+    site: str
+    url: str
+    found: bool
+    status: int
+    title: Optional[str]
+    tokens: int
+    sections: int
+    links: CheckLinks
+    llms_full: bool
+    issues: List[CheckIssue]
+    summary: CheckSummary
+    checked_at: str
+    raw: Dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+    @classmethod
+    def from_json(cls, d: Dict[str, Any]) -> "CheckResult":
+        links = d.get("links") or {}
+        summary = d.get("summary") or {}
+        return cls(
+            site=d.get("site", ""),
+            url=d.get("url", ""),
+            found=bool(d.get("found")),
+            status=d.get("status", 0),
+            title=d.get("title"),
+            tokens=d.get("tokens", 0),
+            sections=d.get("sections", 0),
+            links=CheckLinks(
+                total=links.get("total", 0),
+                checked=links.get("checked", 0),
+                broken=[BrokenLink(b["url"], b["status"]) for b in links.get("broken") or []],
+            ),
+            llms_full=bool(d.get("llmsFull")),
+            issues=[CheckIssue(i["level"], i["code"], i.get("line"), i["message"]) for i in d.get("issues") or []],
+            summary=CheckSummary(errors=summary.get("errors", 0), warnings=summary.get("warnings", 0)),
+            checked_at=d.get("checkedAt", ""),
+            raw=d,
+        )
+
+
+class Client:
+    """A client for https://llms.ink.
+
+    ``key`` is an optional API key (``lk_…``), sent as ``Authorization: Bearer``; it defaults to the
+    ``LLMS_INK_KEY`` environment variable. Without one, requests are anonymous and share the free limits.
+    ``base_url`` defaults to ``LLMS_INK_API`` or https://llms.ink. Building a big site or a video can take
+    minutes, hence the long default ``timeout`` (seconds).
+    """
+
+    def __init__(
+        self,
+        key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = 300.0,
+    ) -> None:
+        key = key if key is not None else os.environ.get("LLMS_INK_KEY")
+        self.key = key.strip() if key and key.strip() else None
+        self.base_url = (base_url or os.environ.get("LLMS_INK_API") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+
+    def __repr__(self) -> str:
+        return f"Client(base_url={self.base_url!r}, key={'set' if self.key else None!r})"
+
+    def llms(self, url: str, mode: str = "llms", fresh: bool = False) -> Result:
+        """llms.txt (``mode='llms'``, an index of links) or llms-full.txt (``mode='full'``, the content inlined)
+        for any public link. ``fresh=True`` skips the cache and rebuilds (counts against the daily quota)."""
+        if mode not in MODES:
+            raise ValueError(f"mode must be 'llms' (the index) or 'full' (llms-full.txt), not {mode!r}")
+        params = {"url": url, "mode": mode}
+        if fresh:
+            params["fresh"] = "1"
+        return Result.from_json(self._get("/api/v0/llms", params))
+
+    def check(self, url: str) -> CheckResult:
+        """Checks a site's published llms.txt against the format and that its links answer."""
+        return CheckResult.from_json(self._get("/api/v0/check", {"url": url}))
+
+    def _get(self, path: str, params: Dict[str, str]) -> Dict[str, Any]:
+        headers = {"Accept": "application/json", "User-Agent": f"llms-ink-python/{__version__}"}
+        if self.key:
+            headers["Authorization"] = f"Bearer {self.key}"
+        request = urllib.request.Request(f"{self.base_url}{path}?{urllib.parse.urlencode(params)}", headers=headers)
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as res:
+                body = res.read()
+        except urllib.error.HTTPError as err:
+            raise _problem(err) from None
+        except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError) as err:
+            reason = getattr(err, "reason", err)
+            raise LlmsInkError(f"Couldn't reach {self.base_url}: {reason}") from err
+        try:
+            return json.loads(body)
+        except ValueError as err:
+            raise LlmsInkError(f"{self.base_url}{path} answered with something other than JSON.") from err
+
+
+def _problem(err: urllib.error.HTTPError) -> LlmsInkError:
+    """An HTTP error response → the typed error for its problem ``code``."""
+    raw = err.read()
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        data = None
+    if not isinstance(data, dict):
+        data = {}
+    status = data.get("status") if isinstance(data.get("status"), int) else err.code
+    detail = data.get("detail") or data.get("title") or f"HTTP {err.code} {err.reason or 'error'}"
+    code = data.get("code")
+    return error_for(code)(
+        detail,
+        status=status,
+        code=code,
+        title=data.get("title"),
+        errors=data.get("errors"),
+        retry_after=_retry_after(err.headers.get("Retry-After") if err.headers else None),
+    )
+
+
+def _retry_after(value: Optional[str]) -> Optional[int]:
+    """``Retry-After`` as seconds: delta-seconds, or an HTTP date turned into seconds from now."""
+    if not value:
+        return None
+    value = value.strip()
+    if value.isdigit():
+        return int(value)
+    try:
+        when = parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if when is None:
+        return None
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=timezone.utc)
+    return max(0, int((when - datetime.now(timezone.utc)).total_seconds()))
+
+
+def _metadata(result: Result) -> Dict[str, Any]:
+    """Document metadata for the LangChain and LlamaIndex loaders."""
+    return {
+        "url": result.url,
+        "title": result.title,
+        "kind": result.kind,
+        "source": result.source,
+        "mode": result.mode,
+        "tokens": result.tokens,
+        "generated_at": result.generated_at,
+    }

llms_ink/errors.py

@@ -0,0 +1,56 @@
+"""Typed errors from the API's RFC 9457 problem details (codes at https://llms.ink/docs/#errors)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class LlmsInkError(Exception):
+    """An API error, or llms.ink couldn't be reached (then ``status`` and ``code`` are ``None``).
+
+    ``code`` is the problem's machine-readable code (``invalid_url``, ``unprocessable``, ``upstream_error``…),
+    ``detail`` the human-readable message, ``errors`` the per-parameter issues of ``invalid_request``.
+    ``retry_after`` is the ``Retry-After`` header in seconds, when the response had one.
+    """
+
+    def __init__(
+        self,
+        detail: str,
+        *,
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        title: Optional[str] = None,
+        errors: Optional[List[Dict[str, Any]]] = None,
+        retry_after: Optional[int] = None,
+    ) -> None:
+        super().__init__(detail)
+        self.detail = detail
+        self.status = status
+        self.code = code
+        self.title = title
+        self.errors = errors or []
+        self.retry_after = retry_after
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(status={self.status!r}, code={self.code!r}, detail={self.detail!r})"
+
+
+class InvalidKey(LlmsInkError):
+    """401 ``invalid_key``: the API key is unknown or revoked. Requests never fall back to anonymous."""
+
+
+class RateLimited(LlmsInkError):
+    """429 ``rate_limited``: too many requests this minute; wait ``retry_after`` seconds."""
+
+
+class QuotaExceeded(LlmsInkError):
+    """429 ``quota_exceeded``: the daily quota of new links is used up; ``retry_after`` is the seconds until it
+    resets (midnight UTC). Cached links still work."""
+
+
+_BY_CODE = {"invalid_key": InvalidKey, "rate_limited": RateLimited, "quota_exceeded": QuotaExceeded}
+
+
+def error_for(code: Optional[str]) -> type:
+    """The exception class for a problem ``code``."""
+    return _BY_CODE.get(code or "", LlmsInkError)

llms_ink/langchain.py

@@ -0,0 +1,44 @@
+"""LangChain document loader: ``pip install 'llms-ink[langchain]'``.
+
+    >>> from llms_ink.langchain import LlmsInkLoader
+    >>> docs = LlmsInkLoader(["docs.astro.build/en/guides/"], mode="full").load()
+"""
+
+from __future__ import annotations
+
+from typing import Iterator, Optional, Sequence, Union
+
+try:
+    from langchain_core.document_loaders import BaseLoader
+    from langchain_core.documents import Document
+except ImportError as err:  # pragma: no cover
+    raise ImportError("LlmsInkLoader needs langchain-core: pip install 'llms-ink[langchain]'") from err
+
+from .client import MODES, Client, _metadata
+
+
+class LlmsInkLoader(BaseLoader):
+    """One Document per link: llms.txt (``mode='llms'``) or llms-full.txt (``mode='full'``) as
+    ``page_content``, with metadata ``url``, ``title``, ``kind``, ``source``, ``mode``, ``tokens`` and
+    ``generated_at``. ``key`` defaults to ``LLMS_INK_KEY``; pass ``client`` to reuse one."""
+
+    def __init__(
+        self,
+        urls: Union[str, Sequence[str]],
+        mode: str = "llms",
+        *,
+        fresh: bool = False,
+        key: Optional[str] = None,
+        client: Optional[Client] = None,
+    ) -> None:
+        if mode not in MODES:
+            raise ValueError(f"mode must be 'llms' or 'full', not {mode!r}")
+        self.urls = [urls] if isinstance(urls, str) else list(urls)
+        self.mode = mode
+        self.fresh = fresh
+        self.client = client or Client(key)
+
+    def lazy_load(self) -> Iterator[Document]:
+        for url in self.urls:
+            result = self.client.llms(url, mode=self.mode, fresh=self.fresh)
+            yield Document(page_content=result.text, metadata=_metadata(result))

llms_ink/llama_index.py

@@ -0,0 +1,46 @@
+"""LlamaIndex reader: ``pip install 'llms-ink[llama-index]'``.
+
+    >>> from llms_ink.llama_index import LlmsInkReader
+    >>> docs = LlmsInkReader(mode="full").load_data(["docs.astro.build/en/guides/"])
+"""
+
+from __future__ import annotations
+
+from typing import Iterator, List, Optional, Union
+
+try:
+    from llama_index.core import Document
+    from llama_index.core.readers.base import BaseReader
+except ImportError as err:  # pragma: no cover
+    raise ImportError("LlmsInkReader needs llama-index-core: pip install 'llms-ink[llama-index]'") from err
+
+from .client import MODES, Client, _metadata
+
+
+class LlmsInkReader(BaseReader):
+    """One Document per link: llms.txt (``mode='llms'``) or llms-full.txt (``mode='full'``) as text, with
+    metadata ``url``, ``title``, ``kind``, ``source``, ``mode``, ``tokens`` and ``generated_at``.
+    ``key`` defaults to ``LLMS_INK_KEY``; pass ``client`` to reuse one."""
+
+    def __init__(
+        self,
+        mode: str = "llms",
+        *,
+        fresh: bool = False,
+        key: Optional[str] = None,
+        client: Optional[Client] = None,
+    ) -> None:
+        if mode not in MODES:
+            raise ValueError(f"mode must be 'llms' or 'full', not {mode!r}")
+        self.mode = mode
+        self.fresh = fresh
+        self.client = client or Client(key)
+
+    def lazy_load_data(self, urls: Union[str, List[str]], mode: Optional[str] = None) -> Iterator[Document]:
+        """Documents for ``urls``; ``mode`` overrides the reader's for this call."""
+        for url in [urls] if isinstance(urls, str) else urls:
+            result = self.client.llms(url, mode=mode or self.mode, fresh=self.fresh)
+            yield Document(text=result.text, metadata=_metadata(result))
+
+    def load_data(self, urls: Union[str, List[str]], mode: Optional[str] = None) -> List[Document]:
+        return list(self.lazy_load_data(urls, mode))

llms_ink-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.5
+Name: llms-ink
+Version: 0.1.0
+Summary: Turn any link — site, docs section, page, GitHub repo, PDF or video — into llms.txt and llms-full.txt. Python client for llms.ink, with LangChain and LlamaIndex loaders.
+Project-URL: Homepage, https://llms.ink
+Project-URL: Documentation, https://llms.ink/docs/
+Author: Lucas Espindola
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,context,docs,langchain,llama-index,llm,llms-full.txt,llms.txt,markdown,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == 'langchain'
+Provides-Extra: llama-index
+Requires-Dist: llama-index-core>=0.10; extra == 'llama-index'
+Description-Content-Type: text/markdown
+
+# llms-ink
+
+Turn any public link — a site, docs section, page, GitHub repo, PDF or video — into
+[llms.txt](https://llmstxt.org) or llms-full.txt, from Python. A client for [llms.ink](https://llms.ink)
+with LangChain and LlamaIndex loaders. No required dependencies.
+
+```sh
+pip install llms-ink
+```
+
+## Use
+
+```python
+from llms_ink import Client
+
+ink = Client()
+index = ink.llms("llmstxt.org")                         # llms.txt: an index of links
+docs = ink.llms("docs.astro.build/en/guides/", mode="full")  # llms-full.txt: the content
+
+print(docs.title, docs.kind, docs.tokens)
+print(docs.text)
+```
+
+`llms()` returns a `Result`: `url`, `kind` (`site`, `section`, `page`, `repo`, `document`, `video`),
+`source` (`native` = published by the site, `generated` = made by llms.ink), `mode`, `title`, `text`,
+`tokens`, `pages`, `model`, `cached`, `generated_at`, and `media` for videos (duration, downloads,
+transcript segments). `fresh=True` skips the cache and rebuilds.
+
+Check a site's published llms.txt:
+
+```python
+report = ink.check("llmstxt.org")
+print(report.found, report.summary.errors, [i.message for i in report.issues])
+```
+
+## API key (optional)
+
+Without a key you share the free anonymous limits (10 requests/minute, 60 new links a day per IP;
+cached links are free). A key gets its own daily quota:
+
+```sh
+export LLMS_INK_KEY=lk_...
+```
+
+or `Client(key="lk_...")`. It is sent as `Authorization: Bearer`. A bad key raises `InvalidKey`; it never
+falls back to anonymous. [Ask for a key](https://lucasespindola.com/message?text=I%27d+like+an+llms.ink+API+key).
+
+## Errors
+
+```python
+from llms_ink import Client, LlmsInkError, QuotaExceeded, RateLimited
+
+try:
+    Client().llms("example.com")
+except (RateLimited, QuotaExceeded) as err:
+    print(f"wait {err.retry_after}s")
+except LlmsInkError as err:
+    print(err.status, err.code, err.detail)
+```
+
+`LlmsInkError` carries the API's `status`, `code` (see the [error table](https://llms.ink/docs/#errors)),
+`detail` and `errors`. `InvalidKey`, `RateLimited` and `QuotaExceeded` are subclasses.
+
+## LangChain
+
+```sh
+pip install 'llms-ink[langchain]'
+```
+
+```python
+from llms_ink.langchain import LlmsInkLoader
+
+docs = LlmsInkLoader(["llmstxt.org", "github.com/AnswerDotAI/llms-txt"], mode="full").load()
+docs[0].metadata  # {'url', 'title', 'kind', 'source', 'mode', 'tokens', 'generated_at'}
+```
+
+## LlamaIndex
+
+```sh
+pip install 'llms-ink[llama-index]'
+```
+
+```python
+from llama_index.core import VectorStoreIndex
+from llms_ink.llama_index import LlmsInkReader
+
+docs = LlmsInkReader(mode="full").load_data(["docs.astro.build/en/guides/"])
+index = VectorStoreIndex.from_documents(docs)
+```
+
+## Command line
+
+```sh
+python -m llms_ink llmstxt.org            # llms.txt
+python -m llms_ink llmstxt.org --full     # llms-full.txt
+python -m llms_ink llmstxt.org --json     # the whole result
+```
+
+## Development
+
+```sh
+python3 -m venv .venv && .venv/bin/pip install -e '.[langchain,llama-index]' pytest
+.venv/bin/pytest                # against a local stub server
+.venv/bin/pytest -m live        # one real call to https://llms.ink
+```
+
+`LLMS_INK_API` points the client at another API base URL.
+
+MIT licensed.

llms_ink-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+llms_ink/__init__.py,sha256=RjdpYlU81hIDdkCb1nmDXMUEEqDuhvk40xu23VhynBk,814
+llms_ink/__main__.py,sha256=dQa-hpBAGk_wPt0aD3_fZ2oXee9Fhy71fPgw4c1uIak,1778
+llms_ink/client.py,sha256=6hC-X9tVe3K4og-ZITerGTOXx7vFcrkX8GBd5DVmsh8,9442
+llms_ink/errors.py,sha256=Pqr4uZ8eW04P_DfC42pxLSSaX_Z2WdLhX4GX6fDXX6Q,1998
+llms_ink/langchain.py,sha256=RJN41PWBQOaLA9uePF0o-vV561vLlCWJvAeRtaiFNak,1679
+llms_ink/llama_index.py,sha256=PzeBKtGm3PUluXLSk0yNWL0x8YK9O2wn7ONBpSBqXag,1880
+llms_ink/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+llms_ink-0.1.0.dist-info/METADATA,sha256=Nm--sH8uC_tNNVYyAtPpME0XFETJBiVIahx7lJdEP6I,4285
+llms_ink-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+llms_ink-0.1.0.dist-info/licenses/LICENSE,sha256=FmG9pZzsJIZAObaW9nC7RL6Cx42IZ4yqJ7XH58Lj-w0,1072
+llms_ink-0.1.0.dist-info/RECORD,,

llms_ink-0.1.0.dist-info/WHEEL

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

llms_ink-0.1.0.dist-info/licenses/LICENSE

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