Svensk Filmdatabas APIsvenskfilmdatabas.se ↗

"""
Svensk Filmdatabas - Films in Production API Client
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional


class ParseClient:
    """Client for the Svensk Filmdatabas Films in Production API."""

    def __init__(self, api_key: Optional[str] = None):
        """Initialize the Parse API client."""
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "4f6f74e6-f5b8-4c24-8bf0-bfe4162f3568"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError("API key must be provided or set in PARSE_API_KEY environment variable")

    def _call(self, endpoint: str, method: str = "POST", **params) -> dict:
        """
        Make a request to the Parse API.

        Args:
            endpoint: The API endpoint name
            method: HTTP method (GET or POST)
            **params: Query or body parameters

        Returns:
            dict: The API response
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}

        if method.upper() == "GET":
            response = requests.get(url, headers=headers, params=params)
        else:
            response = requests.post(url, headers=headers, json=params)

        response.raise_for_status()
        return response.json()

    def list_films_in_production(
        self,
        page: int = 1,
        sort_by: str = "chrono_desc",
        film_type: Optional[str] = None,
        country: Optional[str] = None,
    ) -> dict:
        """
        List Swedish films currently in production.

        Args:
            page: Page number for pagination (15 items per page)
            sort_by: Sort order - chrono_desc, chrono_asc, alpha_asc, alpha_desc
            film_type: Filter by film type - Kortfilm or Långfilm
            country: Filter by production country

        Returns:
            dict: Paginated list of films with metadata
        """
        params = {"page": page, "sort_by": sort_by}
        if film_type:
            params["film_type"] = film_type
        if country:
            params["country"] = country

        return self._call("list_films_in_production", method="GET", **params)

    def get_film_details(self, film_id: str) -> dict:
        """
        Get detailed information about a specific film.

        Args:
            film_id: Numeric film ID

        Returns:
            dict: Detailed film information including cast and production facts
        """
        return self._call("get_film_details", method="GET", film_id=film_id)


def main():
    """Demonstrate practical usage of the Films in Production API."""
    client = ParseClient()

    print("=" * 60)
    print("SVENSKA FILMDATABAS - FILMS IN PRODUCTION")
    print("=" * 60)

    # Step 1: List films in production - get Swedish long films, sorted alphabetically
    print("\n1. Fetching Swedish long films (Långfilm) sorted alphabetically...")
    response = client.list_films_in_production(page=1, sort_by="alpha_asc", film_type="Långfilm", country="Sverige")

    total_films = response["total_count"]
    films_on_page = len(response["items"])

    print(f"\n   Total Swedish long films in production: {total_films}")
    print(f"   Films on this page: {films_on_page}")
    print(f"   Available film types: {', '.join(response['available_film_types'])}")

    # Step 2: Display first few films from the list
    print("\n2. First 5 films on the list:")
    print("-" * 60)

    films_to_detail = response["items"][:5]

    for i, film in enumerate(films_to_detail, 1):
        print(f"\n   {i}. {film['title']}")
        print(f"      Type: {film['film_type']}")
        print(f"      Meta: {film['meta']}")
        print(f"      ID: {film['id']}")

    # Step 3: Get detailed information for the first film
    if films_to_detail:
        first_film_id = films_to_detail[0]["id"]
        first_film_title = films_to_detail[0]["title"]

        print("\n3. Fetching detailed information for the first film...")
        print(f"   Film: {first_film_title}")
        print("-" * 60)

        details = client.get_film_details(first_film_id)

        print(f"\n   Original Title: {details.get('original_title', 'N/A')}")
        print(f"   Year: {details.get('year', 'N/A')}")
        print(f"   Category: {details.get('category', 'N/A')}")
        print(f"   Director: {details.get('director', 'N/A')}")
        print(f"   Producer: {details.get('producer', 'N/A')}")
        print(f"   Screenplay: {details.get('screenplay', 'N/A')}")
        print(f"   Production Country: {details.get('production_country', 'N/A')}")
        print(f"   Production Company: {details.get('production_company', 'N/A')}")

        # Display cast if available
        if details.get("cast"):
            print(f"\n   Cast ({len(details['cast'])} members):")
            for cast_member in details["cast"][:5]:  # Show first 5 cast members
                print(f"      - {cast_member['name']} as {cast_member['role']}")
            if len(details["cast"]) > 5:
                print(f"      ... and {len(details['cast']) - 5} more")

    # Step 4: Show summary statistics
    print("\n4. Summary Statistics:")
    print("-" * 60)

    # Get short films count for comparison
    short_films = client.list_films_in_production(page=1, film_type="Kortfilm")
    short_count = short_films["total_count"]

    print(f"\n   Total Swedish Long Films (Långfilm): {total_films}")
    print(f"   Total Swedish Short Films (Kortfilm): {short_count}")
    print(f"   Grand Total: {total_films + short_count}")

    print("\n" + "=" * 60)
    print("API exploration complete!")
    print("=" * 60)


if __name__ == "__main__":
    main()