llms-generator 0.1.0__py3-none-any.whl

llms_generator/__init__.py

@@ -0,0 +1 @@
+from llms_generator._version import __version__

llms_generator/__main__.py

@@ -0,0 +1,4 @@
+from llms_generator.cli import main
+
+if __name__ == "__main__":
+    main()

llms_generator/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

llms_generator/cli.py

@@ -0,0 +1,77 @@
+import argparse
+import sys
+
+from llms_generator.crawler import Crawler
+from llms_generator.section_grouper import group_pages
+from llms_generator.generator import generate_llms_txt
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="llms-gen",
+        description="Crawl a website and generate llms.txt",
+    )
+    parser.add_argument("url", help="Target website URL")
+    parser.add_argument(
+        "--depth",
+        type=int,
+        default=2,
+        help="Maximum crawl depth (default: 2)",
+    )
+    parser.add_argument(
+        "--output",
+        default="llms.txt",
+        help="Output file path (default: llms.txt)",
+    )
+    parser.add_argument(
+        "--full",
+        action="store_true",
+        help="Also generate llms-full.txt with full page content",
+    )
+    parser.add_argument(
+        "--no-js",
+        action="store_true",
+        help="Skip Playwright JavaScript rendering fallback",
+    )
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=1.0,
+        help="Seconds between requests (default: 1.0)",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+
+    crawler = Crawler(
+        start_url=args.url,
+        max_depth=args.depth,
+        delay=args.delay,
+        use_js=not args.no_js,
+    )
+    pages = crawler.run()
+
+    if not pages:
+        print("No pages found. Check the URL and try again.", file=sys.stderr)
+        sys.exit(1)
+
+    sections = group_pages(pages)
+
+    output = generate_llms_txt(sections, args.full)
+    with open(args.output, "w", encoding="utf-8") as f:
+        f.write(output)
+    print(f"Wrote {args.output} with {len(pages)} pages across {len(sections)} sections.")
+
+    if args.full:
+        full_path = args.output.replace("llms.txt", "llms-full.txt")
+        if full_path == args.output:
+            full_path = "llms-full.txt"
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(output)
+        print(f"Wrote {full_path}.")
+
+
+if __name__ == "__main__":
+    main()

llms_generator/crawler.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import time
+import urllib.robotparser
+from collections import deque
+from typing import Optional
+from urllib.parse import urljoin, urlparse
+
+import requests
+from bs4 import BeautifulSoup, Tag
+
+from llms_generator.page_analyzer import (
+    PageInfo,
+    RobotsDirectives,
+    extract_page_info,
+    parse_meta_robots,
+    parse_robots_header,
+)
+
+USER_AGENT = "llms-generator/0.1.0"
+
+
+class Crawler:
+    def __init__(
+        self,
+        start_url: str,
+        max_depth: int = 2,
+        delay: float = 1.0,
+        use_js: bool = True,
+    ):
+        self.start_url = start_url.rstrip("/")
+        self.max_depth = max_depth
+        self.delay = delay
+        self.use_js = use_js
+        self._session = requests.Session()
+        self._session.headers.update({"User-Agent": USER_AGENT})
+
+        parsed = urlparse(self.start_url)
+        self._base = f"{parsed.scheme}://{parsed.netloc}"
+
+        self._rp: Optional[urllib.robotparser.RobotFileParser] = None
+        self._visited: set[str] = set()
+        self._pages: list[PageInfo] = []
+
+    def run(self) -> list[PageInfo]:
+        self._load_robots_txt()
+        queue: deque[tuple[str, int]] = deque()
+        queue.append((self.start_url, 0))
+        self._visited.add(self.start_url)
+
+        while queue:
+            url, depth = queue.popleft()
+            if depth > self.max_depth:
+                continue
+
+            if not self._is_allowed(url):
+                continue
+
+            page = self._fetch_and_analyze(url, depth)
+            if page is None:
+                continue
+
+            self._pages.append(page)
+
+            if depth < self.max_depth:
+                links = self._extract_links(url, page.raw_html)
+                for link in links:
+                    if link not in self._visited:
+                        self._visited.add(link)
+                        queue.append((link, depth + 1))
+
+            time.sleep(self.delay)
+
+        return self._pages
+
+    # ------------------------------------------------------------------
+    #  Robots.txt
+    # ------------------------------------------------------------------
+    def _load_robots_txt(self) -> None:
+        rp = urllib.robotparser.RobotFileParser()
+        rp.set_url(urljoin(self._base, "/robots.txt"))
+        try:
+            rp.read()
+        except Exception:
+            rp = None
+        self._rp = rp
+
+    def _is_allowed(self, url: str) -> bool:
+        if self._rp is None:
+            return True
+        try:
+            return self._rp.can_fetch(USER_AGENT, url)
+        except Exception:
+            return True
+
+    # ------------------------------------------------------------------
+    #  Fetch + analyze
+    # ------------------------------------------------------------------
+    def _fetch_and_analyze(self, url: str, depth: int) -> PageInfo | None:
+        html = self._fetch(url)
+        if html is None:
+            return None
+
+        page = extract_page_info(url, html, depth)
+
+        directives = self._check_robots_directives(html)
+        if directives.noindex:
+            return None
+
+        return page
+
+    def _fetch(self, url: str) -> str | None:
+        try:
+            resp = self._session.get(url, timeout=30)
+            resp.raise_for_status()
+        except requests.RequestException:
+            return self._fetch_with_playwright(url)
+
+        ct = (resp.headers.get("Content-Type") or "").lower()
+        if "text/html" not in ct:
+            return None
+
+        # Check X-Robots-Tag header
+        x_robots = resp.headers.get("X-Robots-Tag")
+        if x_robots:
+            directives = parse_robots_header(x_robots)
+            if directives.noindex:
+                return None
+
+        return resp.text
+
+    def _fetch_with_playwright(self, url: str) -> str | None:
+        if not self.use_js:
+            return None
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError:
+            return None
+
+        try:
+            with sync_playwright() as p:
+                browser = p.chromium.launch(headless=True)
+                page = browser.new_page(user_agent=USER_AGENT)
+                try:
+                    page.goto(url, timeout=30000, wait_until="domcontentloaded")
+                    content = page.content()
+                except Exception:
+                    return None
+                finally:
+                    browser.close()
+                return content
+        except Exception:
+            return None
+
+    # ------------------------------------------------------------------
+    #  Link extraction
+    # ------------------------------------------------------------------
+    def _extract_links(self, base_url: str, html: str) -> list[str]:
+        soup = BeautifulSoup(html, "html.parser")
+        links: list[str] = []
+
+        directives = self._check_robots_directives(html)
+        if directives.nofollow:
+            return links
+
+        for a_tag in soup.find_all("a", href=True):
+            if not isinstance(a_tag, Tag):
+                continue
+            href = a_tag["href"]
+            if isinstance(href, (list, tuple)):
+                href = href[0] if href else ""
+            href = str(href)
+
+            # Resolve relative URLs
+            full = urljoin(base_url, href)
+            parsed = urlparse(full)
+
+            # Same domain only, skip fragments, skip non-HTTP(S)
+            if parsed.netloc != urlparse(self._base).netloc:
+                continue
+            if parsed.scheme not in ("http", "https"):
+                continue
+            if parsed.fragment:
+                full = full.rstrip("#" + parsed.fragment)
+
+            links.append(full)
+
+        return list(dict.fromkeys(links))  # deduplicate, preserve order
+
+    # ------------------------------------------------------------------
+    #  Robots directives from HTML
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _check_robots_directives(html: str) -> RobotsDirectives:
+        soup = BeautifulSoup(html, "html.parser")
+        return parse_meta_robots(soup)

llms_generator/generator.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from llms_generator.page_analyzer import PageInfo
+
+
+def generate_llms_txt(
+    sections: dict[str, list[PageInfo]],
+    full: bool = False,
+) -> str:
+    lines: list[str] = []
+
+    # H1 — site name from the start URL's netloc
+    site_name = _pick_site_name(sections)
+    lines.append(f"# {site_name}")
+    lines.append("")
+
+    # Blockquote summary — first non-empty description
+    summary = _pick_summary(sections)
+    if summary:
+        lines.append(f"> {summary}")
+        lines.append("")
+
+    # Optional context paragraph
+    lines.append(
+        "This file provides AI systems with a structured summary of this website. "
+        "It is maintained automatically by llms-generator."
+    )
+    lines.append("")
+
+    # Sections
+    for section_name in _order_sections(sections):
+        pages = sections[section_name]
+        if not pages:
+            continue
+
+        lines.append(f"## {section_name}")
+        lines.append("")
+
+        for page in pages:
+            desc = page.summary or page.h1 or page.title
+            lines.append(f"- [{page.title or page.h1 or page.url}]({page.url}): {desc}")
+
+            if full and page.full_text:
+                lines.append("")
+                lines.append(page.full_text)
+                lines.append("")
+
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def _pick_site_name(sections: dict[str, list[PageInfo]]) -> str:
+    for pages in sections.values():
+        for p in pages:
+            if p.title:
+                return p.title.split("—")[0].split("|")[0].strip()
+            if p.h1:
+                return p.h1
+    # Fallback: domain name
+    for pages in sections.values():
+        for p in pages:
+            netloc = urlparse(p.url).netloc
+            return netloc.replace("www.", "").split(".")[0].title()
+    return "Untitled Site"
+
+
+def _pick_summary(sections: dict[str, list[PageInfo]]) -> str:
+    for name in ("Home", "About", "Docs"):
+        pages = sections.get(name)
+        if pages:
+            for p in pages:
+                if p.description:
+                    return p.description
+                if p.summary:
+                    return p.summary
+    # Fallback: any non-empty summary
+    for pages in sections.values():
+        for p in pages:
+            if p.description:
+                return p.description
+    return ""
+
+
+SECTION_PRIORITY = [
+    "Home", "About", "Docs", "Documentation",
+    "Guide", "Guides", "Tutorial", "Tutorials",
+    "Api", "Api Reference",
+    "Blog", "News",
+    "Features", "Pricing",
+    "Support", "Faq",
+    "Contact",
+]
+
+
+def _order_sections(sections: dict[str, list[PageInfo]]) -> list[str]:
+    custom: list[str] = []
+    remaining: list[str] = []
+
+    for name in sections:
+        if name in SECTION_PRIORITY:
+            custom.append(name)
+        else:
+            remaining.append(name)
+
+    custom.sort(key=lambda n: SECTION_PRIORITY.index(n))
+    remaining.sort()
+
+    return custom + remaining

llms_generator/page_analyzer.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from urllib.parse import urlparse
+
+from bs4 import BeautifulSoup, Tag
+
+
+@dataclass
+class PageInfo:
+    url: str
+    title: str = ""
+    h1: str = ""
+    description: str = ""
+    summary: str = ""
+    section: str = ""
+    depth: int = 0
+    full_text: str = ""
+    raw_html: str = ""
+
+
+@dataclass
+class RobotsDirectives:
+    noindex: bool = False
+    nofollow: bool = False
+
+
+_X_ROBOTS_TAG_RE = re.compile(
+    r"(?:noindex|nofollow|index|follow|none|all|noarchive)",
+    re.IGNORECASE,
+)
+
+
+def parse_robots_header(header_value: str) -> RobotsDirectives:
+    d = RobotsDirectives()
+    val = header_value.lower()
+    if "none" in val:
+        d.noindex = True
+        d.nofollow = True
+    if "noindex" in val:
+        d.noindex = True
+    if "nofollow" in val:
+        d.nofollow = True
+    return d
+
+
+def parse_meta_robots(soup: BeautifulSoup) -> RobotsDirectives:
+    d = RobotsDirectives()
+    meta = soup.find("meta", attrs={"name": re.compile(r"^robots$", re.I)})
+    if not meta or not isinstance(meta, Tag):
+        return d
+    content = (meta.get("content") or "").lower()
+    if "none" in content:
+        d.noindex = True
+        d.nofollow = True
+    if "noindex" in content:
+        d.noindex = True
+    if "nofollow" in content:
+        d.nofollow = True
+    return d
+
+
+def extract_page_info(url: str, html: str, depth: int) -> PageInfo:
+    soup = BeautifulSoup(html, "html.parser")
+    info = PageInfo(url=url, depth=depth, raw_html=html)
+
+    title_tag = soup.find("title")
+    if title_tag and isinstance(title_tag, Tag):
+        info.title = title_tag.get_text(strip=True)
+
+    h1_tag = soup.find("h1")
+    if h1_tag:
+        info.h1 = h1_tag.get_text(strip=True)
+
+    meta_desc = soup.find("meta", attrs={"name": re.compile(r"^description$", re.I)})
+    if meta_desc and isinstance(meta_desc, Tag):
+        info.description = (meta_desc.get("content") or "").strip()
+
+    info.summary = info.description or info.h1 or info.title
+
+    p_tag = soup.find("p")
+    if p_tag:
+        text = p_tag.get_text(strip=True)
+        if len(text) > 20:
+            info.full_text = text
+        else:
+            info.full_text = _find_first_meaningful_text(soup)
+
+    info.section = _infer_section(url, info.h1)
+    return info
+
+
+def _find_first_meaningful_text(soup: BeautifulSoup) -> str:
+    for tag in soup.find_all(["p", "li", "div", "section"]):
+        text = tag.get_text(strip=True)
+        if len(text) > 50:
+            return text[:500]
+    return ""
+
+
+def _infer_section(url: str, h1: str) -> str:
+    path = urlparse(url).path.strip("/")
+    if not path:
+        return "Home"
+    parts = path.split("/")
+    top = parts[0].replace("-", " ").replace("_", " ").title()
+    if top:
+        return top
+    return h1 or "Other"

llms_generator/section_grouper.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from urllib.parse import urlparse
+
+from llms_generator.page_analyzer import PageInfo
+
+
+def group_pages(pages: list[PageInfo]) -> dict[str, list[PageInfo]]:
+    sections: dict[str, list[PageInfo]] = defaultdict(list)
+
+    for page in pages:
+        section = _assign_section(page)
+        sections[section].append(page)
+
+    return dict(sections)
+
+
+def _assign_section(page: PageInfo) -> str:
+    if page.section and page.section != "Other":
+        return _normalise(page.section)
+
+    path = urlparse(page.url).path.strip("/")
+    if not path:
+        return "Home"
+
+    parts = [p for p in path.split("/") if p]
+    top = _normalise(parts[0])
+
+    if page.h1:
+        h1_section = _normalise(page.h1)
+        return h1_section
+
+    return top or "Other"
+
+
+def _normalise(name: str) -> str:
+    return name.replace("-", " ").replace("_", " ").strip().title()

llms_generator-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: llms-generator
+Version: 0.1.0
+Summary: Crawl any website and generate llms.txt — the AI-ready site map standard.
+Author: aouwalitshikkha
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/aouwalitshikkha/llms-generator
+Project-URL: Repository, https://github.com/aouwalitshikkha/llms-generator
+Keywords: llms.txt,crawler,seo,ai,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: beautifulsoup4>=4.12
+Provides-Extra: js
+Requires-Dist: playwright>=1.40; extra == "js"
+Provides-Extra: all
+Requires-Dist: llms-generator[js]; extra == "all"
+Dynamic: license-file
+
+# llms-generator
+
+[![PyPI](https://img.shields.io/pypi/v/llms-generator)](https://pypi.org/project/llms-generator/)
+[![Python](https://img.shields.io/pypi/pyversions/llms-generator)](https://pypi.org/project/llms-generator/)
+[![License](https://img.shields.io/github/license/aouwalitshikkha/llms-generator)](LICENSE)
+
+**Crawl any website and generate `llms.txt`** — the AI-ready site map standard.
+
+`llms.txt` is a markdown file placed at a website's root (`/llms.txt`) that helps AI assistants like ChatGPT, Claude, and Perplexity understand your site's content structure. Think of it as *robots.txt for AI*.
+
+This tool crawls your site, extracts page metadata, groups pages into logical sections, and outputs a spec-compliant `llms.txt` file.
+
+---
+
+## Why llms.txt?
+
+AI systems struggle to navigate large, noisy websites. An `llms.txt` file gives them a curated map of your most important content — leading to:
+
+-   Accurate citations in AI-generated responses
+-   Better brand representation in ChatGPT, Perplexity, Google AI Overviews
+-   Less server load from AI crawlers wandering your site
+-   Control over how AI systems reference your content
+
+The [llms.txt specification](https://llmstxt.org) was proposed by Jeremy Howard in 2024 and is actively supported by Perplexity, Anthropic, and other AI platforms.
+
+---
+
+## Installation
+
+```bash
+pip install llms-generator
+```
+
+For JavaScript-heavy sites (optional):
+
+```bash
+pip install llms-generator[js]
+playwright install chromium
+```
+
+---
+
+## Usage
+
+```bash
+llms-gen https://example.com
+```
+
+That's it. The tool crawls your site and creates `llms.txt` in the current directory.
+
+### Options
+
+| Flag | Default | Description |
+|---|---|---|
+| `URL` | required | Target website URL |
+| `--depth` | `2` | Maximum crawl depth |
+| `--output` | `llms.txt` | Output file path |
+| `--full` | `False` | Also generate `llms-full.txt` with full page content |
+| `--no-js` | `False` | Skip Playwright JavaScript rendering fallback |
+| `--delay` | `1.0` | Seconds between requests (be polite) |
+
+### Examples
+
+```bash
+# Basic crawl (2 levels deep)
+llms-gen https://example.com
+
+# Crawl deeper, output to custom path
+llms-gen https://docs.example.com --depth 3 --output site-llms.txt
+
+# Generate both standard and full versions
+llms-gen https://example.com --full
+
+# Fast crawl without JS rendering
+llms-gen https://example.com --no-js --delay 0.5
+```
+
+---
+
+## How it works
+
+### Per-page robot check
+
+Every page is checked against three layers before being included or followed:
+
+```
+robots.txt ──┬── disallowed? → skip
+             └── allowed? ──→ check HTTP X-Robots-Tag header
+                                     │
+                           noindex? ──→ skip
+                           nofollow? ──→ still analyze, don't follow links
+                                     │
+                           absent ──→ check <meta name="robots">
+                                     │
+                           noindex? ──→ skip
+                           nofollow? ──→ still analyze, don't follow links
+                                     │
+                           absent/index,follow ──→ analyze + follow links
+```
+
+Pages with `noindex` are **excluded from `llms.txt`**. Pages with `nofollow` are still analyzed for their content but their child links are not crawled.
+
+### Crawl strategy
+
+1. Parse `robots.txt` — respect `Disallow` and `Crawl-Delay`
+2. BFS from the start URL up to `--depth` levels
+3. For each page:
+    - Fetch with `requests` (handles most sites)
+    - If content is empty (JS-rendered), fall back to Playwright headless browser
+    - Extract: `<title>`, `<h1>`, `<meta name="description">`, first meaningful paragraph, directory path
+4. Group pages into sections (directory-based, with H1 fallback)
+5. Assemble `llms.txt` per the spec
+
+### Section grouping
+
+Pages are grouped into `##` sections by their top-level directory path:
+
+```
+/docs/getting-started   → ## Docs
+/blog/hello-world       → ## Blog
+/api/v1/users           → ## Api
+```
+
+Pages without a clear directory path use their `<h1>` as the section name.
+
+---
+
+## Output format
+
+The generated `llms.txt` follows the [llmstxt.org](https://llmstxt.org) specification:
+
+```markdown
+# Example Site
+
+> A great example site with documentation and blog content.
+
+This file provides AI systems with a structured summary of this website.
+
+## Docs
+
+- [Getting Started](https://example.com/docs/getting-started): How to get started with our platform.
+- [API Reference](https://example.com/docs/api): Complete API documentation.
+
+## Blog
+
+- [Hello World](https://example.com/blog/hello): Our first blog post.
+```
+
+### llms-full.txt
+
+With `--full`, an expanded version is also generated that includes the full text content of each page inline — useful for providing complete context to LLMs in a single file.
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/aouwalitshikkha/llms-generator.git
+cd llms-generator
+pip install -e .
+pip install -e ".[js]"   # with Playwright support
+```
+
+Run tests:
+
+```bash
+pip install pytest
+pytest
+```
+
+---
+
+## License
+
+MIT

llms_generator-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+llms_generator/__init__.py,sha256=EObI8QaandukD-LUGiPaKXk-UwBT_XG19YKqNUCDbW4,48
+llms_generator/__main__.py,sha256=FIIppT24g8YwqftTHcvnX0A18ylqpUZmcW6aKGOQKI8,75
+llms_generator/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+llms_generator/cli.py,sha256=yu21yldgodFF9UakbvvYcF5nN0Zj4YRKRaI8yL2Jrr0,2131
+llms_generator/crawler.py,sha256=eaqhuBRnPbwrMb4CVqlh1vHLOJ1vJrw9Z2tjQpRWKTg,6128
+llms_generator/generator.py,sha256=w2VDiZxewUwRCFKcMHaOtqVgfL7x5ZvKUA29awfhhfQ,3015
+llms_generator/page_analyzer.py,sha256=QJVgAcxFtg9grfNZm1Wy9wVrlcIfLT5EdLOFCnAukEs,2835
+llms_generator/section_grouper.py,sha256=UiqtlF62zc6myQn5MbixhQKdsGdgbpgO1cO0wqhy9Mc,932
+llms_generator-0.1.0.dist-info/licenses/LICENSE,sha256=Oczh2qn7dQ5PR6mYsb-QXZ1wsZv5IGFGCerMBHG5PeA,1072
+llms_generator-0.1.0.dist-info/METADATA,sha256=YUbFcWXXF2Qt9QTc55GqCGl9NfaTkBlPolhqDeQybUU,6459
+llms_generator-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+llms_generator-0.1.0.dist-info/entry_points.txt,sha256=Q4klthIOtQMi9Z23c8AbJFg9c-xnibppCtZnmwFH9_4,53
+llms_generator-0.1.0.dist-info/top_level.txt,sha256=w2v6vqKUn9ffmSwzBKLKDl5ygkE39h-6NgMHgQqkrxY,15
+llms_generator-0.1.0.dist-info/RECORD,,

llms_generator-0.1.0.dist-info/WHEEL

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

llms_generator-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+llms-gen = llms_generator.cli:main

llms_generator-0.1.0.dist-info/licenses/LICENSE

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

llms_generator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llms_generator