vidsrc-dlp 0.1.0__tar.gz

vidsrc_dlp-0.1.0/.env.example

@@ -0,0 +1,3 @@
+TMDB_API_KEY=your_api_key_here
+MOVIES_DIR=./downloads/movies
+TV_DIR=./downloads/tv

vidsrc_dlp-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include .env.example

vidsrc_dlp-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: vidsrc-dlp
+Version: 0.1.0
+Summary: CLI to search TMDB, resolve VidSrc streams, and download via yt-dlp
+Author: Jeevan
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jeevan/vidsrc-dlp
+Project-URL: Source, https://github.com/jeevan/vidsrc-dlp
+Project-URL: BugTracker, https://github.com/jeevan/vidsrc-dlp/issues
+Keywords: vidsrc,tmdb,yt-dlp,video,downloader
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: yt-dlp>=2024.0.0
+
+# vidsrc-dlp
+
+Search TMDB, resolve a playable HLS stream via VidSrc's 4-hop chain, and download via yt-dlp.
+
+## Install
+
+```bash
+pip install vidsrc-dlp
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+Or for local development:
+
+```bash
+git clone https://github.com/jeevan/vidsrc-dlp
+cd vidsrc-dlp
+python -m venv .venv && source .venv/bin/activate
+pip install -e .
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+## Usage
+
+```bash
+# Movies
+moviefinder "Inception"
+moviefinder "The Matrix" --year 1999
+moviefinder "Interstellar" --quality 1080p --no-confirm --verbose
+
+# TV Shows
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1
+moviefinder "Severance" --type tv --season 2 --episode 5
+
+# Test with main.py (no install needed)
+python main.py "Inception"
+```
+
+## Output paths
+
+Configure in `.env` or override via CLI:
+
+```
+MOVIES_DIR=./downloads/movies
+TV_DIR=./downloads/tv
+```
+
+```bash
+moviefinder "Inception" --movies-dir "/Volumes/Media/Movies"
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1 --tv-dir "/Volumes/Media/TV"
+```
+
+## Naming convention
+
+```
+Movies:  {MOVIES_DIR}/Inception (2010)/Inception (2010).mp4
+TV:      {TV_DIR}/Breaking Bad/Season 01/Breaking Bad - S01E01 - Pilot.mp4
+```
+
+## Architecture
+
+1. **TMDB** — search API for movie/TV metadata
+2. **VidSrc Resolver** — `requests`-only 4-hop chain to extract an HLS URL
+3. **Downloader** — `yt-dlp` + ffmpeg to download and transcode to MP4
+
+## How the resolver works
+
+```
+vidsrc.to/embed/{movie|tv}/{tmdb_id}[/{season}/{episode}]
+  → vsembed.ru iframe (parse src attr)
+    → cloudorchestranova.com/rcp/{hash} (parse prorcp hash)
+      → cloudorchestranova.com/prorcp/{hash} (m3u8 URLs with __TOKEN__ placeholders)
+        → generate.php endpoints (JWT tokens)
+          → final m3u8 URL
+```
+
+## Adding a new stream provider
+
+Implement `StreamProvider` from `moviefinder.utils`.
+
+## Acknowledgements
+
+- **[MaheshSharan/vidsrc](https://github.com/MaheshSharan/vidsrc)** — The request-based 4-hop resolution chain was reverse-engineered from this open-source PHP scraper. Critical reference for the VidSrc token flow.
+- **[TMDB](https://www.themoviedb.org/)** — Movie and TV metadata API. All search, detail, episode info sourced from their free tier.
+- **[yt-dlp](https://github.com/yt-dlp/yt-dlp)** — The download engine. Handles HLS fragment fetching, decryption, and ffmpeg transcoding.
+- **[requests](https://github.com/psf/requests)** — HTTP library for the resolver chain.
+- **[python-dotenv](https://github.com/theskumar/python-dotenv)** — Environment variable loading from `.env`.

vidsrc_dlp-0.1.0/README.md

@@ -0,0 +1,86 @@
+# vidsrc-dlp
+
+Search TMDB, resolve a playable HLS stream via VidSrc's 4-hop chain, and download via yt-dlp.
+
+## Install
+
+```bash
+pip install vidsrc-dlp
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+Or for local development:
+
+```bash
+git clone https://github.com/jeevan/vidsrc-dlp
+cd vidsrc-dlp
+python -m venv .venv && source .venv/bin/activate
+pip install -e .
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+## Usage
+
+```bash
+# Movies
+moviefinder "Inception"
+moviefinder "The Matrix" --year 1999
+moviefinder "Interstellar" --quality 1080p --no-confirm --verbose
+
+# TV Shows
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1
+moviefinder "Severance" --type tv --season 2 --episode 5
+
+# Test with main.py (no install needed)
+python main.py "Inception"
+```
+
+## Output paths
+
+Configure in `.env` or override via CLI:
+
+```
+MOVIES_DIR=./downloads/movies
+TV_DIR=./downloads/tv
+```
+
+```bash
+moviefinder "Inception" --movies-dir "/Volumes/Media/Movies"
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1 --tv-dir "/Volumes/Media/TV"
+```
+
+## Naming convention
+
+```
+Movies:  {MOVIES_DIR}/Inception (2010)/Inception (2010).mp4
+TV:      {TV_DIR}/Breaking Bad/Season 01/Breaking Bad - S01E01 - Pilot.mp4
+```
+
+## Architecture
+
+1. **TMDB** — search API for movie/TV metadata
+2. **VidSrc Resolver** — `requests`-only 4-hop chain to extract an HLS URL
+3. **Downloader** — `yt-dlp` + ffmpeg to download and transcode to MP4
+
+## How the resolver works
+
+```
+vidsrc.to/embed/{movie|tv}/{tmdb_id}[/{season}/{episode}]
+  → vsembed.ru iframe (parse src attr)
+    → cloudorchestranova.com/rcp/{hash} (parse prorcp hash)
+      → cloudorchestranova.com/prorcp/{hash} (m3u8 URLs with __TOKEN__ placeholders)
+        → generate.php endpoints (JWT tokens)
+          → final m3u8 URL
+```
+
+## Adding a new stream provider
+
+Implement `StreamProvider` from `moviefinder.utils`.
+
+## Acknowledgements
+
+- **[MaheshSharan/vidsrc](https://github.com/MaheshSharan/vidsrc)** — The request-based 4-hop resolution chain was reverse-engineered from this open-source PHP scraper. Critical reference for the VidSrc token flow.
+- **[TMDB](https://www.themoviedb.org/)** — Movie and TV metadata API. All search, detail, episode info sourced from their free tier.
+- **[yt-dlp](https://github.com/yt-dlp/yt-dlp)** — The download engine. Handles HLS fragment fetching, decryption, and ffmpeg transcoding.
+- **[requests](https://github.com/psf/requests)** — HTTP library for the resolver chain.
+- **[python-dotenv](https://github.com/theskumar/python-dotenv)** — Environment variable loading from `.env`.

vidsrc_dlp-0.1.0/moviefinder/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

vidsrc_dlp-0.1.0/moviefinder/cli.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+import logging
+
+from moviefinder.config import load_config
+from moviefinder.downloader import VideoDownloader
+from moviefinder.resolver import VidSrcResolver
+from moviefinder.tmdb import TMDBClient
+from moviefinder.utils import MediaType, setup_logging
+
+logger = logging.getLogger("moviefinder.cli")
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="moviefinder",
+        description="Search TMDB, resolve stream, and download movies & TV shows.",
+    )
+    parser.add_argument("query", nargs="?", help="Movie or TV show title to search for")
+    parser.add_argument("--type", choices=["movie", "tv"], default="movie", help="Media type")
+    parser.add_argument("--season", type=int, help="Season number (for TV)")
+    parser.add_argument("--episode", type=int, help="Episode number (for TV)")
+    parser.add_argument("--year", type=int, help="Filter by release year")
+    parser.add_argument("--quality", default="best", help="Quality (e.g. 1080p, 720p, best)")
+    parser.add_argument("--movies-dir", help="Override movies output directory")
+    parser.add_argument("--tv-dir", help="Override TV output directory")
+    parser.add_argument("--no-confirm", action="store_true", help="Skip confirmation prompt")
+    parser.add_argument("--verbose", action="store_true", help="Enable debug logging")
+    parser.add_argument("--verbose-ytdlp", action="store_true", help="Show yt-dlp output")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+
+    if args.query is None:
+        print("usage: moviefinder <title> [options]")
+        print()
+        print("Movies:")
+        print('  moviefinder "Inception"')
+        print('  moviefinder "The Matrix" --year 1999')
+        print()
+        print("TV:")
+        print('  moviefinder "Breaking Bad" --type tv --season 1 --episode 1')
+        raise SystemExit(1)
+
+    setup_logging(args.verbose)
+
+    if args.type == "tv":
+        if args.season is None or args.episode is None:
+            logger.error("--season and --episode are required for TV shows")
+            raise SystemExit(1)
+
+    config = load_config(
+        movies_dir=args.movies_dir,
+        tv_dir=args.tv_dir,
+        quality=args.quality,
+        no_confirm=args.no_confirm,
+    )
+
+    tmdb = TMDBClient(api_key=config.tmdb_api_key)
+    media_type = MediaType.TV if args.type == "tv" else MediaType.MOVIE
+    search_fn = tmdb.search_tv if args.type == "tv" else tmdb.search_movie
+    detail_fn = tmdb.get_tv_details if args.type == "tv" else tmdb.get_movie_details
+
+    results = search_fn(args.query, year=args.year)
+    if not results:
+        logger.error("No %s found for: %s", args.type, args.query)
+        raise SystemExit(1)
+
+    best = results[0]
+    logger.info("Found: %s", _format_media_info(best))
+
+    # Enrich with full details
+    detailed = detail_fn(best.id)
+    if detailed:
+        best = detailed
+
+    # Fetch episode title for TV
+    if args.type == "tv":
+        ep_title = tmdb.get_episode_title(best.id, args.season, args.episode)
+        best.season = args.season
+        best.episode = args.episode
+        best.episode_title = ep_title if ep_title else None
+        best.media_type = MediaType.TV
+
+    logger.info(
+        "Metadata: %s",
+        _format_metadata(best),
+    )
+
+    if not args.no_confirm:
+        label = (
+            f"{best.title} S{best.season:02d}E{best.episode:02d}"
+            if best.media_type == MediaType.TV
+            else best.title
+        )
+        answer = input(f"Download '{label}'? [Y/n] ").strip().lower()
+        if answer and answer not in ("y", "yes", ""):
+            logger.info("Skipped.")
+            return
+
+    resolver = VidSrcResolver()
+    stream = resolver.resolve(
+        best.id,
+        media_type=args.type,
+        season=best.season,
+        episode=best.episode,
+    )
+    if stream is None:
+        logger.error("No stream available for %s", best.title)
+        raise SystemExit(1)
+
+    logger.info("Stream URL: %s", stream.url[:100])
+
+    downloader = VideoDownloader(config)
+    success = downloader.download(stream, best)
+    raise SystemExit(0 if success else 1)
+
+
+def _format_media_info(media) -> str:
+    parts = [media.title]
+    if media.year:
+        parts.append(f"({media.year})")
+    return " ".join(parts)
+
+
+def _format_metadata(media) -> str:
+    parts = []
+    if media.imdb_id:
+        parts.append(f"IMDb: {media.imdb_id}")
+    if media.vote_average:
+        parts.append(f"Rating: {media.vote_average:.1f}/10")
+    if media.year:
+        parts.append(f"Year: {media.year}")
+    if media.genres:
+        parts.append(f"Genres: {', '.join(media.genres[:3])}")
+    if media.media_type == MediaType.TV and media.episode_title:
+        parts.append(f"Episode: {media.episode_title}")
+    return " | ".join(parts)

vidsrc_dlp-0.1.0/moviefinder/config.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+@dataclass
+class Config:
+    tmdb_api_key: str
+    movies_dir: Path
+    tv_dir: Path
+    quality: str = "best"
+    no_confirm: bool = False
+
+
+def load_config(
+    movies_dir: str | None = None,
+    tv_dir: str | None = None,
+    quality: str | None = None,
+    no_confirm: bool = False,
+) -> Config:
+    load_dotenv()
+
+    api_key = os.getenv("TMDB_API_KEY")
+    if not api_key:
+        raise ValueError(
+            "TMDB_API_KEY not found in .env file. "
+            "Create a .env file with TMDB_API_KEY=your_key_here"
+        )
+
+    default_downloads = Path.cwd() / "downloads"
+
+    resolved_movies = (
+        Path(movies_dir)
+        if movies_dir
+        else Path(os.getenv("MOVIES_DIR", str(default_downloads / "movies")))
+    )
+    resolved_tv = (
+        Path(tv_dir)
+        if tv_dir
+        else Path(os.getenv("TV_DIR", str(default_downloads / "tv")))
+    )
+
+    return Config(
+        tmdb_api_key=api_key,
+        movies_dir=resolved_movies,
+        tv_dir=resolved_tv,
+        quality=quality or "best",
+        no_confirm=no_confirm,
+    )

vidsrc_dlp-0.1.0/moviefinder/downloader.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+import yt_dlp
+
+from moviefinder.config import Config
+from moviefinder.utils import Media, MediaType, StreamInfo
+
+logger = logging.getLogger("moviefinder.downloader")
+
+
+@dataclass
+class VideoDownloader:
+    config: Config
+
+    def download(self, stream: StreamInfo, media: Media) -> bool:
+        if media.media_type == MediaType.TV:
+            output_dir, filename = self._tv_path(media)
+        else:
+            output_dir, filename = self._movie_path(media)
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        output_template = str(output_dir / f"{filename}.%(ext)s")
+
+        ydl_opts: dict = {
+            "format": self._build_format_spec(),
+            "outtmpl": output_template,
+            "merge_output_format": "mp4",
+            "http_headers": {
+                "User-Agent": stream.headers.get(
+                    "User-Agent",
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                ),
+                "Referer": stream.referer or stream.url,
+            },
+            "postprocessors": [
+                {
+                    "key": "FFmpegVideoConvertor",
+                    "preferedformat": "mp4",
+                }
+            ],
+            "progress_hooks": [self._progress_hook],
+            "quiet": True,
+            "no_warnings": True,
+            "extractor_retries": 3,
+            "fragment_retries": 5,
+            "retries": 5,
+            "ignoreerrors": False,
+        }
+
+        try:
+            logger.info("Downloading %s", filename)
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                ydl.download([stream.url])
+            logger.info("Download complete: %s", filename)
+            return True
+        except yt_dlp.utils.DownloadError as e:
+            logger.error("Download failed: %s", e)
+            return False
+        except Exception as e:
+            logger.error("Unexpected error: %s", e)
+            return False
+
+    def _movie_path(self, media: Media) -> tuple[Path, str]:
+        label = self._media_label(media)
+        folder = self.config.movies_dir / label
+        return folder, label
+
+    def _tv_path(self, media: Media) -> tuple[Path, str]:
+        show_dir = self.config.tv_dir / self._safe_filename(media.title)
+        season_dir = show_dir / f"Season {media.season or 1}"
+        ep = media.episode or 1
+        parts = [
+            self._safe_filename(media.title),
+            f"S{media.season or 1:02d}E{ep:02d}",
+        ]
+        if media.episode_title:
+            parts.append(self._safe_filename(media.episode_title))
+        filename = " - ".join(parts)
+        return season_dir, filename
+
+    def _media_label(self, media: Media) -> str:
+        title = self._safe_filename(media.title)
+        if media.year:
+            return f"{title} ({media.year})"
+        return title
+
+    def _build_format_spec(self) -> str:
+        quality = self.config.quality
+        if quality == "best":
+            return "bestvideo+bestaudio/best"
+        try:
+            height = quality.replace("p", "").strip()
+            int(height)
+            return f"bestvideo[height<={height}]+bestaudio/best[height<={height}]/best"
+        except ValueError:
+            return "bestvideo+bestaudio/best"
+
+    @staticmethod
+    def _progress_hook(d: dict) -> None:
+        if d["status"] == "downloading":
+            total = d.get("total_bytes") or d.get("total_bytes_estimate", 0)
+            downloaded = d.get("downloaded_bytes", 0)
+            if total > 0:
+                logger.info("Progress: %.1f%%", downloaded / total * 100)
+        elif d["status"] == "finished":
+            logger.info("Post-processing...")
+
+    @staticmethod
+    def _safe_filename(title: str) -> str:
+        return "".join(c if c.isalnum() or c in " ._-" else "_" for c in title).strip()

vidsrc_dlp-0.1.0/moviefinder/resolver.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import logging
+import re
+import time
+from dataclasses import dataclass
+
+import requests
+
+from moviefinder.utils import StreamInfo, StreamProvider
+
+logger = logging.getLogger("moviefinder.resolver")
+
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+}
+
+
+@dataclass
+class VidSrcResolver(StreamProvider):
+    base_domain: str = "vidsrc.to"
+    request_delay: float = 0.3
+    timeout: int = 30
+
+    def resolve(
+        self,
+        tmdb_id: int,
+        media_type: str = "movie",
+        season: int | None = None,
+        episode: int | None = None,
+    ) -> StreamInfo | None:
+        logger.info(
+            "Resolving TMDB ID %d (%s) via %s", tmdb_id, media_type, self.base_domain
+        )
+        try:
+            return self._resolve(tmdb_id, media_type, season, episode)
+        except Exception as e:
+            logger.error("Resolution failed: %s", e)
+            return None
+
+    def _resolve(
+        self,
+        tmdb_id: int,
+        media_type: str,
+        season: int | None,
+        episode: int | None,
+    ) -> StreamInfo | None:
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        if media_type == "tv" and season is not None and episode is not None:
+            embed_url = (
+                f"https://{self.base_domain}/embed/tv/{tmdb_id}/{season}/{episode}"
+            )
+        else:
+            embed_url = f"https://{self.base_domain}/embed/movie/{tmdb_id}"
+
+        r1 = session.get(embed_url, timeout=15)
+        vsembed_url = self._extract_vsembed(r1.text, embed_url)
+        if not vsembed_url:
+            logger.error("No vsembed iframe found on %s", embed_url)
+            return None
+        logger.info("Step 1: %s", vsembed_url)
+        time.sleep(self.request_delay)
+
+        r2 = session.get(vsembed_url, headers={"Referer": embed_url}, timeout=15)
+        hashes = re.findall(r'data-hash=["\']([A-Za-z0-9+/=_-]+)["\']', r2.text)
+        if not hashes:
+            logger.error("No data-hash found on vsembed")
+            return None
+        logger.info("Step 2: %d source hash(es) found", len(hashes))
+        time.sleep(self.request_delay)
+
+        for i, h in enumerate(hashes):
+            logger.debug("Trying source %d/%d", i + 1, len(hashes))
+            result = self._resolve_source(session, h, vsembed_url)
+            if result:
+                logger.info("Stream resolved from source %d", i + 1)
+                return result
+            time.sleep(self.request_delay)
+
+        logger.error("All %d sources failed", len(hashes))
+        return None
+
+    def _resolve_source(
+        self, session: requests.Session, rcp_hash: str, referer: str
+    ) -> StreamInfo | None:
+        rcp_url = f"https://cloudorchestranova.com/rcp/{rcp_hash}"
+        r3 = session.get(rcp_url, headers={"Referer": referer}, timeout=self.timeout)
+        if r3.status_code != 200:
+            logger.warning("RCP request failed: %d", r3.status_code)
+            return None
+
+        prorcp = re.search(r"prorcp/([A-Za-z0-9+/=_-]+)", r3.text)
+        if not prorcp:
+            logger.warning("No prorcp hash in RCP response")
+            return None
+        logger.debug("Step 3: prorcp hash found")
+        time.sleep(self.request_delay)
+
+        prorcp_url = f"https://cloudorchestranova.com/prorcp/{prorcp.group(1)}"
+        r4 = session.get(
+            prorcp_url, headers={"Referer": rcp_url}, timeout=self.timeout
+        )
+        if r4.status_code != 200:
+            logger.warning("prorcp request failed: %d", r4.status_code)
+            return None
+
+        m3u8_urls = re.findall(r"https?://[^\"' ]+\.m3u8[^\"' ]*", r4.text)
+        if not m3u8_urls:
+            logger.warning("No m3u8 URLs in prorcp response")
+            return None
+        logger.debug("Step 4: %d raw m3u8 URL(s) found", len(m3u8_urls))
+        time.sleep(self.request_delay)
+
+        token_main = self._fetch_token(
+            session, "https://peregrinepalaver.space/generate.php", rcp_url
+        )
+        token_pg = self._fetch_token(
+            session, "https://app2.putgate.com/generate.php", rcp_url
+        )
+        logger.debug("Step 5: tokens resolved")
+
+        for raw_url in m3u8_urls:
+            resolved = raw_url
+            if token_main:
+                resolved = resolved.replace("__TOKEN__", token_main)
+            if token_pg:
+                resolved = resolved.replace("__TOKENPG__", token_pg)
+            if "{v" not in resolved:
+                return StreamInfo(
+                    url=resolved,
+                    headers={"User-Agent": HEADERS["User-Agent"]},
+                    referer="https://cloudorchestranova.com/",
+                    stream_type="hls",
+                )
+
+        logger.warning("All m3u8 URLs had unresolved placeholders")
+        return None
+
+    @staticmethod
+    def _extract_vsembed(html: str, page_url: str) -> str | None:
+        src = re.search(r'src=["\']([^"\']*vsembed[^"\']*)["\']', html)
+        if not src:
+            src = re.search(r'src=["\']([^"\']*embed[^"\']*)["\']', html)
+        if not src:
+            return None
+        url = src.group(1)
+        if url.startswith("//"):
+            url = "https:" + url
+        return url
+
+    @staticmethod
+    def _fetch_token(
+        session: requests.Session, url: str, referer: str
+    ) -> str | None:
+        try:
+            r = session.get(url, headers={"Referer": referer}, timeout=10)
+            if r.status_code == 200 and r.text.strip():
+                return r.text.strip()
+        except requests.RequestException:
+            pass
+        return None

vidsrc_dlp-0.1.0/moviefinder/tmdb.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import logging
+
+import requests
+
+from moviefinder.utils import Media, MediaType
+
+logger = logging.getLogger("moviefinder.tmdb")
+
+
+class TMDBClient:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://api.themoviedb.org/3"
+
+    def search_movie(self, query: str, year: int | None = None) -> list[Media]:
+        params = {"api_key": self.api_key, "query": query.strip(), "language": "en-US"}
+        if year:
+            params["primary_release_year"] = year
+        return self._search("search/movie", params, MediaType.MOVIE)
+
+    def search_tv(self, query: str, year: int | None = None) -> list[Media]:
+        params = {"api_key": self.api_key, "query": query.strip(), "language": "en-US"}
+        if year:
+            params["first_air_date_year"] = year
+        return self._search("search/tv", params, MediaType.TV)
+
+    def _search(
+        self, endpoint: str, params: dict, media_type: MediaType
+    ) -> list[Media]:
+        try:
+            r = requests.get(
+                f"{self.base_url}/{endpoint}", params=params, timeout=10
+            )
+            r.raise_for_status()
+            data = r.json()
+        except requests.RequestException as e:
+            logger.error("TMDB search request failed: %s", e)
+            return []
+
+        results = data.get("results", [])
+        if not results:
+            logger.info("No TMDB results for %s", params.get("query"))
+            return []
+
+        items = []
+        for m in results:
+            date_field = "release_date" if media_type == MediaType.MOVIE else "first_air_date"
+            raw_date = m.get(date_field, "") or ""
+            year_val = _parse_year(raw_date)
+            items.append(
+                Media(
+                    id=m["id"],
+                    title=m.get("title" if media_type == MediaType.MOVIE else "name", "Unknown"),
+                    media_type=media_type,
+                    year=year_val,
+                    release_date=raw_date,
+                    overview=m.get("overview", "") or "",
+                    vote_average=m.get("vote_average"),
+                    poster_path=m.get("poster_path"),
+                )
+            )
+
+        logger.info(
+            "TMDB %s search for '%s': %d results",
+            media_type.value,
+            params.get("query"),
+            len(items),
+        )
+        return items
+
+    def get_movie_details(self, tmdb_id: int) -> Media | None:
+        return self._get_details(f"movie/{tmdb_id}", MediaType.MOVIE)
+
+    def get_tv_details(self, tmdb_id: int) -> Media | None:
+        return self._get_details(f"tv/{tmdb_id}", MediaType.TV)
+
+    def _get_details(self, endpoint: str, media_type: MediaType) -> Media | None:
+        params = {"api_key": self.api_key, "language": "en-US"}
+        try:
+            r = requests.get(
+                f"{self.base_url}/{endpoint}", params=params, timeout=10
+            )
+            r.raise_for_status()
+            d = r.json()
+        except requests.RequestException as e:
+            logger.error("TMDB detail request failed: %s", e)
+            return None
+
+        date_field = "release_date" if media_type == MediaType.MOVIE else "first_air_date"
+        raw_date = d.get(date_field, "") or ""
+        year_val = _parse_year(raw_date)
+        title_key = "title" if media_type == MediaType.MOVIE else "name"
+
+        genre_names = [g["name"] for g in d.get("genres", []) if "name" in g]
+
+        media = Media(
+            id=d["id"],
+            title=d.get(title_key, "Unknown"),
+            media_type=media_type,
+            year=year_val,
+            release_date=raw_date,
+            overview=d.get("overview", "") or "",
+            genres=genre_names,
+            vote_average=d.get("vote_average"),
+            poster_path=d.get("poster_path"),
+        )
+
+        # Fetch external IDs for IMDb
+        try:
+            ext = requests.get(
+                f"{self.base_url}/{endpoint}/external_ids",
+                params={"api_key": self.api_key},
+                timeout=10,
+            ).json()
+            media.imdb_id = ext.get("imdb_id")
+        except requests.RequestException:
+            pass
+
+        return media
+
+    def get_episode_title(self, tmdb_id: int, season: int, episode: int) -> str | None:
+        try:
+            r = requests.get(
+                f"{self.base_url}/tv/{tmdb_id}/season/{season}/episode/{episode}",
+                params={"api_key": self.api_key, "language": "en-US"},
+                timeout=10,
+            )
+            r.raise_for_status()
+            return r.json().get("name")
+        except requests.RequestException as e:
+            logger.debug("Could not fetch episode title: %s", e)
+            return None
+
+
+def _parse_year(date_str: str) -> int | None:
+    if date_str and len(date_str) >= 4:
+        try:
+            return int(date_str[:4])
+        except ValueError:
+            return None
+    return None

vidsrc_dlp-0.1.0/moviefinder/utils.py

@@ -0,0 +1,55 @@
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class MediaType(Enum):
+    MOVIE = "movie"
+    TV = "tv"
+
+
+@dataclass
+class Media:
+    id: int
+    title: str
+    media_type: MediaType = MediaType.MOVIE
+    year: int | None = None
+    release_date: str = ""
+    overview: str = ""
+    season: int | None = None
+    episode: int | None = None
+    episode_title: str | None = None
+    imdb_id: str | None = None
+    genres: list[str] = field(default_factory=list)
+    vote_average: float | None = None
+    poster_path: str | None = None
+
+
+@dataclass
+class StreamInfo:
+    url: str
+    headers: dict[str, str] = field(default_factory=dict)
+    referer: str = ""
+    stream_type: str = "hls"
+
+
+class StreamProvider(ABC):
+    @abstractmethod
+    def resolve(
+        self,
+        tmdb_id: int,
+        media_type: str = "movie",
+        season: int | None = None,
+        episode: int | None = None,
+    ) -> StreamInfo | None:
+        ...
+
+
+def setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("[%(levelname)s] %(name)s: %(message)s"))
+    root = logging.getLogger("moviefinder")
+    root.setLevel(level)
+    root.addHandler(handler)

vidsrc_dlp-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vidsrc-dlp"
+version = "0.1.0"
+description = "CLI to search TMDB, resolve VidSrc streams, and download via yt-dlp"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Jeevan" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: End Users/Desktop",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Video",
+]
+keywords = ["vidsrc", "tmdb", "yt-dlp", "video", "downloader"]
+dependencies = [
+    "python-dotenv>=1.0.0",
+    "requests>=2.31.0",
+    "yt-dlp>=2024.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/jeevan/vidsrc-dlp"
+Source = "https://github.com/jeevan/vidsrc-dlp"
+BugTracker = "https://github.com/jeevan/vidsrc-dlp/issues"
+
+[project.scripts]
+moviefinder = "moviefinder.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["moviefinder*"]

vidsrc_dlp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: vidsrc-dlp
+Version: 0.1.0
+Summary: CLI to search TMDB, resolve VidSrc streams, and download via yt-dlp
+Author: Jeevan
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jeevan/vidsrc-dlp
+Project-URL: Source, https://github.com/jeevan/vidsrc-dlp
+Project-URL: BugTracker, https://github.com/jeevan/vidsrc-dlp/issues
+Keywords: vidsrc,tmdb,yt-dlp,video,downloader
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: yt-dlp>=2024.0.0
+
+# vidsrc-dlp
+
+Search TMDB, resolve a playable HLS stream via VidSrc's 4-hop chain, and download via yt-dlp.
+
+## Install
+
+```bash
+pip install vidsrc-dlp
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+Or for local development:
+
+```bash
+git clone https://github.com/jeevan/vidsrc-dlp
+cd vidsrc-dlp
+python -m venv .venv && source .venv/bin/activate
+pip install -e .
+cp .env.example .env  # add your TMDB_API_KEY
+```
+
+## Usage
+
+```bash
+# Movies
+moviefinder "Inception"
+moviefinder "The Matrix" --year 1999
+moviefinder "Interstellar" --quality 1080p --no-confirm --verbose
+
+# TV Shows
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1
+moviefinder "Severance" --type tv --season 2 --episode 5
+
+# Test with main.py (no install needed)
+python main.py "Inception"
+```
+
+## Output paths
+
+Configure in `.env` or override via CLI:
+
+```
+MOVIES_DIR=./downloads/movies
+TV_DIR=./downloads/tv
+```
+
+```bash
+moviefinder "Inception" --movies-dir "/Volumes/Media/Movies"
+moviefinder "Breaking Bad" --type tv --season 1 --episode 1 --tv-dir "/Volumes/Media/TV"
+```
+
+## Naming convention
+
+```
+Movies:  {MOVIES_DIR}/Inception (2010)/Inception (2010).mp4
+TV:      {TV_DIR}/Breaking Bad/Season 01/Breaking Bad - S01E01 - Pilot.mp4
+```
+
+## Architecture
+
+1. **TMDB** — search API for movie/TV metadata
+2. **VidSrc Resolver** — `requests`-only 4-hop chain to extract an HLS URL
+3. **Downloader** — `yt-dlp` + ffmpeg to download and transcode to MP4
+
+## How the resolver works
+
+```
+vidsrc.to/embed/{movie|tv}/{tmdb_id}[/{season}/{episode}]
+  → vsembed.ru iframe (parse src attr)
+    → cloudorchestranova.com/rcp/{hash} (parse prorcp hash)
+      → cloudorchestranova.com/prorcp/{hash} (m3u8 URLs with __TOKEN__ placeholders)
+        → generate.php endpoints (JWT tokens)
+          → final m3u8 URL
+```
+
+## Adding a new stream provider
+
+Implement `StreamProvider` from `moviefinder.utils`.
+
+## Acknowledgements
+
+- **[MaheshSharan/vidsrc](https://github.com/MaheshSharan/vidsrc)** — The request-based 4-hop resolution chain was reverse-engineered from this open-source PHP scraper. Critical reference for the VidSrc token flow.
+- **[TMDB](https://www.themoviedb.org/)** — Movie and TV metadata API. All search, detail, episode info sourced from their free tier.
+- **[yt-dlp](https://github.com/yt-dlp/yt-dlp)** — The download engine. Handles HLS fragment fetching, decryption, and ffmpeg transcoding.
+- **[requests](https://github.com/psf/requests)** — HTTP library for the resolver chain.
+- **[python-dotenv](https://github.com/theskumar/python-dotenv)** — Environment variable loading from `.env`.

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+.env.example
+MANIFEST.in
+README.md
+pyproject.toml
+moviefinder/__init__.py
+moviefinder/cli.py
+moviefinder/config.py
+moviefinder/downloader.py
+moviefinder/resolver.py
+moviefinder/tmdb.py
+moviefinder/utils.py
+vidsrc_dlp.egg-info/PKG-INFO
+vidsrc_dlp.egg-info/SOURCES.txt
+vidsrc_dlp.egg-info/dependency_links.txt
+vidsrc_dlp.egg-info/entry_points.txt
+vidsrc_dlp.egg-info/requires.txt
+vidsrc_dlp.egg-info/top_level.txt

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/entry_points.txt

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

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/requires.txt

@@ -0,0 +1,3 @@
+python-dotenv>=1.0.0
+requests>=2.31.0
+yt-dlp>=2024.0.0

vidsrc_dlp-0.1.0/vidsrc_dlp.egg-info/top_level.txt

@@ -0,0 +1 @@
+moviefinder