finalising the Querries and the rest

data_sources/tmdb_source.py

@@ -7,7 +7,6 @@ import urllib.request
 from datetime import date
 
 TMDB_API_BASE = "https://api.themoviedb.org/3"
-TMDB_ANIME_KEYWORD_ID = "210024"
 
 
 def parse_release_date(value: str) -> date | None:
@@ -21,7 +20,10 @@ def parse_release_date(value: str) -> date | None:
 
 
 def tmdb_get_json(path: str, params: dict, token: str) -> dict:
-    url = TMDB_API_BASE + path + "?" + urllib.parse.urlencode(params)
+    url = TMDB_API_BASE + path
+    if params:
+        url += "?" + urllib.parse.urlencode(params)
+
     req = urllib.request.Request(
         url,
         headers={
@@ -30,89 +32,74 @@ def tmdb_get_json(path: str, params: dict, token: str) -> dict:
             "User-Agent": "anime-movies-script/1.0",
         },
     )
+
     with urllib.request.urlopen(req, timeout=20) as resp:
         return json.loads(resp.read().decode("utf-8"))
 
 
-def poster_url(path: str) -> str:
-    text = (path or "").strip()
-    if not text:
-        return ""
-    return "https://image.tmdb.org/t/p/w780" + text
-
-
-def fetch_genre_map(token: str, language: str = "de-DE") -> dict[int, str]:
-    payload = tmdb_get_json("/genre/movie/list", {"language": language}, token)
-    result = {}
-    for entry in payload.get("genres", []):
-        try:
-            gid = int(entry.get("id"))
-        except Exception:
-            continue
-        name = (entry.get("name") or "").strip()
-        if name:
-            result[gid] = name
-    return result
-
-
-def fetch_tmdb_anime_movies(start_date: date, end_date: date, token: str, language: str = "de-DE") -> list[dict]:
-    if not token:
+def search_tmdb_movies(title: str, token: str, language: str = "en-US") -> list[dict]:
+    query = (title or "").strip()
+    if not query:
         return []
 
-    genre_map = fetch_genre_map(token, language=language)
-    page = 1
-    results = []
-    seen_ids = set()
-
-    while True:
-        params = {
+    payload = tmdb_get_json(
+        "/search/movie",
+        {
+            "query": query,
             "include_adult": "false",
-            "include_video": "false",
             "language": language,
-            "sort_by": "primary_release_date.desc",
-            "primary_release_date.gte": start_date.isoformat(),
-            "primary_release_date.lte": end_date.isoformat(),
-            "with_keywords": TMDB_ANIME_KEYWORD_ID,
-            "page": str(page),
-        }
-        payload = tmdb_get_json("/discover/movie", params, token)
-        page_results = payload.get("results", [])
-        if not page_results:
-            break
+            "page": "1",
+        },
+        token,
+    )
 
-        for movie in page_results:
-            movie_id = movie.get("id")
-            if movie_id in seen_ids:
-                continue
+    results = []
+    for item in payload.get("results", []):
+        movie_id = item.get("id")
+        if not movie_id:
+            continue
 
-            release_date = parse_release_date(str(movie.get("release_date") or ""))
-            if not release_date:
-                continue
-
-            seen_ids.add(movie_id)
-            genre_names = [genre_map.get(gid, "") for gid in (movie.get("genre_ids") or [])]
-            genre_names = [name for name in genre_names if name]
-
-            results.append(
-                {
-                    "tmdb_id": movie_id,
-                    "title": (movie.get("title") or "").strip(),
-                    "original_title": (movie.get("original_title") or "").strip(),
-                    "overview": (movie.get("overview") or "").strip(),
-                    "release_date": release_date,
-                    "genres": genre_names,
-                    "genres_text": ", ".join(genre_names),
-                    "poster_url": poster_url(str(movie.get("poster_path") or "")),
-                    "popularity": movie.get("popularity"),
-                    "vote_average": movie.get("vote_average"),
-                    "vote_count": movie.get("vote_count"),
-                    "raw": movie,
-                }
-            )
-
-        total_pages = int(payload.get("total_pages") or page)
-        if page >= total_pages:
-            break
-        page += 1
+        results.append(
+            {
+                "tmdb_id": int(movie_id),
+                "title": (item.get("title") or "").strip(),
+                "original_title": (item.get("original_title") or "").strip(),
+                "release_date": parse_release_date(str(item.get("release_date") or "")),
+            }
+        )
 
     return results
+
+
+def fetch_tmdb_release_dates(movie_id: int, token: str) -> dict:
+    return tmdb_get_json(f"/movie/{movie_id}/release_dates", {}, token)
+
+
+def extract_de_theatrical_dates(release_payload: dict) -> list[date]:
+    german_block = None
+    for result in release_payload.get("results", []):
+        if str(result.get("iso_3166_1") or "").upper() == "DE":
+            german_block = result
+            break
+
+    if not german_block:
+        return []
+
+    dates = []
+    for entry in german_block.get("release_dates", []):
+        release_type = int(entry.get("type") or 0)
+        if release_type not in {2, 3}:
+            continue
+
+        release_date = parse_release_date(str(entry.get("release_date") or ""))
+        if release_date:
+            dates.append(release_date)
+
+    return sorted(dates)
+
+
+def select_release_in_range(release_dates: list[date], start_date: date, end_date: date) -> date | None:
+    for release_date in sorted(release_dates):
+        if start_date <= release_date <= end_date:
+            return release_date
+    return None