simplesoup 0.1.0__py3-none-any.whl

simplesoup/__init__.py

@@ -0,0 +1,3 @@
+from .core import SimpleSoup, rz
+
+__all__ = ["SimpleSoup", "rz"]

simplesoup/converter.py

@@ -0,0 +1,32 @@
+import subprocess
+
+
+class Converter:
+
+    @staticmethod
+    def convert(input_file, output_file):
+
+        command = [
+            "ffmpeg",
+            "-y",
+            "-i",
+            input_file,
+            "-vf",
+            "format=nv12",
+            "-c:v",
+            "h264_mediacodec",
+            "-g",
+            "120",
+            "-c:a",
+            "aac",
+            "-movflags",
+            "+faststart",
+            output_file
+        ]
+
+        subprocess.run(
+            command,
+            check=True
+        )
+
+        return output_file

simplesoup/core.py

@@ -0,0 +1,85 @@
+from .parser import parse
+from .downloader import Downloader
+from .gallery import Gallery
+
+
+# ============================================================
+# SimpleSoup Configuration
+# ============================================================
+
+# Put your cookies.txt file path here.
+# Example:
+# COOKIES = "/storage/emulated/0/Download/instagram_cookies.txt"
+#
+# Disable cookies:
+# COOKIES = None
+
+COOKIES = "/storage/emulated/0/Download/reddit_cookies.txt"
+
+
+class SimpleSoup:
+
+    def __init__(self):
+        self.downloader = Downloader()
+        self.gallery = Gallery()
+
+    def __call__(
+        self,
+        expression,
+        url=None,
+        progress_callback=None
+    ):
+        return self.run(
+            expression,
+            url,
+            progress_callback
+        )
+
+    def run(
+        self,
+        expression,
+        url=None,
+        progress_callback=None
+    ):
+
+        config = parse(expression)
+
+        if url is not None:
+            config["url"] = url
+
+        if not config["url"]:
+            raise ValueError("URL missing")
+
+        # ========================================================
+        # Gallery-dl engine
+        # ========================================================
+
+        for block in config["blocks"]:
+
+            if block["type"] == "gallery":
+
+                result = self.gallery.execute(
+                    config["url"],
+                    cookies=COOKIES
+                )
+
+                if block["variable"]:
+
+                    return {
+                        block["variable"]: result
+                    }
+
+                return result
+
+        # ========================================================
+        # Normal yt-dlp engine
+        # ========================================================
+
+        return self.downloader.execute(
+            config,
+            cookies=COOKIES,
+            progress_callback=progress_callback
+        )
+
+
+rz = SimpleSoup()

simplesoup/downloader.py

@@ -0,0 +1,555 @@
+import os
+import urllib.request
+import yt_dlp
+
+from .parser import STAGES
+
+
+class Downloader:
+
+    def __init__(self):
+        self.path = "/storage/emulated/0/Download/ReiDownloader"
+        os.makedirs(self.path, exist_ok=True)
+
+    # ============================================================
+    # Helpers
+    # ============================================================
+
+    def _format_speed(self, speed):
+        if not speed:
+            return "0 KB/s"
+
+        if speed >= 1024 * 1024:
+            return f"{speed / (1024 * 1024):.1f} MB/s"
+
+        return f"{speed / 1024:.0f} KB/s"
+
+    def _progress_hook(
+        self,
+        data,
+        mode="Video",
+        progress_callback=None
+    ):
+
+        status = data.get("status")
+
+        if status == "downloading":
+
+            total = (
+                data.get("total_bytes")
+                or data.get("total_bytes_estimate")
+            )
+
+            downloaded = data.get("downloaded_bytes", 0)
+            speed = data.get("speed")
+
+            if total:
+                percent = (downloaded / total) * 100
+            else:
+                percent = 0
+
+            network = self._format_speed(speed)
+
+            print(
+                f"\r[Download {percent:.0f}%] "
+                f"[Network {network}] "
+                f"[Mode {mode}]",
+                end="",
+                flush=True
+            )
+
+            if progress_callback:
+                try:
+                    progress_callback(
+                        f"{percent:.0f}%",
+                        network,
+                        mode
+                    )
+                except Exception:
+                    pass
+
+        elif status == "finished":
+
+            network = self._format_speed(
+                data.get("speed")
+            )
+
+            print(
+                f"\r[Download 100%] "
+                f"[Network {network}] "
+                f"[Mode {mode}]"
+            )
+
+            if progress_callback:
+                try:
+                    progress_callback(
+                        "100%",
+                        network,
+                        mode
+                    )
+                except Exception:
+                    pass
+
+    def _get_format(self, quality):
+
+        if quality == "audio":
+
+            return (
+                "bestaudio[acodec^=mp4a]/"
+                "bestaudio"
+            )
+
+        elif quality == "best":
+
+            return (
+                "bestvideo[vcodec^=avc1]+"
+                "bestaudio[acodec^=mp4a]/"
+                "bestvideo[vcodec^=avc1]+"
+                "bestaudio/"
+                "best"
+            )
+
+        else:
+
+            height = quality.replace("p", "")
+
+            return (
+                f"bestvideo[height<={height}]"
+                f"[vcodec^=avc1]+"
+                f"bestaudio[acodec^=mp4a]/"
+                f"bestvideo[height<={height}]"
+                f"[vcodec^=avc1]+"
+                f"bestaudio/"
+                f"best"
+            )
+
+    # ============================================================
+    # Main Engine
+    # ============================================================
+
+    def execute(
+        self,
+        config,
+        cookies=None,
+        progress_callback=None
+    ):
+
+        url = config["url"]
+
+        # ---------------------------------
+        # Cookie validation
+        # ---------------------------------
+
+        if cookies:
+
+            if not os.path.isfile(cookies):
+                raise FileNotFoundError(
+                    f"Cookies file not found: {cookies}"
+                )
+
+        # ---------------------------------
+        # Find playlist block
+        # ---------------------------------
+
+        playlist = None
+
+        for block in config["blocks"]:
+
+            if block["type"] == "playlist":
+                playlist = block
+                break
+
+        # ---------------------------------
+        # Find video block
+        # ---------------------------------
+
+        video = None
+
+        for block in config["blocks"]:
+
+            if block["type"] == "video":
+                video = block
+                break
+
+        # =========================================================
+        # PLAYLIST ENGINE
+        # =========================================================
+
+        if playlist is not None:
+
+            quality_stage = playlist["quality"]
+            skip = playlist["skip"]
+            count = playlist["count"]
+
+            quality = STAGES[quality_stage]
+
+            fmt = self._get_format(quality)
+
+            # -----------------------------------------------------
+            # Metadata + playlist title
+            # -----------------------------------------------------
+
+            metadata_options = {
+                "quiet": True,
+                "no_warnings": True,
+                "extract_flat": True,
+                "noplaylist": False
+            }
+
+            if cookies:
+                metadata_options["cookiefile"] = cookies
+
+            with yt_dlp.YoutubeDL(
+                metadata_options
+            ) as ydl:
+
+                playlist_info = ydl.extract_info(
+                    url,
+                    download=False
+                )
+
+            result = {}
+
+            # -----------------------------------------------------
+            # Metadata blocks
+            # -----------------------------------------------------
+
+            for block in config["blocks"]:
+
+                variable = block["variable"]
+
+                if not variable:
+                    continue
+
+                block_type = block["type"]
+
+                if block_type == "title":
+
+                    result[variable] = playlist_info.get(
+                        "title"
+                    )
+
+                elif block_type == "creator":
+
+                    result[variable] = (
+                        playlist_info.get("uploader")
+                        or playlist_info.get("channel")
+                    )
+
+                elif block_type == "url":
+
+                    result[variable] = (
+                        playlist_info.get("webpage_url")
+                        or url
+                    )
+
+                elif block_type == "views":
+
+                    result[variable] = playlist_info.get(
+                        "view_count"
+                    )
+
+                elif block_type == "likes":
+
+                    result[variable] = playlist_info.get(
+                        "like_count"
+                    )
+
+                elif block_type == "count":
+
+                    result[variable] = playlist_info.get(
+                        "comment_count"
+                    )
+
+                elif block_type == "time":
+
+                    result[variable] = playlist_info.get(
+                        "duration"
+                    )
+
+                elif block_type == "playlist_title":
+
+                    result[variable] = playlist_info.get(
+                        "title"
+                    )
+
+            # -----------------------------------------------------
+            # Playlist range
+            # -----------------------------------------------------
+
+            start = skip + 1
+            end = skip + count
+
+            playlist_items = f"{start}-{end}"
+
+            output = os.path.join(
+                self.path,
+                "%(title)s.%(ext)s"
+            )
+
+            options = {
+                "format": fmt,
+                "outtmpl": output,
+                "noplaylist": False,
+                "playlist_items": playlist_items,
+                "merge_output_format": "mp4",
+                "quiet": True,
+                "no_warnings": True,
+                "progress_hooks": [
+                    lambda data: self._progress_hook(
+                        data,
+                        "Playlist",
+                        progress_callback
+                    )
+                ]
+            }
+
+            if cookies:
+                options["cookiefile"] = cookies
+
+            print(
+                f"Playlist download: "
+                f"quality={quality}, "
+                f"skip={skip}, "
+                f"count={count}"
+            )
+
+            # -----------------------------------------------------
+            # Download playlist
+            # -----------------------------------------------------
+
+            downloaded_files = []
+
+            with yt_dlp.YoutubeDL(options) as ydl:
+
+                final_info = ydl.extract_info(
+                    url,
+                    download=True
+                )
+
+                entries = final_info.get(
+                    "entries",
+                    []
+                )
+
+                for entry in entries:
+
+                    if not entry:
+                        continue
+
+                    filepath = ydl.prepare_filename(
+                        entry
+                    )
+
+                    if not os.path.exists(filepath):
+
+                        mp4_path = (
+                            os.path.splitext(filepath)[0]
+                            + ".mp4"
+                        )
+
+                        if os.path.exists(mp4_path):
+                            filepath = mp4_path
+
+                    if os.path.exists(filepath):
+
+                        downloaded_files.append(
+                            filepath
+                        )
+
+            # -----------------------------------------------------
+            # Return playlist files
+            # -----------------------------------------------------
+
+            result["videos"] = downloaded_files
+
+            return result
+
+        # =========================================================
+        # NORMAL SINGLE-VIDEO ENGINE
+        # =========================================================
+
+        metadata_options = {
+            "quiet": True,
+            "no_warnings": True
+        }
+
+        if cookies:
+            metadata_options["cookiefile"] = cookies
+
+        with yt_dlp.YoutubeDL(
+            metadata_options
+        ) as ydl:
+
+            info = ydl.extract_info(
+                url,
+                download=False
+            )
+
+        result = {}
+
+        # ---------------------------------
+        # Metadata blocks
+        # ---------------------------------
+
+        for block in config["blocks"]:
+
+            variable = block["variable"]
+
+            if not variable:
+                continue
+
+            block_type = block["type"]
+
+            if block_type == "title":
+
+                result[variable] = info.get(
+                    "title"
+                )
+
+            elif block_type == "creator":
+
+                result[variable] = (
+                    info.get("uploader")
+                    or info.get("channel")
+                )
+
+            elif block_type == "url":
+
+                result[variable] = (
+                    info.get("webpage_url")
+                    or url
+                )
+
+            elif block_type == "views":
+
+                result[variable] = info.get(
+                    "view_count"
+                )
+
+            elif block_type == "likes":
+
+                result[variable] = info.get(
+                    "like_count"
+                )
+
+            elif block_type == "count":
+
+                result[variable] = info.get(
+                    "comment_count"
+                )
+
+            elif block_type == "time":
+
+                result[variable] = info.get(
+                    "duration"
+                )
+
+            elif block_type == "thumbnail":
+
+                thumbnail_url = info.get(
+                    "thumbnail"
+                )
+
+                if thumbnail_url:
+
+                    title = (
+                        info.get("title")
+                        or "thumbnail"
+                    )
+
+                    thumbnail_path = os.path.join(
+                        self.path,
+                        f"{title}.jpg"
+                    )
+
+                    urllib.request.urlretrieve(
+                        thumbnail_url,
+                        thumbnail_path
+                    )
+
+                    result[variable] = thumbnail_path
+
+                else:
+
+                    result[variable] = None
+
+            elif block_type == "formats":
+
+                result[variable] = info.get(
+                    "formats",
+                    []
+                )
+
+        # ---------------------------------
+        # Metadata-only request
+        # ---------------------------------
+
+        if video is None:
+            return result
+
+        # ---------------------------------
+        # Quality
+        # ---------------------------------
+
+        stage = video["stage"]
+
+        quality = STAGES[stage]
+
+        fmt = self._get_format(quality)
+
+        # ---------------------------------
+        # Download options
+        # ---------------------------------
+
+        output = os.path.join(
+            self.path,
+            "%(title)s.%(ext)s"
+        )
+
+        options = {
+            "format": fmt,
+            "outtmpl": output,
+            "noplaylist": True,
+            "merge_output_format": "mp4",
+            "quiet": True,
+            "progress_hooks": [
+                lambda data: self._progress_hook(
+                    data,
+                    "Video",
+                    progress_callback
+                )
+            ]
+        }
+
+        if cookies:
+            options["cookiefile"] = cookies
+
+        print(
+            f"Downloading: {quality}"
+        )
+
+        with yt_dlp.YoutubeDL(options) as ydl:
+
+            final_info = ydl.extract_info(
+                url,
+                download=True
+            )
+
+            filepath = ydl.prepare_filename(
+                final_info
+            )
+
+        if not os.path.exists(filepath):
+
+            mp4_path = (
+                os.path.splitext(filepath)[0]
+                + ".mp4"
+            )
+
+            if os.path.exists(mp4_path):
+                filepath = mp4_path
+
+        result[video["variable"]] = filepath
+
+        return result

simplesoup/gallery.py

@@ -0,0 +1,44 @@
+import os
+import subprocess
+
+
+class Gallery:
+
+    def __init__(self):
+        self.path = "/storage/emulated/0/Download/ReiDownloader"
+        os.makedirs(self.path, exist_ok=True)
+
+    def execute(self, url, cookies=None):
+
+        command = [
+            "gallery-dl",
+            "--directory",
+            self.path,
+        ]
+
+        # ---------------------------------
+        # Automatic cookies
+        # ---------------------------------
+
+        if cookies:
+
+            if not os.path.isfile(cookies):
+                raise FileNotFoundError(
+                    f"Cookies file not found: {cookies}"
+                )
+
+            command.extend([
+                "--cookies",
+                cookies
+            ])
+
+        command.append(url)
+
+        print("Downloading gallery...")
+
+        subprocess.run(
+            command,
+            check=True
+        )
+
+        return self.path

simplesoup/parser.py

@@ -0,0 +1,218 @@
+STAGES = {
+    0: "audio",
+    2: "360p",
+    3: "480p",
+    4: "720p",
+    5: "1080p",
+    6: "best",
+}
+
+
+def parse(expression):
+    """
+    Parse SimpleSoup configuration.
+
+    Supported format:
+
+        {
+            "video[4]": "video",
+            "playlist": "4:10:4",
+            "title": "title",
+            "creator": "creator",
+            "url": "url",
+            "views": "views",
+            "likes": "likes",
+            "count": "count",
+            "time": "duration",
+            "thumbnail": "thumbnail"
+        }
+
+    Playlist format:
+
+        "playlist": "quality:skip:count"
+
+    Example:
+
+        "playlist": "4:10:4"
+
+    Means:
+
+        4  = 720p
+        10 = skip first 10 videos
+        4  = download next 4 videos
+
+    Old rz.(...) syntax is also supported.
+    """
+
+    # -----------------------------
+    # New dictionary-style syntax
+    # -----------------------------
+    if isinstance(expression, dict):
+
+        result = {
+            "url": None,
+            "blocks": []
+        }
+
+        for key, variable in expression.items():
+
+            key = str(key).strip()
+            variable = str(variable).strip()
+
+            # video[4]
+            if key.startswith("video[") and key.endswith("]"):
+
+                stage_text = key[6:-1]
+
+                try:
+                    stage = int(stage_text)
+                except ValueError:
+                    raise ValueError(
+                        f"Invalid video stage: {stage_text}"
+                    )
+
+                if stage not in STAGES:
+                    raise ValueError(
+                        f"Unknown video stage: {stage}"
+                    )
+
+                result["blocks"].append({
+                    "type": "video",
+                    "stage": stage,
+                    "variable": variable
+                })
+
+                continue
+
+            # playlist
+            if key == "playlist":
+
+                parts = variable.split(":")
+
+                if len(parts) != 3:
+                    raise ValueError(
+                        "Playlist syntax: playlist:quality:skip:count"
+                    )
+
+                try:
+                    quality = int(parts[0])
+                    skip = int(parts[1])
+                    count = int(parts[2])
+                except ValueError:
+                    raise ValueError(
+                        "Playlist values must be numbers"
+                    )
+
+                if quality not in STAGES:
+                    raise ValueError(
+                        f"Unknown playlist quality: {quality}"
+                    )
+
+                if skip < 0:
+                    raise ValueError(
+                        "Playlist skip cannot be negative"
+                    )
+
+                if count <= 0:
+                    raise ValueError(
+                        "Playlist count must be greater than 0"
+                    )
+
+                result["blocks"].append({
+                    "type": "playlist",
+                    "quality": quality,
+                    "skip": skip,
+                    "count": count,
+                    "variable": None
+                })
+
+                continue
+
+            # normal block
+            result["blocks"].append({
+                "type": key,
+                "variable": variable
+            })
+
+        return result
+
+    # -----------------------------
+    # Old rz.(...) syntax
+    # -----------------------------
+    expression = expression.strip()
+
+    if not expression.startswith("rz.(") or not expression.endswith(")"):
+        raise ValueError("Invalid SimpleSoup syntax")
+
+    body = expression[4:-1].strip()
+
+    parts = [
+        p.strip()
+        for p in body.split(";")
+        if p.strip()
+    ]
+
+    result = {
+        "url": None,
+        "blocks": []
+    }
+
+    for part in parts:
+
+        # URL
+        if part.startswith("{") and part.endswith("}"):
+            result["url"] = part[1:-1].strip()
+            continue
+
+        # video[4]:variable
+        if part.startswith("video["):
+
+            if "]:" not in part:
+                raise ValueError(
+                    "Video syntax: video[stage]:variable"
+                )
+
+            stage_text, variable = part.split("]:", 1)
+
+            try:
+                stage = int(stage_text[6:])
+            except ValueError:
+                raise ValueError(
+                    "Invalid video stage"
+                )
+
+            if stage not in STAGES:
+                raise ValueError(
+                    f"Unknown video stage: {stage}"
+                )
+
+            result["blocks"].append({
+                "type": "video",
+                "stage": stage,
+                "variable": variable.strip()
+            })
+
+            continue
+
+        # name:variable
+        if ":" in part:
+
+            name, variable = part.split(":", 1)
+
+            result["blocks"].append({
+                "type": name.strip(),
+                "variable": variable.strip()
+            })
+
+            continue
+
+        # simple block
+        result["blocks"].append({
+            "type": part,
+            "variable": None
+        })
+
+    if not result["url"]:
+        raise ValueError("URL missing")
+
+    return result

simplesoup-0.1.0.dist-info/METADATA

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: simplesoup
+Version: 0.1.0
+Summary: Simple CSS-style yt-dlp and FFmpeg wrapper
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: yt-dlp
+Provides-Extra: gallery
+Requires-Dist: gallery-dl; extra == "gallery"
+
+# SimpleSoup
+
+A simple Python wrapper for yt-dlp and FFmpeg.
+
+## Installation
+
+```bash
+pip install simplesoup
+
+For gallery support:
+
+pip install "simplesoup[gallery]"
+
+Import
+
+from simplesoup import rz
+
+Basic Syntax
+
+result = rz({
+    "WHAT_TO_REQUEST": "VARIABLE_NAME"
+}, url)
+
+WHAT_TO_REQUEST batata hai kya chahiye, aur VARIABLE_NAME batata hai result mein us value ko kis naam se save karna hai.
+
+Example:
+
+result = rz({
+    "title": "title"
+}, url)
+
+print(result["title"])
+
+Video Download
+
+result = rz({
+    "video[4]": "video"
+}, url)
+
+print(result["video"])
+
+video[4] = 720p.
+
+Video Quality
+
+video[0] → audio
+video[2] → 360p
+video[3] → 480p
+video[4] → 720p
+video[5] → 1080p
+video[6] → best available
+
+Example:
+
+result = rz({
+    "video[5]": "video"
+}, url)
+
+Multiple Values At Once
+
+Ek hi request mein video aur metadata dono le sakte ho:
+
+result = rz({
+    "video[4]": "video",
+    "title": "title",
+    "creator": "creator",
+    "url": "video_url",
+    "views": "views",
+    "likes": "likes",
+    "count": "comments",
+    "time": "duration",
+    "thumbnail": "thumbnail"
+}, url)
+
+Values access karne ke liye:
+
+print(result["video"])
+print(result["title"])
+print(result["creator"])
+print(result["video_url"])
+print(result["views"])
+print(result["likes"])
+print(result["comments"])
+print(result["duration"])
+print(result["thumbnail"])
+
+Order matter nahi karta.
+
+Metadata
+
+Available metadata:
+
+title      → video title
+creator    → uploader/channel
+url        → video URL
+views      → view count
+likes      → like count
+count      → comment count
+time       → duration in seconds
+thumbnail  → downloaded thumbnail path
+formats    → available yt-dlp formats
+
+Metadata Only
+
+Agar sirf metadata chahiye aur video download nahi karna:
+
+result = rz({
+    "title": "title",
+    "creator": "creator",
+    "views": "views",
+    "likes": "likes",
+    "count": "comments",
+    "time": "duration"
+}, url)
+
+video[...] block nahi hone par video download nahi hota.
+
+Thumbnail
+
+result = rz({
+    "thumbnail": "thumbnail"
+}, url)
+
+print(result["thumbnail"])
+
+Thumbnail actual .jpg file ke roop mein download hota hai.
+
+Playlist
+
+Playlist syntax:
+
+result = rz({
+    "playlist": "QUALITY:SKIP:COUNT"
+}, playlist_url)
+
+Example:
+
+result = rz({
+    "playlist": "4:20:3"
+}, playlist_url)
+
+Meaning:
+
+4  → 720p
+20 → first 20 videos skip
+3  → next 3 videos download
+
+So:
+
+Video 1-20 → skip
+Video 21   → download
+Video 22   → download
+Video 23   → download
+
+Downloaded videos:
+
+for video in result["videos"]:
+    print(video)
+
+Playlist + Metadata
+
+result = rz({
+    "playlist": "4:20:3",
+    "title": "playlist_title"
+}, playlist_url)
+
+print(result["playlist_title"])
+print(result["videos"])
+
+Gallery
+
+Gallery downloading ke liye:
+
+result = rz({
+    "gallery": "images"
+}, gallery_url)
+
+print(result)
+
+Gallery support ke liye gallery-dl install hona chahiye:
+
+pip install "simplesoup[gallery]"
+
+Cookies
+
+Cookies simplesoup/core.py mein configure kiye jaate hain:
+
+COOKIES = "/storage/emulated/0/Download/cookies.txt"
+
+Example:
+
+COOKIES = "/storage/emulated/0/Download/reddit_cookies.txt"
+
+Cookies disable karne ke liye:
+
+COOKIES = None
+
+SimpleSoup configured cookie file ko use karta hai.
+
+Progress Callback
+
+Optional progress callback:
+
+def progress(percent, speed, mode):
+    print(
+        f"[Download {percent}] "
+        f"[Network {speed}] "
+        f"[Mode {mode}]"
+    )
+
+result = rz(
+    {
+        "video[4]": "video"
+    },
+    url,
+    progress_callback=progress
+)
+
+Callback ko ye 3 values milti hain:
+
+percent → download percentage
+speed   → network speed
+mode    → Video / Playlist
+
+Complete Example
+
+from simplesoup import rz
+
+url = "VIDEO_URL"
+
+result = rz({
+    "video[4]": "video",
+    "title": "title",
+    "creator": "creator",
+    "url": "video_url",
+    "views": "views",
+    "likes": "likes",
+    "count": "comments",
+    "time": "duration",
+    "thumbnail": "thumbnail"
+}, url)
+
+print("Video:", result["video"])
+print("Title:", result["title"])
+print("Creator:", result["creator"])
+print("URL:", result["video_url"])
+print("Views:", result["views"])
+print("Likes:", result["likes"])
+print("Comments:", result["comments"])
+print("Duration:", result["duration"])
+print("Thumbnail:", result["thumbnail"])
+
+Default Download Location
+
+/storage/emulated/0/Download/ReiDownloader/
+
+API Syntax Summary
+
+Single video:
+
+rz({
+    "video[QUALITY]": "variable"
+}, url)
+
+Metadata:
+
+rz({
+    "title": "variable",
+    "creator": "variable",
+    "url": "variable",
+    "views": "variable",
+    "likes": "variable",
+    "count": "variable",
+    "time": "variable",
+    "thumbnail": "variable"
+}, url)
+
+Video + metadata:
+
+rz({
+    "video[4]": "video",
+    "title": "title",
+    "creator": "creator",
+    "views": "views",
+    "likes": "likes",
+    "count": "comments",
+    "time": "duration",
+    "thumbnail": "thumbnail"
+}, url)
+
+Playlist:
+
+rz({
+    "playlist": "QUALITY:SKIP:COUNT"
+}, playlist_url)
+
+Gallery:
+
+rz({
+    "gallery": "variable"
+}, gallery_url)
+
+Version
+
+SimpleSoup 0.1.0

simplesoup-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+simplesoup/__init__.py,sha256=sqmWkYkrTrw-fNgy-SJU0nLd2Gwnt8WJITEAfucpARE,65
+simplesoup/converter.py,sha256=x8Rhipe1XYvrsVjnxsObKrGAB-lQwiNFohVMP3MQXYQ,566
+simplesoup/core.py,sha256=gjHagBqNHnI2-ur5wBSKFSKtq39PShHSk7mxp_6pWag,1958
+simplesoup/downloader.py,sha256=LECSYyzWnhvymfHH-HzTrzwjhbJZIXCmtoGzSbgfH9Q,14052
+simplesoup/gallery.py,sha256=9S7DT5AD1maEXFye3H5Q9fBbZU-0JjD15amQ39_vgNE,903
+simplesoup/parser.py,sha256=AJzp9Lkjgu7arCk-MPTu_yK6xvF6YgRs8QG8gPwtM_g,5216
+simplesoup-0.1.0.dist-info/METADATA,sha256=deC95gVPhsOnDmJcr0E19l5gjmffaFLBbzphK1qGc84,5283
+simplesoup-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+simplesoup-0.1.0.dist-info/top_level.txt,sha256=jtEKGzuqamPe-w0c81H0XtiE-9xk27twJdIwN43L_tk,11
+simplesoup-0.1.0.dist-info/RECORD,,

simplesoup-0.1.0.dist-info/WHEEL

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

simplesoup-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simplesoup