kabigon 0.10.0__py3-none-any.whl

kabigon/__init__.py

@@ -0,0 +1,22 @@
+import os
+import sys
+from typing import Final
+
+from loguru import logger
+
+from .compose import Compose
+from .firecrawl import FirecrawlLoader
+from .httpx import HttpxLoader
+from .loader import Loader
+from .pdf import PDFLoader
+from .playwright import PlaywrightLoader
+from .ptt import PttLoader
+from .reddit import RedditLoader
+from .reel import ReelLoader
+from .twitter import TwitterLoader
+from .youtube import YoutubeLoader
+from .youtube_ytdlp import YoutubeYtdlpLoader
+from .ytdlp import YtdlpLoader
+
+LOGURU_LEVEL: Final[str] = os.getenv("LOGURU_LEVEL", "INFO")
+logger.add(sys.stderr, level=LOGURU_LEVEL)

kabigon/cli.py

@@ -0,0 +1,29 @@
+import typer
+from rich import print
+
+from .compose import Compose
+from .pdf import PDFLoader
+from .playwright import PlaywrightLoader
+from .ptt import PttLoader
+from .reel import ReelLoader
+from .twitter import TwitterLoader
+from .youtube import YoutubeLoader
+
+
+def run(url: str) -> None:
+    loader = Compose(
+        [
+            PttLoader(),
+            TwitterLoader(),
+            YoutubeLoader(),
+            ReelLoader(),
+            PDFLoader(),
+            PlaywrightLoader(),
+        ]
+    )
+    result = loader.load(url)
+    print(result)
+
+
+def main() -> None:
+    typer.run(run)

kabigon/compose.py

@@ -0,0 +1,42 @@
+from loguru import logger
+
+from .loader import Loader
+
+
+class Compose(Loader):
+    def __init__(self, loaders: list[Loader]) -> None:
+        self.loaders = loaders
+
+    def load(self, url: str) -> str:
+        for loader in self.loaders:
+            try:
+                result = loader.load(url)
+
+                if not result:
+                    logger.info("[{}] Failed to load URL: {}, got empty result", loader.__class__.__name__, url)
+                    continue
+
+                logger.info("[{}] Successfully loaded URL: {}", loader.__class__.__name__, url)
+                return result
+
+            except Exception as e:
+                logger.info("[{}] Failed to load URL: {}, got error: {}", loader.__class__.__name__, url, e)
+
+        raise Exception(f"Failed to load URL: {url}")
+
+    async def async_load(self, url: str) -> str:
+        for loader in self.loaders:
+            try:
+                result = await loader.async_load(url)
+
+                if not result:
+                    logger.info("[{}] Failed to load URL: {}, got empty result", loader.__class__.__name__, url)
+                    continue
+
+                logger.info("[{}] Successfully loaded URL: {}", loader.__class__.__name__, url)
+                return result
+
+            except Exception as e:
+                logger.info("[{}] Failed to load URL: {}, got error: {}", loader.__class__.__name__, url, e)
+
+        raise Exception(f"Failed to load URL: {url}")

kabigon/firecrawl.py

@@ -0,0 +1,31 @@
+import os
+
+from firecrawl import FirecrawlApp
+
+from .loader import Loader
+
+
+class FirecrawlLoader(Loader):
+    def __init__(self, timeout: int | None = None) -> None:
+        self.timeout = timeout
+
+        api_key = os.getenv("FIRECRAWL_API_KEY")
+        if not api_key:
+            raise ValueError("FIRECRAWL_API_KEY is not set.")
+
+        self.app = FirecrawlApp(api_key=api_key)
+
+    def load(self, url: str) -> str:
+        result = self.app.scrape_url(  # ty:ignore[possibly-missing-attribute]
+            url,
+            formats=["markdown"],
+            timeout=self.timeout,
+        )
+
+        if not result.success:
+            raise Exception(f"Failed to load URL: {url}, got: {result.error}")
+
+        return result.markdown
+
+    async def async_load(self, url: str) -> str:
+        return self.load(url)

kabigon/httpx.py

@@ -0,0 +1,20 @@
+import httpx
+
+from .loader import Loader
+from .utils import html_to_markdown
+
+
+class HttpxLoader(Loader):
+    def __init__(self, headers: dict[str, str] | None = None) -> None:
+        self.headers = headers
+
+    def load(self, url: str) -> str:
+        response = httpx.get(url, headers=self.headers, follow_redirects=False)
+        response.raise_for_status()
+        return html_to_markdown(response.content)
+
+    async def async_load(self, url: str) -> str:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, headers=self.headers, follow_redirects=True)
+            response.raise_for_status()
+            return html_to_markdown(response.content)

kabigon/loader.py

@@ -0,0 +1,13 @@
+import asyncio
+import concurrent.futures
+
+
+class Loader:
+    def load(self, url: str) -> str:
+        raise NotImplementedError
+
+    async def async_load(self, url: str):
+        loop = asyncio.get_running_loop()
+        with concurrent.futures.ProcessPoolExecutor() as executor:
+            result = await loop.run_in_executor(executor, self.load, url)
+            return result

kabigon/pdf.py

@@ -0,0 +1,58 @@
+import io
+from pathlib import Path
+from typing import IO
+from typing import Any
+
+import httpx
+from pypdf import PdfReader
+
+from .loader import Loader
+
+DEFAULT_HEADERS = {
+    "Accept-Language": "zh-TW,zh;q=0.9,ja;q=0.8,en-US;q=0.7,en;q=0.6",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",  # noqa
+}
+
+
+class NotPDFError(Exception):
+    def __init__(self, url: str) -> None:
+        super().__init__(f"URL is not a PDF: {url}")
+
+
+class PDFLoader(Loader):
+    def load(self, url_or_file: str) -> str:  # ty:ignore[invalid-method-override]
+        if not url_or_file.startswith("http"):
+            return read_pdf_content(url_or_file)
+
+        resp = httpx.get(url_or_file, headers=DEFAULT_HEADERS, follow_redirects=True)
+        resp.raise_for_status()
+
+        if resp.headers.get("content-type") != "application/pdf":
+            raise NotPDFError(url_or_file)
+
+        return read_pdf_content(io.BytesIO(resp.content))
+
+    async def async_load(self, url_or_file: str) -> str:  # ty:ignore[invalid-method-override]
+        if not url_or_file.startswith("http"):
+            return read_pdf_content(url_or_file)
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(url_or_file, headers=DEFAULT_HEADERS, follow_redirects=True)
+            resp.raise_for_status()
+
+            if resp.headers.get("content-type") != "application/pdf":
+                raise NotPDFError(url_or_file)
+
+            return read_pdf_content(io.BytesIO(resp.content))
+
+
+def read_pdf_content(f: str | Path | IO[Any]) -> str:
+    lines = []
+    with PdfReader(f) as reader:
+        for page in reader.pages:
+            text = page.extract_text(extraction_mode="plain")
+            for line in text.splitlines():
+                stripped = line.strip()
+                if stripped:
+                    lines.append(stripped)
+    return "\n".join(lines)

kabigon/playwright.py

@@ -0,0 +1,68 @@
+from typing import Literal
+
+from loguru import logger
+
+from .loader import Loader
+from .utils import html_to_markdown
+
+
+class PlaywrightLoader(Loader):
+    def __init__(
+        self,
+        timeout: float | None = 0,
+        wait_until: Literal["commit", "domcontentloaded", "load", "networkidle"] | None = None,
+        browser_headless: bool = False,
+    ) -> None:
+        self.timeout = timeout
+        self.wait_until = wait_until
+        self.browser_headless = browser_headless
+
+    def load(self, url: str) -> str:
+        try:
+            from playwright.sync_api import TimeoutError
+            from playwright.sync_api import sync_playwright
+        except ImportError as e:
+            raise ImportError(
+                "Playwright is not installed."
+                "Please install it with `pip install playwright` and run `playwright install`."
+            ) from e
+
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=self.browser_headless)
+            context = browser.new_context()
+            page = context.new_page()
+
+            try:
+                page.goto(url, timeout=self.timeout, wait_until=self.wait_until)
+            except TimeoutError as e:
+                logger.warning("TimeoutError: {}, (url: {}, timeout: {})", e, url, self.timeout)
+
+            content = page.content()
+            browser.close()
+
+            return html_to_markdown(content)
+
+    async def async_load(self, url: str) -> str:
+        try:
+            from playwright.async_api import TimeoutError
+            from playwright.async_api import async_playwright
+        except ImportError as e:
+            raise ImportError(
+                "Playwright is not installed."
+                "Please install it with `pip install playwright` and run `playwright install`."
+            ) from e
+
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=self.browser_headless)
+            context = await browser.new_context()
+            page = await context.new_page()
+
+            try:
+                await page.goto(url, timeout=self.timeout, wait_until=self.wait_until)
+            except TimeoutError as e:
+                logger.warning("TimeoutError: {}, (url: {}, timeout: {})", e, url, self.timeout)
+
+            content = await page.content()
+            await browser.close()
+
+            return html_to_markdown(content)

kabigon/ptt.py

@@ -0,0 +1,30 @@
+from urllib.parse import urlparse
+
+from .httpx import HttpxLoader
+from .loader import Loader
+
+
+def check_ptt_url(url: str) -> None:
+    if urlparse(url).netloc != "www.ptt.cc":
+        raise ValueError(f"URL must be from ptt.cc, got {url}")
+
+
+class PttLoader(Loader):
+    def __init__(self) -> None:
+        self.httpx_loader = HttpxLoader(
+            headers={
+                "Accept-Language": "zh-TW,zh;q=0.9,ja;q=0.8,en-US;q=0.7,en;q=0.6",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",  # noqa
+                "Cookie": "over18=1",
+            }
+        )
+
+    def load(self, url: str) -> str:
+        check_ptt_url(url)
+
+        return self.httpx_loader.load(url)
+
+    async def async_load(self, url: str):
+        check_ptt_url(url)
+
+        return await self.httpx_loader.async_load(url)

kabigon/reddit.py

@@ -0,0 +1,114 @@
+from urllib.parse import urlparse
+from urllib.parse import urlunparse
+
+from .loader import Loader
+
+REDDIT_DOMAINS = [
+    "reddit.com",
+    "www.reddit.com",
+    "old.reddit.com",
+]
+
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+)
+
+
+def check_reddit_url(url: str) -> None:
+    """Check if URL is from Reddit.
+
+    Args:
+        url: The URL to check
+
+    Raises:
+        ValueError: If URL is not from Reddit
+    """
+    netloc = urlparse(url).netloc
+    if netloc not in REDDIT_DOMAINS:
+        raise ValueError(f"URL is not a Reddit URL: {url}")
+
+
+def convert_to_old_reddit(url: str) -> str:
+    """Convert Reddit URL to old.reddit.com format.
+
+    Args:
+        url: Original Reddit URL
+
+    Returns:
+        URL with old.reddit.com domain
+    """
+    parsed = urlparse(url)
+    return str(urlunparse(parsed._replace(netloc="old.reddit.com")))
+
+
+class RedditLoader(Loader):
+    """Loader for Reddit posts and comments.
+
+    Uses old.reddit.com for better content extraction without CAPTCHA.
+    """
+
+    def __init__(self, timeout: float = 30_000) -> None:
+        """Initialize RedditLoader.
+
+        Args:
+            timeout: Timeout in milliseconds for page loading (default: 30 seconds)
+        """
+        self.timeout = timeout
+
+    def load(self, url: str) -> str:
+        """Load Reddit content from URL.
+
+        Args:
+            url: Reddit URL to load
+
+        Returns:
+            Loaded content as markdown
+
+        Raises:
+            ValueError: If URL is not from Reddit
+        """
+        from playwright.sync_api import sync_playwright
+
+        from .utils import html_to_markdown
+
+        check_reddit_url(url)
+        url = convert_to_old_reddit(url)
+
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            context = browser.new_context(user_agent=USER_AGENT)
+            page = context.new_page()
+            page.goto(url, timeout=self.timeout, wait_until="networkidle")
+            content = page.content()
+            browser.close()
+
+            return html_to_markdown(content)
+
+    async def async_load(self, url: str) -> str:
+        """Asynchronously load Reddit content from URL.
+
+        Args:
+            url: Reddit URL to load
+
+        Returns:
+            Loaded content as markdown
+
+        Raises:
+            ValueError: If URL is not from Reddit
+        """
+        from playwright.async_api import async_playwright
+
+        from .utils import html_to_markdown
+
+        check_reddit_url(url)
+        url = convert_to_old_reddit(url)
+
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=True)
+            context = await browser.new_context(user_agent=USER_AGENT)
+            page = await context.new_page()
+            await page.goto(url, timeout=self.timeout, wait_until="networkidle")
+            content = await page.content()
+            await browser.close()
+
+            return html_to_markdown(content)

kabigon/reel.py

@@ -0,0 +1,30 @@
+from .httpx import HttpxLoader
+from .loader import Loader
+from .ytdlp import YtdlpLoader
+
+
+def check_reel_url(url: str) -> None:
+    if not url.startswith("https://www.instagram.com/reel"):
+        raise ValueError(f"URL is not an Instagram Reel: {url}")
+
+
+class ReelLoader(Loader):
+    def __init__(self) -> None:
+        self.httpx_loader = HttpxLoader()
+        self.ytdlp_loader = YtdlpLoader()
+
+    def load(self, url: str) -> str:
+        check_reel_url(url)
+
+        audio_content = self.ytdlp_loader.load(url)
+        html_content = self.httpx_loader.load(url)
+
+        return f"{audio_content}\n\n{html_content}"
+
+    async def async_load(self, url: str):
+        check_reel_url(url)
+
+        audio_content = await self.ytdlp_loader.async_load(url)
+        html_content = await self.httpx_loader.async_load(url)
+
+        return f"{audio_content}\n\n{html_content}"

kabigon/twitter.py

@@ -0,0 +1,44 @@
+from urllib.parse import urlparse
+from urllib.parse import urlunparse
+
+from .loader import Loader
+from .playwright import PlaywrightLoader
+
+TWITTER_DOMAINS = [
+    "twitter.com",
+    "x.com",
+    "fxtwitter.com",
+    "vxtwitter.com",
+    "fixvx.com",
+    "twittpr.com",
+    "api.fxtwitter.com",
+    "fixupx.com",
+]
+
+
+def replace_domain(url: str, new_domain: str = "x.com") -> str:
+    return str(urlunparse(urlparse(url)._replace(netloc=new_domain)))
+
+
+def check_x_url(url: str) -> None:
+    if urlparse(url).netloc not in TWITTER_DOMAINS:
+        raise ValueError(f"URL is not a Twitter URL: {url}")
+
+
+class TwitterLoader(Loader):
+    def __init__(self, timeout: float = 30_000) -> None:
+        self.playwright_loader = PlaywrightLoader(wait_until="networkidle", timeout=timeout)
+
+    def load(self, url: str) -> str:
+        check_x_url(url)
+
+        url = replace_domain(url)
+
+        return self.playwright_loader.load(url)
+
+    async def async_load(self, url: str):
+        check_x_url(url)
+
+        url = replace_domain(url)
+
+        return await self.playwright_loader.async_load(url)

kabigon/utils.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import charset_normalizer
+from markdownify import markdownify
+
+
+def normalize_whitespace(text: str) -> str:
+    lines = []
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped:
+            lines += [stripped]
+    return "\n".join(lines)
+
+
+def html_to_markdown(content: str | bytes) -> str:
+    """Convert HTML content to markdown format.
+
+    Args:
+        content: HTML content as string or bytes
+
+    Returns:
+        Converted markdown text with normalized whitespace
+    """
+    if isinstance(content, bytes):
+        content = str(charset_normalizer.from_bytes(content).best())
+
+    md = markdownify(content, strip=["a", "img"])
+    return normalize_whitespace(md)
+
+
+def read_html_content(f: str | Path) -> str:
+    content = str(charset_normalizer.from_path(f).best())
+
+    md = markdownify(content, strip=["a", "img"])
+    return normalize_whitespace(md)

kabigon/youtube.py

@@ -0,0 +1,33 @@
+import aioytt
+import aioytt.video_id
+from youtube_transcript_api import YouTubeTranscriptApi
+
+from .loader import Loader
+
+DEFAULT_LANGUAGES = ["zh-TW", "zh-Hant", "zh", "zh-Hans", "ja", "en", "ko"]
+
+
+class YoutubeLoader(Loader):
+    def __init__(self, languages: list[str] | None = None) -> None:
+        self.languages = languages or DEFAULT_LANGUAGES
+
+    def load(self, url: str) -> str:
+        video_id = aioytt.video_id.parse_video_id(url)
+
+        fetched = YouTubeTranscriptApi().fetch(video_id, self.languages)
+
+        lines = []
+        for snippet in fetched.snippets:
+            text = str(snippet.text).strip()
+            if text:
+                lines.append(text)
+        return "\n".join(lines)
+
+    # async def async_load(self, url: str) -> str:
+    #     transcript = await aioytt.get_transcript_from_url(url)
+    #     lines = []
+    #     for piece in transcript:
+    #         text = piece.text.strip()
+    #         if text:
+    #             lines.append(text)
+    #     return "\n".join(lines)

kabigon/youtube_ytdlp.py

@@ -0,0 +1,26 @@
+from urllib.parse import urlparse
+
+from aioytt.video_id import ALLOWED_NETLOCS
+from aioytt.video_id import ALLOWED_SCHEMES
+
+from .loader import Loader
+from .ytdlp import YtdlpLoader
+
+
+def check_youtube_url(url: str) -> None:
+    schema = urlparse(url).scheme
+    if schema not in ALLOWED_SCHEMES:
+        raise ValueError(f"URL scheme is not allowed: {schema}")
+
+    domain = urlparse(url).netloc
+    if domain not in ALLOWED_NETLOCS:
+        raise ValueError(f"URL domain is not allowed: {domain}")
+
+
+class YoutubeYtdlpLoader(Loader):
+    def __init__(self) -> None:
+        self.ytdlp_loader = YtdlpLoader()
+
+    def load(self, url: str) -> str:
+        check_youtube_url(url)
+        return self.ytdlp_loader.load(url)

kabigon/ytdlp.py

@@ -0,0 +1,61 @@
+import os
+import uuid
+from pathlib import Path
+
+import yt_dlp
+from loguru import logger
+
+from .loader import Loader
+
+
+def download_audio(url: str, outtmpl: str | None = None) -> None:
+    ydl_opts = {
+        "format": "bestaudio/best",
+        "postprocessors": [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }
+        ],
+        "match_filter": yt_dlp.match_filter_func(["!is_live"]),
+    }
+
+    if outtmpl is not None:
+        ydl_opts["outtmpl"] = outtmpl
+
+    ffmpeg_path = os.getenv("FFMPEG_PATH")
+    if ffmpeg_path is not None:
+        ydl_opts["ffmpeg_location"] = ffmpeg_path
+
+    logger.info("Downloading audio from URL: {} with options: {}", url, ydl_opts)
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+
+
+class YtdlpLoader(Loader):
+    def __init__(self, model: str = "tiny") -> None:
+        try:
+            import whisper
+        except ImportError as e:
+            raise ImportError(
+                "OpenAI Whisper not installed. Please install it with `pip install openai-whisper`."
+            ) from e
+
+        self.model = whisper.load_model(model)
+        self.load_audio = whisper.load_audio
+
+    def load(self, url: str) -> str:
+        outtmpl = uuid.uuid4().hex[:20]
+        path = str(Path(outtmpl).with_suffix(".mp3"))
+        download_audio(url, outtmpl=outtmpl)
+
+        try:
+            audio = self.load_audio(path)
+            logger.info("Transcribing audio file: {}", path)
+            result = self.model.transcribe(audio)
+        finally:
+            # Clean up the audio file
+            os.remove(path)
+
+        return result.get("text", "")

kabigon-0.10.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: kabigon
+Version: 0.10.0
+Author-email: narumi <toucans-cutouts0f@icloud.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: aioytt>=0.2.4
+Requires-Dist: firecrawl-py>=2.4.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: markdownify>=0.14.1
+Requires-Dist: openai-whisper>=20250625
+Requires-Dist: playwright>=1.52.0
+Requires-Dist: pypdf>=5.3.0
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.3
+Requires-Dist: youtube-transcript-api>=1.2.2
+Requires-Dist: yt-dlp>=2025.4.30
+Description-Content-Type: text/markdown
+
+# kabigon
+
+## Installation
+
+```shell
+pip install kabigon
+playwright install chromium
+```
+
+## Usage
+
+```shell
+kabigon <url>
+```
+
+or
+
+```python
+import kabigon
+
+url = "https://www.google.com.tw"
+
+content = kabigon.Compose(
+    [
+        kabigon.YoutubeLoader(),
+        kabigon.ReelLoader(),
+        kabigon.YtdlpLoader(),
+        kabigon.PDFLoader(),
+        # kabigon.HttpxLoader(),
+        kabigon.PlaywrightLoader(),
+    ]
+).load(url)
+print(content)
+```

kabigon-0.10.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+kabigon/__init__.py,sha256=FXimW6HEBYs0Q_2IGgNmnZcHCmP0sECnDxmoUMguZRg,609
+kabigon/cli.py,sha256=nzztow9R1k4w5J9CADmtVhmGf-LdWWwEZdTpU7H6J4g,592
+kabigon/compose.py,sha256=rSiP0ed0vb9dJ08erZGyiunOcd0ALHAfBRGlxYg1Tvs,1457
+kabigon/firecrawl.py,sha256=Yd9isfGFo8vzp6k2KJ2V0jhazaZ_7ekssdMMj2Wpeng,819
+kabigon/httpx.py,sha256=Zup9DURyWLqoWzaxBbCYAaV-5LSlHUuAcNyyUsZTVag,696
+kabigon/loader.py,sha256=W2ZdSINQKjG-5XNYweM8lIl19JA4wwd7AE2pueHeO70,380
+kabigon/pdf.py,sha256=a6UV4SRuWQzBbpwh0hgDe9OemK5mZ9_dYRXRDHwpg50,1946
+kabigon/playwright.py,sha256=gECaDJhsIrY53lwG7OrH8gUHvIsVe7p5jgBTUy7KPJg,2413
+kabigon/ptt.py,sha256=Gyp2nJrjptkjbwZJ9VEQHX0DEgKBe5QRQOmGVHUUgNA,896
+kabigon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kabigon/reddit.py,sha256=bb8c7I_INO4R2WsLSPyP1b31CcMN7Mpj334FCWLXrBA,3039
+kabigon/reel.py,sha256=qOwWCvcp7xNKg0JDunq_Bsl8yqqMzrnAOI9k5mSqrOU,874
+kabigon/twitter.py,sha256=p-8MEaHOSZwKOgHRc03uJ_5sh8FuG0jcGf7eUTYJ1B8,1093
+kabigon/utils.py,sha256=eNTLtHLSB2erDac2HH3jWemgfr8Ou_ozwVb8h9BD-4g,922
+kabigon/youtube.py,sha256=Vh4cBidScUruTgvm4BbTxqaEDxnotMI3uM3FuFlx5J0,1021
+kabigon/youtube_ytdlp.py,sha256=Y6h55wYF-5PdxLRxsznFtJDypCedD8g-hY9fgCnfvbg,722
+kabigon/ytdlp.py,sha256=4AjPY0W8IxbEhCNVXpi_KbBQLGrWn5ThrchhffcJIIU,1718
+kabigon-0.10.0.dist-info/METADATA,sha256=B2rf3UC9cXdInFkDH2Cel4PkHjy1f5s_BtWS3VE_pjw,1040
+kabigon-0.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kabigon-0.10.0.dist-info/entry_points.txt,sha256=O3FYAO9w-NQvlGMJrBvtrnGHSK2QkUnQBTa30YXRbVE,45
+kabigon-0.10.0.dist-info/licenses/LICENSE,sha256=H2T3_RTgmcngMeC7p_SXT3GwBLkd2DaNgAZuxulcfiA,1066
+kabigon-0.10.0.dist-info/RECORD,,

kabigon-0.10.0.dist-info/WHEEL

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

kabigon-0.10.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kabigon = kabigon.cli:main

kabigon-0.10.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 なるみ
+
+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.