pg2md 1.0.0__py3-none-any.whl

pg2md/__init__.py

@@ -0,0 +1,38 @@
+"""
+pg2md — Page to Markdown converter with JS rendering support.
+
+A fast, clean HTML-to-Markdown converter that uses Playwright for
+JavaScript rendering and html-to-markdown (Rust-based) for conversion.
+
+Example:
+    from pg2md import PageParser, BrowserConfig, ProxyConfig, UserAgents
+
+    parser = PageParser(with_image=False, with_link=True)
+    markdown = parser.parse("https://example.com")
+    print(markdown)
+
+    # With proxy
+    proxy = ProxyConfig(server="socks5://1.2.3.4:1080")
+    markdown = parser.parse("https://example.com", proxy=proxy)
+"""
+
+from pg2md.parser import (
+    PageParser,
+    BrowserConfig,
+    ProxyConfig,
+    UserAgents,
+    HtmlCleaner,
+    MarkdownCleaner,
+)
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__all__ = [
+    "PageParser",
+    "BrowserConfig",
+    "ProxyConfig",
+    "UserAgents",
+    "HtmlCleaner",
+    "MarkdownCleaner",
+    "__version__",
+]

pg2md/parser.py

@@ -0,0 +1,417 @@
+"""
+PageParser — Parser for web pages with JS rendering via Lightpanda/Playwright
+and conversion to clean Markdown.
+
+Dependencies:
+    pip install playwright html-to-markdown beautifulsoup4
+    playwright install chromium  # if using regular Chrome, not Lightpanda
+
+Running Lightpanda (optional, instead of Chrome):
+    ./lightpanda serve --host 127.0.0.1 --port 9222
+
+Usage:
+    parser = PageParser(with_image=False, with_link=False)
+
+    # Without proxy
+    result = parser.parse("https://example.com")
+
+    # With proxy for a specific request
+    proxy = ProxyConfig(server="http://1.2.3.4:8080", username="user", password="pass")
+    result = parser.parse("https://example.com", proxy=proxy)
+
+    print(result)
+"""
+
+import re
+import subprocess
+import time
+import asyncio
+from dataclasses import dataclass
+from typing import Optional, Literal
+
+from bs4 import BeautifulSoup
+from html_to_markdown import convert, ConversionOptions, PreprocessingOptions
+from playwright.async_api import async_playwright, ProxySettings
+
+
+@dataclass
+class ProxyConfig:
+    """
+    Proxy settings for a single request.
+
+    Supported server formats:
+        http://host:port
+        https://host:port
+        socks5://host:port
+
+    Args:
+        server   : proxy address (required)
+        username : login (optional)
+        password : password (optional)
+        bypass   : comma-separated list of hosts to bypass proxy
+                   (e.g. "localhost,127.0.0.1")
+    """
+
+    server: str
+    username: Optional[str] = None
+    password: Optional[str] = None
+    bypass: Optional[str] = None
+
+    def to_playwright(self) -> ProxySettings:
+        """Converts to Playwright ProxySettings format."""
+        settings: ProxySettings = {"server": self.server}
+        if self.username:
+            settings["username"] = self.username
+        if self.password:
+            settings["password"] = self.password
+        if self.bypass:
+            settings["bypass"] = self.bypass
+        return settings
+
+
+class UserAgents:
+    """Popular User-Agent strings for bypassing blocks."""
+
+    CHROME_DESKTOP = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/120.0.0.0 Safari/537.36"
+    )
+
+    CHROME_MAC = (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/120.0.0.0 Safari/537.36"
+    )
+
+    FIREFOX_DESKTOP = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0"
+
+    SAFARI_MAC = (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) "
+        "Version/17.2 Safari/605.1.15"
+    )
+
+    EDGE = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
+    )
+
+    GOOGLEBOT_DESKTOP = (
+        "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
+    )
+
+    GOOGLEBOT_MOBILE = (
+        "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.71 MobileSafari/537.36 "
+        "(compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
+    )
+
+    GOOGLEBOT_VIDEO = (
+        "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.71 MobileSafari/537.36 "
+        "Googlebot/2.1"
+    )
+
+    BINGBOT = "Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)"
+
+    BINGBOT_MOBILE = (
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 "
+        "(KHTML, like Gecko) Version/16.6 Mobile/15E148 BingWeb/7.15.13.7055 (advisor; +http://www.bing.com/bingbot.htm)"
+    )
+
+    YANDEXBOT = "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)"
+
+    DUCKBOT = "DuckDuckBot/1.0; (+http://duckduckgo.com/duckduckbot.html)"
+
+    APPLEBOT = (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) "
+        "Version/17.0 Safari/605.1.15 Applebot/0.1"
+    )
+
+    CHROME_LINUX = (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/120.0.0.0 Safari/537.36"
+    )
+
+
+@dataclass
+class BrowserConfig:
+    """Browser connection settings."""
+
+    cdp_url: Optional[str] = "ws://127.0.0.1:9222"
+    lightpanda_bin: Optional[str] = None
+    navigation_timeout: int = 30_000
+    wait_until: Literal["load", "domcontentloaded", "networkidle"] = "networkidle"
+    default_proxy: Optional[ProxyConfig] = None
+    user_agent: Optional[str] = UserAgents.CHROME_DESKTOP
+    extra_headers: Optional[dict[str, str]] = None
+
+
+class HtmlCleaner:
+    """
+    Cleans HTML before converting to Markdown:
+      - removes <script>, <style>, <noscript>, <svg>, <canvas>, <video>, <audio>
+      - removes <img> (optional)
+      - removes href/src with data:, blob: (base64 junk)
+      - strips links, keeping only text (optional)
+    """
+
+    ALWAYS_STRIP_TAGS = [
+        "script",
+        "style",
+        "noscript",
+        "svg",
+        "canvas",
+        "video",
+        "audio",
+        "iframe",
+        "object",
+        "embed",
+        "head",
+    ]
+
+    def __init__(self, with_image: bool = False, with_link: bool = True):
+        self.with_image = with_image
+        self.with_link = with_link
+
+    def clean(self, html: str) -> str:
+        soup = BeautifulSoup(html, "html.parser")
+
+        for tag in self.ALWAYS_STRIP_TAGS:
+            for el in soup.find_all(tag):
+                el.decompose()
+
+        if not self.with_image:
+            for el in soup.find_all("img"):
+                el.decompose()
+        else:
+            for el in soup.find_all("img"):
+                src = el.get("src", "")
+                if isinstance(src, str) and (
+                    src.startswith("data:") or src.startswith("blob:")
+                ):
+                    el.decompose()
+
+        if not self.with_link:
+            for el in soup.find_all("a"):
+                el.replace_with(el.get_text())
+        else:
+            for el in soup.find_all("a"):
+                href = el.get("href", "")
+                if isinstance(href, str) and (
+                    href.startswith("data:") or href.startswith("blob:")
+                ):
+                    el["href"] = ""
+
+        for el in soup.find_all(True):
+            for attr in ("src", "href", "srcset", "poster", "background"):
+                val = el.get(attr, "")
+                if isinstance(val, str) and (
+                    val.startswith("data:") or val.startswith("blob:")
+                ):
+                    del el[attr]
+
+        return str(soup)
+
+
+class MarkdownCleaner:
+    """Final cleanup of ready Markdown text."""
+
+    _BASE64_LINE = re.compile(r"^[A-Za-z0-9+/=]{40,}\s*$", re.MULTILINE)
+    _BINARY_GARBAGE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]")
+    _EXCESS_NEWLINES = re.compile(r"\n{3,}")
+    _MD_IMAGE = re.compile(r"!\[.*?\]\(.*?\)")
+
+    def clean(self, text: str, strip_images: bool = False) -> str:
+        text = self._BINARY_GARBAGE.sub("", text)
+        text = self._BASE64_LINE.sub("", text)
+
+        if strip_images:
+            text = self._MD_IMAGE.sub("", text)
+
+        text = self._EXCESS_NEWLINES.sub("\n\n", text)
+
+        return text.strip()
+
+
+class PageParser:
+    """
+    Parses web pages with JS rendering and returns clean Markdown.
+
+    Args:
+        with_image     (bool)         : Include images in output. Default False.
+        with_link      (bool)         : Include links (href). Default True.
+                                        False — links are replaced with their text.
+        browser_config (BrowserConfig): Browser connection settings.
+                                        Can set default_proxy for all requests.
+
+    Proxy is passed to parse() / async_parse() per-request:
+        proxy = ProxyConfig(server="socks5://1.2.3.4:1080")
+        result = parser.parse("https://example.com", proxy=proxy)
+    """
+
+    def __init__(
+        self,
+        with_image: bool = False,
+        with_link: bool = True,
+        browser_config: Optional[BrowserConfig] = None,
+    ):
+        self.with_image = with_image
+        self.with_link = with_link
+        self.config = browser_config or BrowserConfig()
+
+        self._html_cleaner = HtmlCleaner(with_image=with_image, with_link=with_link)
+        self._md_cleaner = MarkdownCleaner()
+
+        self._lightpanda_proc: Optional[subprocess.Popen] = None
+
+    def parse(self, url: str, proxy: Optional[ProxyConfig] = None) -> str:
+        """
+        Synchronous wrapper over async_parse.
+
+        Args:
+            url   : page to parse
+            proxy : proxy for this specific request (overrides default_proxy)
+        """
+        return asyncio.run(self.async_parse(url, proxy=proxy))
+
+    async def async_parse(self, url: str, proxy: Optional[ProxyConfig] = None) -> str:
+        """
+        Loads page, renders JS, returns clean Markdown.
+
+        Args:
+            url   : page to parse
+            proxy : proxy for this specific request (overrides default_proxy)
+        """
+        html = await self._fetch_html(url, proxy=proxy)
+        return self._html_to_markdown(html)
+
+    async def async_parse_many(
+        self,
+        urls: list[str],
+        proxy: Optional[ProxyConfig] = None,
+    ) -> dict[str, str | BaseException]:
+        """
+        Parses multiple URLs in parallel.
+
+        Args:
+            urls  : list of pages
+            proxy : one proxy for all requests (or None)
+        """
+        tasks = [self.async_parse(url, proxy=proxy) for url in urls]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        return {url: res for url, res in zip(urls, results)}
+
+    async def _fetch_html(self, url: str, proxy: Optional[ProxyConfig] = None) -> str:
+        """Opens browser, loads page, returns HTML."""
+        self._maybe_start_lightpanda()
+
+        effective_proxy = proxy or self.config.default_proxy
+        proxy_settings = effective_proxy.to_playwright() if effective_proxy else None
+
+        headers = {}
+        if self.config.extra_headers:
+            headers.update(self.config.extra_headers)
+
+        async with async_playwright() as pw:
+            if self.config.cdp_url:
+                browser = await pw.chromium.connect_over_cdp(self.config.cdp_url)
+                context = await browser.new_context(
+                    proxy=proxy_settings,
+                    user_agent=self.config.user_agent,
+                    extra_http_headers=headers if headers else None,
+                )
+            else:
+                browser = await pw.chromium.launch(headless=True)
+                context = await browser.new_context(
+                    proxy=proxy_settings,
+                    user_agent=self.config.user_agent,
+                    extra_http_headers=headers if headers else None,
+                )
+
+            page = await context.new_page()
+
+            try:
+                await page.goto(
+                    url,
+                    timeout=self.config.navigation_timeout,
+                    wait_until=self.config.wait_until,
+                )
+                html = await page.content()
+            finally:
+                await page.close()
+                await context.close()
+                await browser.close()
+
+        return html
+
+    def _html_to_markdown(self, html: str) -> str:
+        """Cleans HTML and converts to Markdown."""
+
+        clean_html = self._html_cleaner.clean(html)
+
+        options = ConversionOptions(
+            heading_style="atx",
+            strong_em_symbol="*",
+            bullets="*",
+            escape_asterisks=False,
+        )
+        preprocessing = PreprocessingOptions(
+            enabled=True,
+            preset="aggressive",
+            remove_navigation=True,
+            remove_forms=True,
+        )
+        markdown = convert(clean_html, options, preprocessing)
+
+        markdown = self._md_cleaner.clean(markdown, strip_images=not self.with_image)
+
+        return markdown
+
+    def _maybe_start_lightpanda(self) -> None:
+        """If binary path is set and process not running — start it."""
+        if not self.config.lightpanda_bin:
+            return
+        if self._lightpanda_proc and self._lightpanda_proc.poll() is None:
+            return
+
+        self._lightpanda_proc = subprocess.Popen(
+            [
+                self.config.lightpanda_bin,
+                "serve",
+                "--host",
+                "127.0.0.1",
+                "--port",
+                "9222",
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        time.sleep(1.5)
+
+    def stop_lightpanda(self) -> None:
+        """Explicitly stops Lightpanda if started by us."""
+        if self._lightpanda_proc:
+            self._lightpanda_proc.terminate()
+            self._lightpanda_proc = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.stop_lightpanda()
+
+
+if __name__ == "__main__":
+    import sys
+
+    url = sys.argv[1] if len(sys.argv) > 1 else "https://example.com"
+
+    parser = PageParser(
+        with_image=False,
+        with_link=False,
+        browser_config=BrowserConfig(cdp_url=None),
+    )
+
+    with parser:
+        result = parser.parse(url)
+
+    print(result)

pg2md-1.0.0.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: pg2md
+Version: 1.0.0
+Summary: Page to Markdown converter with JS rendering support via Playwright
+Project-URL: Homepage, https://github.com/yourusername/pg2md
+Project-URL: Documentation, https://github.com/yourusername/pg2md#readme
+Project-URL: Repository, https://github.com/yourusername/pg2md
+Project-URL: Issues, https://github.com/yourusername/pg2md/issues
+Author-email: Your Name <your@email.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: converter,html,js-rendering,markdown,parser,playwright,scraper,web-scraping
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: html-to-markdown>=2.0.0
+Requires-Dist: playwright>=1.40.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pg2md
+
+[![PyPI version](https://badge.fury.io/py/pg2md.svg)](https://badge.fury.io/py/pg2md)
+[![Python](https://img.shields.io/pypi/pyversions/pg2md.svg)](https://pypi.org/project/pg2md/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://static.pepy.tech/badge/pg2md)](https://pepy.tech/project/pg2md)
+[![GitHub stars](https://img.shields.io/github/stars/yourusername/pg2md.svg?style=social)](https://github.com/yourusername/pg2md/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/yourusername/pg2md.svg)](https://github.com/yourusername/pg2md/issues)
+[![GitHub forks](https://img.shields.io/github/forks/yourusername/pg2md.svg?style=social)](https://github.com/yourusername/pg2md/network/members)
+
+**P**a**g**e to **M**ark**d**own — fast HTML-to-Markdown converter with JavaScript rendering support.
+
+Converts any web page to clean Markdown using Playwright for JS rendering and Rust-based `html-to-markdown` for conversion.
+
+## Features
+
+- **JavaScript Rendering** — handles SPA, React, Vue, dynamic content
+- **Fast Conversion** — Rust-based `html-to-markdown` core
+- **Clean Output** — strips scripts, styles, navigation, forms
+- **Proxy Support** — HTTP/HTTPS/SOCKS5 with auth
+- **Custom User-Agents** — includes Googlebot, Bingbot, etc.
+- **Async & Sync API** — `parse()` and `async_parse()`
+- **Batch Processing** — `async_parse_many()` for parallel requests
+- **Configurable** — images, links, headers, timeouts
+
+## Installation
+
+```bash
+pip install pg2md
+playwright install chromium
+```
+
+## Quick Start
+
+```python
+from pg2md import PageParser
+
+parser = PageParser(with_image=False, with_link=True)
+markdown = parser.parse("https://example.com")
+print(markdown)
+```
+
+## Usage Examples
+
+### Basic Usage
+
+```python
+from pg2md import PageParser
+
+parser = PageParser()
+result = parser.parse("https://example.com")
+print(result)
+```
+
+### Without Images and Links
+
+```python
+from pg2md import PageParser
+
+parser = PageParser(with_image=False, with_link=False)
+result = parser.parse("https://example.com")
+```
+
+### With Proxy
+
+```python
+from pg2md import PageParser, ProxyConfig
+
+proxy = ProxyConfig(
+    server="http://proxy.example.com:8080",
+    username="user",
+    password="pass"
+)
+
+parser = PageParser()
+result = parser.parse("https://example.com", proxy=proxy)
+```
+
+### SOCKS5 Proxy
+
+```python
+from pg2md import PageParser, ProxyConfig
+
+proxy = ProxyConfig(server="socks5://127.0.0.1:1080")
+parser = PageParser()
+result = parser.parse("https://example.com", proxy=proxy)
+```
+
+### Custom User-Agent
+
+```python
+from pg2md import PageParser, BrowserConfig, UserAgents
+
+config = BrowserConfig(
+    cdp_url=None,
+    user_agent=UserAgents.GOOGLEBOT_DESKTOP,
+    extra_headers={"Accept-Language": "en-US,en;q=0.9"}
+)
+
+parser = PageParser(browser_config=config)
+result = parser.parse("https://example.com")
+```
+
+### Async API
+
+```python
+import asyncio
+from pg2md import PageParser
+
+async def main():
+    parser = PageParser()
+    result = await parser.async_parse("https://example.com")
+    print(result)
+
+asyncio.run(main())
+```
+
+### Batch Processing
+
+```python
+import asyncio
+from pg2md import PageParser
+
+async def main():
+    parser = PageParser()
+    urls = [
+        "https://example.com",
+        "https://example.org",
+        "https://example.net",
+    ]
+    results = await parser.async_parse_many(urls)
+    
+    for url, result in results.items():
+        if isinstance(result, Exception):
+            print(f"Error {url}: {result}")
+        else:
+            print(f"{url}: {len(result)} chars")
+
+asyncio.run(main())
+```
+
+### Using Lightpanda
+
+```python
+from pg2md import PageParser, BrowserConfig
+
+# Start Lightpanda manually:
+# ./lightpanda serve --host 127.0.0.1 --port 9222
+
+config = BrowserConfig(cdp_url="ws://127.0.0.1:9222")
+parser = PageParser(browser_config=config)
+result = parser.parse("https://example.com")
+```
+
+## Configuration
+
+### BrowserConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `cdp_url` | `str \| None` | `"ws://127.0.0.1:9222"` | CDP endpoint (Lightpanda/Chrome) |
+| `lightpanda_bin` | `str \| None` | `None` | Path to Lightpanda binary |
+| `navigation_timeout` | `int` | `30000` | Navigation timeout (ms) |
+| `wait_until` | `str` | `"networkidle"` | Wait event |
+| `default_proxy` | `ProxyConfig \| None` | `None` | Default proxy for all requests |
+| `user_agent` | `str \| None` | Chrome Desktop | User-Agent string |
+| `extra_headers` | `dict \| None` | `None` | Additional HTTP headers |
+
+### ProxyConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `server` | `str` | required | Proxy URL |
+| `username` | `str \| None` | `None` | Username |
+| `password` | `str \| None` | `None` | Password |
+| `bypass` | `str \| None` | `None` | Hosts to bypass |
+
+### UserAgents
+
+Available presets:
+
+- `CHROME_DESKTOP`, `CHROME_MAC`, `CHROME_LINUX`
+- `FIREFOX_DESKTOP`
+- `SAFARI_MAC`
+- `EDGE`
+- `GOOGLEBOT_DESKTOP`, `GOOGLEBOT_MOBILE`, `GOOGLEBOT_VIDEO`
+- `BINGBOT`, `BINGBOT_MOBILE`
+- `YANDEXBOT`
+- `DUCKBOT`
+- `APPLEBOT`
+
+## API Reference
+
+### PageParser
+
+```python
+PageParser(
+    with_image: bool = False,
+    with_link: bool = True,
+    browser_config: BrowserConfig | None = None
+)
+```
+
+#### Methods
+
+| Method | Description |
+|--------|-------------|
+| `parse(url, proxy=None)` | Sync parse, returns Markdown string |
+| `async_parse(url, proxy=None)` | Async parse, returns Markdown string |
+| `async_parse_many(urls, proxy=None)` | Batch async parse, returns dict |
+| `stop_lightpanda()` | Stop Lightpanda if started |
+
+## Development
+
+```bash
+git clone https://github.com/yourusername/pg2md.git
+cd pg2md
+python -m venv venv
+source venv/bin/activate
+pip install -e ".[dev]"
+playwright install chromium
+```
+
+## License
+
+[MIT](LICENSE)
+
+## Credits
+
+- [Playwright](https://playwright.dev/python/) — browser automation
+- [html-to-markdown](https://pypi.org/project/html-to-markdown/) — Rust-based HTML to Markdown
+- [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/) — HTML parsing

pg2md-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+pg2md/__init__.py,sha256=gnJA-EpCZh0rqggk_avwsi3IBGHbc0bddJmB8rrAvBw,896
+pg2md/parser.py,sha256=bnepF5302PsV2SXmHgEla2126SihPE2FuBYNDI5Gp8k,13371
+pg2md-1.0.0.dist-info/METADATA,sha256=5tTGIaPbjSr3qu05zp8hiUQFt94F49JbsRSkFUefPJk,7560
+pg2md-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pg2md-1.0.0.dist-info/licenses/LICENSE,sha256=OphKV48tcMv6ep-7j-8T6nycykPT0g8ZlMJ9zbGvdPs,1066
+pg2md-1.0.0.dist-info/RECORD,,

pg2md-1.0.0.dist-info/WHEEL

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

pg2md-1.0.0.dist-info/licenses/LICENSE

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