easyder 0.2.0__py3-none-any.whl

easyder/__init__.py

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

easyder/core.py

@@ -0,0 +1,150 @@
+import inspect
+
+from .parser import parse, STAGES
+
+
+COOKIE_VARIABLE = "Cooki"
+
+
+class EasyDer:
+
+    def __init__(self, cookies=None):
+        import os
+        from .downloader import Downloader
+
+        self.downloader = Downloader()
+        self.cookies = cookies or []
+
+    def _get_working_cookie(self, url):
+        if not self.cookies:
+            return None
+
+        print("Checking cookies...")
+
+        for cookie in self.cookies:
+            if not cookie:
+                continue
+
+            if not self.downloader.cookie_exists(cookie):
+                print(f"❌ Cookie file not found: {cookie}")
+                print("   → Continuing...")
+                continue
+
+            try:
+                print(f"🔍 Testing cookie: {cookie}")
+
+                self.downloader.test_cookie(
+                    url,
+                    cookie
+                )
+
+                print(f"✅ Cookie works: {cookie}")
+                return cookie
+
+            except Exception as e:
+                print(f"❌ Cookie failed: {cookie}")
+                print(f"   → {e}")
+                print("   → Continuing...")
+
+        print("⚠️ No working cookie found.")
+        return None
+
+    def execute(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")
+
+        try:
+            return self.downloader.execute(
+                config,
+                cookies=None,
+                progress_callback=progress_callback
+            )
+
+        except Exception as normal_error:
+            print("\n⚠️ Normal request failed.")
+
+            working_cookie = self._get_working_cookie(
+                config["url"]
+            )
+
+            if working_cookie is None:
+                print("❌ No working cookie available.")
+                raise normal_error
+
+            print(
+                f"🍪 Using working cookie: "
+                f"{working_cookie}"
+            )
+
+            return self.downloader.execute(
+                config,
+                cookies=working_cookie,
+                progress_callback=progress_callback
+            )
+
+    def __call__(
+        self,
+        expression,
+        url=None,
+        progress_callback=None
+    ):
+        return self.execute(
+            expression,
+            url,
+            progress_callback
+        )
+
+
+def _get_user_cookies():
+    frame = inspect.currentframe()
+
+    try:
+        if frame is None:
+            return []
+
+        caller = frame.f_back
+
+        while caller is not None:
+            cookies = caller.f_locals.get(
+                COOKIE_VARIABLE
+            )
+
+            if cookies is None:
+                cookies = caller.f_globals.get(
+                    COOKIE_VARIABLE
+                )
+
+            if cookies is not None:
+                if isinstance(cookies, str):
+                    return [cookies]
+
+                if isinstance(cookies, (list, tuple)):
+                    return list(cookies)
+
+            caller = caller.f_back
+
+        return []
+
+    finally:
+        del frame
+
+
+def rz(
+    expression,
+    url=None,
+    progress_callback=None
+):
+    cookies = _get_user_cookies()
+
+    handler = EasyDer(cookies)
+
+    return handler.execute(
+        expression,
+        url,
+        progress_callback
+    )

easyder/downloader.py

@@ -0,0 +1,571 @@
+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 cookie_exists(self, cookie):
+        return os.path.isfile(cookie)
+
+    def test_cookie(self, url, cookie):
+        options = {
+            "quiet": True,
+            "no_warnings": True,
+            "cookiefile": cookie
+        }
+
+        with yt_dlp.YoutubeDL(options) as ydl:
+            ydl.extract_info(
+                url,
+                download=False
+            )
+
+    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

easyder/parser.py

@@ -0,0 +1,88 @@
+STAGES = {
+    0: "audio",
+    1: "360p",
+    2: "480p",
+    3: "720p",
+    4: "1080p",
+    5: "best",
+}
+
+
+def parse(expression):
+    if not isinstance(expression, dict):
+        raise ValueError("Easyder syntax must be a dictionary")
+
+    result = {
+        "url": None,
+        "blocks": []
+    }
+
+    for key, variable in expression.items():
+        key = str(key).strip()
+        variable = str(variable).strip()
+
+        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
+
+        if key == "playlist":
+            parts = variable.split(":")
+
+            if len(parts) != 3:
+                raise ValueError(
+                    "Playlist syntax: 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
+
+        result["blocks"].append({
+            "type": key,
+            "variable": variable
+        })
+
+    return result

easyder-0.2.0.dist-info/METADATA

@@ -0,0 +1,504 @@
+Metadata-Version: 2.4
+Name: easyder
+Version: 0.2.0
+Summary: EASYDER - CSS-inspired video downloader with automatic cookie fallback, powered by yt-dlp + FFmpeg
+Home-page: https://github.com/ReiZyuki/easyder
+Author: ReiZyuki
+Author-email: ReiZyuki <rei@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ReiZyuki/easyder
+Project-URL: Bug Tracker, https://github.com/ReiZyuki/easyder/issues
+Project-URL: Documentation, https://github.com/ReiZyuki/easyder#readme
+Project-URL: Source Code, https://github.com/ReiZyuki/easyder
+Keywords: video,downloader,youtube,instagram,tiktok,yt-dlp,ffmpeg,css-inspired,easy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Multimedia :: Video
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: yt-dlp>=2023.12.30
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+EASYDER — CSS-Inspired Video Downloader
+
+""Python 3.8+" (https://img.shields.io/badge/python-3.8+-blue.svg)" (https://www.python.org/downloads/)
+""License: MIT" (https://img.shields.io/badge/License-MIT-yellow.svg)" (https://opensource.org/licenses/MIT)
+
+EASYDER is a CSS-inspired video downloader built with yt-dlp + FFmpeg.
+
+Easyder V1.0 focuses on downloading video/audio, extracting metadata, downloading thumbnails, handling playlists, and automatically trying supplied cookie files when a normal request fails.
+
+---
+
+Features
+
+- ✅ CSS-inspired dictionary syntax
+- ✅ Video quality selection
+- ✅ Audio-only downloads
+- ✅ 360p, 480p, 720p and 1080p quality stages
+- ✅ Original/best quality selection
+- ✅ Automatic cookie fallback
+- ✅ Multiple supplied cookie files
+- ✅ Playlist downloads
+- ✅ Video metadata extraction
+- ✅ Thumbnail downloading
+- ✅ yt-dlp + FFmpeg based downloading
+- ✅ Download progress display
+- ✅ MP4 output for video downloads
+
+---
+
+Installation
+
+From PyPI
+
+pip install easyder
+
+From GitHub
+
+git clone https://github.com/ReiZyuki/Easyder.git
+cd Easyder
+pip install -e .
+
+---
+
+Quick Start
+
+from easyder import rz
+
+result = rz(
+    {
+        "video[3]": "video",
+        "title": "title",
+        "creator": "creator",
+    },
+    url,
+)
+
+print("Video:", result["video"])
+print("Title:", result["title"])
+print("Creator:", result["creator"])
+
+The right-side values such as ""video"", ""title"" and ""creator"" are user-defined variable names.
+
+---
+
+Video Quality
+
+Easyder uses CSS-inspired quality selectors:
+
+"video[0]"
+"video[1]"
+"video[2]"
+"video[3]"
+"video[4]"
+"video[5]"
+
+Selector| Quality
+"video[0]"| Audio only
+"video[1]"| 360p
+"video[2]"| 480p
+"video[3]"| 720p
+"video[4]"| 1080p
+"video[5]"| Best/original available quality
+
+Example:
+
+from easyder import rz
+
+result = rz(
+    {
+        "video[4]": "video",
+    },
+    url,
+)
+
+print(result["video"])
+
+If the requested quality is unavailable, yt-dlp selects an appropriate available format according to Easyder's format selection rules.
+
+---
+
+Audio Only
+
+Use "video[0]" for audio:
+
+from easyder import rz
+
+result = rz(
+    {
+        "video[0]": "audio",
+    },
+    url,
+)
+
+print(result["audio"])
+
+---
+
+Metadata
+
+Easyder can extract video metadata without downloading the video.
+
+from easyder import rz
+
+result = rz(
+    {
+        "title": "title",
+        "creator": "creator",
+        "url": "video_url",
+        "views": "views",
+        "likes": "likes",
+        "count": "comments",
+        "time": "duration",
+        "thumbnail": "thumbnail",
+        "formats": "formats",
+    },
+    url,
+)
+
+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"])
+print("Formats:", result["formats"])
+
+Metadata variable names are completely user-defined.
+
+For example:
+
+result = rz(
+    {
+        "title": "MyTitle",
+        "creator": "MyCreator",
+    },
+    url,
+)
+
+print(result["MyTitle"])
+print(result["MyCreator"])
+
+---
+
+Thumbnail
+
+Use the "thumbnail" selector to download the video's thumbnail.
+
+from easyder import rz
+
+result = rz(
+    {
+        "thumbnail": "thumb",
+    },
+    url,
+)
+
+print(result["thumb"])
+
+The returned value is the path of the downloaded thumbnail.
+
+Default download directory:
+
+/storage/emulated/0/Download/ReiDownloader
+
+---
+
+Playlist
+
+Playlist syntax:
+
+"playlist": "QUALITY:SKIP:COUNT"
+
+Example:
+
+from easyder import rz
+
+result = rz(
+    {
+        "playlist": "3:5:10",
+    },
+    playlist_url,
+)
+
+print(result["videos"])
+
+Meaning:
+
+3 = 720p
+5 = skip the first 5 videos
+10 = download the next 10 videos
+
+Quality values
+
+Quality| Meaning
+"0"| Audio
+"1"| 360p
+"2"| 480p
+"3"| 720p
+"4"| 1080p
+"5"| Best/original
+
+Example:
+
+result = rz(
+    {
+        "playlist": "4:0:5",
+    },
+    playlist_url,
+)
+
+This requests:
+
+1080p
+Skip 0
+Download 5 videos
+
+Downloaded playlist files are returned in:
+
+result["videos"]
+
+---
+
+Automatic Cookie Fallback
+
+Easyder first attempts the request without cookies.
+
+If the normal request fails, Easyder checks the cookie files supplied through the "Cooki" variable.
+
+from easyder import rz
+
+Cooki = [
+    "/storage/emulated/0/Download/youtube.txt",
+    "/storage/emulated/0/Download/other.txt",
+]
+
+result = rz(
+    {
+        "video[3]": "video",
+        "title": "title",
+    },
+    url,
+)
+
+Easyder tests the supplied cookie files one by one and uses the first working cookie.
+
+No cookie filenames are hardcoded by Easyder.
+
+---
+
+Cookie Variable
+
+The cookie variable name is:
+
+Cooki
+
+It can contain a single path:
+
+Cooki = "/path/to/cookies.txt"
+
+or multiple paths:
+
+Cooki = [
+    "/path/to/cookies1.txt",
+    "/path/to/cookies2.txt",
+]
+
+Easyder does not scan directories for cookie files.
+
+---
+
+Progress
+
+During downloads Easyder displays progress information similar to:
+
+Downloading: 1080p
+[Download 50%] [Network 2.0 MB/s] [Mode Video]
+
+The downloader can also receive a progress callback:
+
+from easyder import rz
+
+def progress(percent, network, mode):
+    print(percent, network, mode)
+
+result = rz(
+    {
+        "video[3]": "video",
+    },
+    url,
+    progress_callback=progress,
+)
+
+The callback receives:
+
+percent
+network
+mode
+
+---
+
+Custom Variable Names
+
+Easyder does not require fixed output variable names.
+
+For example:
+
+result = rz(
+    {
+        "video[3]": "MyVideo",
+        "title": "MyTitle",
+        "creator": "MyCreator",
+        "thumbnail": "MyThumbnail",
+    },
+    url,
+)
+
+Then:
+
+print(result["MyVideo"])
+print(result["MyTitle"])
+print(result["MyCreator"])
+print(result["MyThumbnail"])
+
+This keeps the selector syntax separate from the variable names used by your application.
+
+---
+
+Complete Example
+
+from easyder import rz
+
+Cooki = [
+    "/storage/emulated/0/Download/youtube.txt",
+]
+
+result = rz(
+    {
+        "video[4]": "video",
+        "title": "title",
+        "creator": "creator",
+        "thumbnail": "thumbnail",
+        "views": "views",
+        "likes": "likes",
+        "time": "duration",
+    },
+    url,
+)
+
+print("Video:", result["video"])
+print("Title:", result["title"])
+print("Creator:", result["creator"])
+print("Thumbnail:", result["thumbnail"])
+print("Views:", result["views"])
+print("Likes:", result["likes"])
+print("Duration:", result["duration"])
+
+---
+
+Selector Reference
+
+Selector| Example value| Description
+"video[0]"| ""video""| Audio only
+"video[1]"| ""video""| 360p video
+"video[2]"| ""video""| 480p video
+"video[3]"| ""video""| 720p video
+"video[4]"| ""video""| 1080p video
+"video[5]"| ""video""| Best/original quality
+"title"| ""title""| Video title
+"creator"| ""creator""| Uploader/creator
+"url"| ""video_url""| Video URL
+"views"| ""views""| View count
+"likes"| ""likes""| Like count
+"count"| ""comments""| Comment count
+"time"| ""duration""| Duration
+"thumbnail"| ""thumbnail""| Download thumbnail
+"formats"| ""formats""| Available formats
+"playlist"| ""QUALITY:SKIP:COUNT""| Playlist download
+
+---
+
+Quality Reference
+
+video[0] = Audio only
+video[1] = 360p
+video[2] = 480p
+video[3] = 720p
+video[4] = 1080p
+video[5] = Best/original available
+
+---
+
+Requirements
+
+Easyder uses:
+
+- Python
+- yt-dlp
+- FFmpeg
+
+FFmpeg is required for media processing and merging separate video/audio streams.
+
+---
+
+Download Location
+
+The default download directory is:
+
+/storage/emulated/0/Download/ReiDownloader
+
+Videos and thumbnails downloaded by Easyder are stored there.
+
+---
+
+V1.0 Scope
+
+Easyder V1.0 intentionally focuses on:
+
+Video
+Audio
+Thumbnail
+Metadata
+Playlist
+Automatic cookie fallback
+Progress reporting
+
+Easyder V1.0 does not include:
+
+Gallery / gallery-dl
+Telegram / TeleBot integration
+Sender functionality
+
+These features may be considered separately in future versions.
+
+---
+
+License
+
+MIT License

easyder-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+easyder/__init__.py,sha256=lKyzNVVsHnac9yBcmb0vxwYtgHuX6UVNhaTJ_IllpTI,39
+easyder/core.py,sha256=f6gOUDsmi5zWalOmxslS6FkKxgXTCdJwrILHIWLbY-w,3404
+easyder/downloader.py,sha256=48LhUBhhqJXGE4-Mc_Sf61iiqcQghOe3rOq4SyCnyfA,14436
+easyder/parser.py,sha256=7e3ionF0ibBcMzgGt93Ug2yLBKQTtQDVZvL6EmQKRmk,2224
+easyder-0.2.0.dist-info/licenses/LICENSE,sha256=vPfguhmt6ouLqAZ0kAiP4zO2v01yvJ4477X24eh5Vvs,1065
+easyder-0.2.0.dist-info/METADATA,sha256=9_zSpxN84LoDRK6aen9XZ7hT1KA1Tq87ZHgFSM-YMqU,9633
+easyder-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+easyder-0.2.0.dist-info/top_level.txt,sha256=QGXPSOhE6ebeLjg_lLO6RXdG6OSc91s9Z9t8bgjFCaw,8
+easyder-0.2.0.dist-info/RECORD,,

easyder-0.2.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
+

easyder-0.2.0.dist-info/licenses/LICENSE

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

easyder-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+easyder