simplesyntax 0.1.0__py3-none-any.whl

easytasks/__init__.py

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

easytasks/core.py

@@ -0,0 +1,108 @@
+import inspect
+
+from .parser import parse_selector, parse_playlist
+from .video import run_video
+from .image import download_image
+from .media import run_media
+from .metadata import get_metadata
+from .playlist import run_playlist
+
+
+def _get_reizuki():
+    frame = inspect.currentframe()
+
+    try:
+        caller = frame.f_back
+
+        while caller is not None:
+            if "ReiZyuki" in caller.f_locals:
+                return caller.f_locals["ReiZyuki"]
+
+            if "ReiZyuki" in caller.f_globals:
+                return caller.f_globals["ReiZyuki"]
+
+            caller = caller.f_back
+
+        return None
+
+    finally:
+        del frame
+
+
+def rz(request, url):
+    if not isinstance(request, dict):
+        raise TypeError("rz() first argument must be a dictionary.")
+
+    if not isinstance(url, str):
+        raise TypeError("rz() url must be a string.")
+
+    cookie_paths = _get_reizuki()
+
+    if cookie_paths is not None:
+        if not isinstance(cookie_paths, (list, tuple)):
+            raise TypeError("ReiZyuki must be a list or tuple.")
+
+        cookie_paths = [
+            path
+            for path in cookie_paths
+            if isinstance(path, str) and path.strip()
+        ]
+
+    results = {}
+
+    for selector, variable in request.items():
+
+        if not isinstance(variable, str):
+            raise TypeError(
+                "Right-side value must be a variable name string."
+            )
+
+        if selector == "playlist":
+            parsed = parse_playlist(variable)
+
+            results[variable] = run_playlist(
+                url,
+                parsed["quality"],
+                parsed["skip"],
+                parsed["count"],
+                cookie_paths
+            )
+            continue
+
+        parsed = parse_selector(selector)
+
+        if parsed["type"] == "video":
+            result = run_video(
+                url,
+                parsed["quality"],
+                cookie_paths
+            )
+
+        elif parsed["type"] == "image":
+            result = download_image(
+                url,
+                cookie_paths
+            )
+
+        elif parsed["type"] == "media":
+            result = run_media(
+                url,
+                parsed["quality"],
+                cookie_paths
+            )
+
+        elif parsed["type"] == "metadata":
+            result = get_metadata(
+                url,
+                parsed["name"],
+                cookie_paths
+            )
+
+        else:
+            raise ValueError(
+                f"Unsupported operation type: {parsed[type]}"
+            )
+
+        results[variable] = result
+
+    return results

easytasks/downloader.py

@@ -0,0 +1,179 @@
+import os
+import yt_dlp
+
+
+DOWNLOAD_DIR = "/storage/emulated/0/Download/ReiDownloader/"
+
+
+QUALITY_FORMATS = {
+    0: (
+        "bestaudio[acodec^=mp4a]/"
+        "bestaudio"
+    ),
+
+    1: (
+        "bestvideo[height<=360][vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[height<=360][vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+
+    2: (
+        "bestvideo[height<=480][vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[height<=480][vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+
+    3: (
+        "bestvideo[height<=720][vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[height<=720][vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+
+    4: (
+        "bestvideo[height<=1080][vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[height<=1080][vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+
+    5: (
+        "bestvideo[height<=1440][vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[height<=1440][vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+
+    6: (
+        "bestvideo[vcodec^=avc1]+"
+        "bestaudio[acodec^=mp4a]/"
+        "bestvideo[vcodec^=avc1]+"
+        "bestaudio/"
+        "best"
+    ),
+}
+
+
+def ensure_download_dir():
+    os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+    return DOWNLOAD_DIR
+
+
+def _progress_hook(mode):
+    def hook(data):
+        status = data.get("status")
+
+        if status == "downloading":
+            total = (
+                data.get("total_bytes")
+                or data.get("total_bytes_estimate")
+            )
+
+            downloaded = data.get(
+                "downloaded_bytes",
+                0
+            )
+
+            if total:
+                percent = (
+                    downloaded * 100 / total
+                )
+                percent_text = (
+                    f"{percent:.1f}%"
+                )
+            else:
+                percent_text = "?"
+
+            speed = data.get("speed")
+
+            if speed:
+                if speed >= 1024 * 1024:
+                    speed_text = (
+                        f"{speed / (1024 * 1024):.2f}MiB/s"
+                    )
+                elif speed >= 1024:
+                    speed_text = (
+                        f"{speed / 1024:.2f}KiB/s"
+                    )
+                else:
+                    speed_text = (
+                        f"{speed:.0f}B/s"
+                    )
+            else:
+                speed_text = "0B/s"
+
+            print(
+                f"\r[Download {percent_text}]"
+                f"[Speed {speed_text}]"
+                f"[Mode {mode}]",
+                end="",
+                flush=True
+            )
+
+        elif status == "finished":
+            print()
+
+    return hook
+
+
+def download(
+    url,
+    quality,
+    cookie_file=None,
+    mode="video"
+):
+    if quality not in QUALITY_FORMATS:
+        raise ValueError(
+            f"Invalid quality: {quality}"
+        )
+
+    ensure_download_dir()
+
+    options = {
+        "format": QUALITY_FORMATS[quality],
+        "outtmpl": os.path.join(
+            DOWNLOAD_DIR,
+            "%(title)s.%(ext)s"
+        ),
+        "merge_output_format": "mp4",
+        "noplaylist": True,
+        "quiet": True,
+        "no_warnings": True,
+        "progress_hooks": [
+            _progress_hook(mode)
+        ],
+    }
+
+    if cookie_file is not None:
+        options["cookiefile"] = cookie_file
+
+    with yt_dlp.YoutubeDL(options) as ydl:
+        return ydl.download([url])
+
+
+def extract_info(
+    url,
+    cookie_file=None
+):
+    options = {
+        "quiet": True,
+        "no_warnings": True,
+        "skip_download": True,
+        "noplaylist": True,
+    }
+
+    if cookie_file is not None:
+        options["cookiefile"] = cookie_file
+
+    with yt_dlp.YoutubeDL(options) as ydl:
+        return ydl.extract_info(
+            url,
+            download=False
+        )

easytasks/fallback.py

@@ -0,0 +1,44 @@
+from .observer import get_cookie_scores, save_success
+
+
+def run_with_fallback(
+    operation,
+    cookie_paths=None,
+    url=None
+):
+    try:
+        return operation(None)
+
+    except Exception as first_error:
+        if not cookie_paths:
+            raise first_error
+
+        if url is not None:
+            ranked = get_cookie_scores(
+                url,
+                cookie_paths
+            )
+
+            ordered_cookies = [
+                cookie_path
+                for _, cookie_path in ranked
+            ]
+        else:
+            ordered_cookies = list(cookie_paths)
+
+        for cookie_file in ordered_cookies:
+            try:
+                result = operation(cookie_file)
+
+                if url is not None:
+                    save_success(
+                        url,
+                        cookie_file
+                    )
+
+                return result
+
+            except Exception:
+                continue
+
+        raise first_error

easytasks/ffmpeg.py

@@ -0,0 +1,25 @@
+import os
+import subprocess
+
+
+def merge_video_audio(video_path, audio_path, output_path):
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    command = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        video_path,
+        "-i",
+        audio_path,
+        "-c",
+        "copy",
+        output_path,
+    ]
+
+    subprocess.run(
+        command,
+        check=True
+    )
+
+    return output_path

easytasks/image.py

@@ -0,0 +1,128 @@
+import os
+import io
+import contextlib
+import gallery_dl
+
+from .fallback import run_with_fallback
+
+
+DOWNLOAD_DIR = "/storage/emulated/0/Download/ReiDownloader/"
+
+IMAGE_EXTENSIONS = {
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".webp",
+    ".gif",
+    ".bmp",
+    ".avif",
+}
+
+
+def ensure_download_dir():
+    os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+    return DOWNLOAD_DIR
+
+
+def _image_files():
+    files = []
+
+    for root, _, names in os.walk(DOWNLOAD_DIR):
+        for name in names:
+            path = os.path.join(root, name)
+
+            if os.path.splitext(name)[1].lower() in IMAGE_EXTENSIONS:
+                files.append(path)
+
+    return files
+
+
+def download_image_once(url, cookie_file=None):
+    ensure_download_dir()
+
+    before = set(_image_files())
+
+    gallery_dl.config.clear()
+
+    gallery_dl.config.set(
+        ("extractor",),
+        "base-directory",
+        DOWNLOAD_DIR
+    )
+
+    gallery_dl.config.set(
+        ("extractor",),
+        "metadata",
+        False
+    )
+
+    if cookie_file is not None:
+        gallery_dl.config.set(
+            ("extractor",),
+            "cookies",
+            cookie_file
+        )
+
+    output = io.StringIO()
+
+    try:
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
+            job = gallery_dl.job.DownloadJob(url)
+            result = job.run()
+
+    except Exception as error:
+        message = output.getvalue().strip()
+
+        if message:
+            raise RuntimeError(
+                f"gallery-dl failed:\n{message}"
+            ) from error
+
+        error_text = str(error).strip()
+
+        if error_text and error_text.lower() != "none":
+            raise RuntimeError(
+                f"gallery-dl failed: {error_text}"
+            ) from error
+
+        raise RuntimeError(
+            "gallery-dl failed without an error message."
+        ) from error
+
+    after = _image_files()
+
+    new_files = [
+        path
+        for path in after
+        if path not in before
+    ]
+
+    if new_files:
+        new_files.sort(
+            key=lambda path: os.path.getmtime(path),
+            reverse=True
+        )
+
+        return new_files[0]
+
+    message = output.getvalue().strip()
+
+    if message:
+        raise RuntimeError(
+            f"gallery-dl failed:\n{message}"
+        )
+
+    raise RuntimeError(
+        "gallery-dl completed without downloading an image."
+    )
+
+
+def download_image(url, cookie_paths=None):
+    return run_with_fallback(
+        lambda cookie_file: download_image_once(
+            url,
+            cookie_file
+        ),
+        cookie_paths,
+        url=url
+    )

easytasks/media.py

@@ -0,0 +1,37 @@
+from .video import run_video
+from .image import download_image
+
+
+def run_media(url, quality, cookie_paths=None):
+    video_error = None
+
+    try:
+        return run_video(
+            url,
+            quality,
+            cookie_paths
+        )
+
+    except Exception as error:
+        video_error = error
+        print("[MEDIA] VIDEO ERROR")
+        print(f"yt-dlp failed: {error}")
+
+    image_error = None
+
+    try:
+        return download_image(
+            url,
+            cookie_paths
+        )
+
+    except Exception as error:
+        image_error = error
+        print("[MEDIA] IMAGE ERROR")
+        print(f"gallery-dl failed: {error}")
+
+    raise RuntimeError(
+        "[MEDIA] FAILED\n\n"
+        f"VIDEO ERROR:\n{video_error}\n\n"
+        f"IMAGE ERROR:\n{image_error}"
+    )

easytasks/metadata.py

@@ -0,0 +1,30 @@
+from .downloader import extract_info
+from .fallback import run_with_fallback
+
+
+def get_metadata(url, name, cookie_paths=None):
+    info = run_with_fallback(
+        lambda cookie_file: extract_info(
+            url,
+            cookie_file
+        ),
+        cookie_paths, url=url
+    )
+
+    values = {
+        "title": info.get("title"),
+        "creator": (
+            info.get("creator")
+            or info.get("uploader")
+            or info.get("artist")
+            or info.get("author")
+        ),
+        "url": info.get("webpage_url") or url,
+        "views": info.get("view_count"),
+        "likes": info.get("like_count"),
+        "comments": info.get("comment_count"),
+        "duration": info.get("duration"),
+        "thumbnail": info.get("thumbnail"),
+    }
+
+    return values.get(name)