allocine 0.1.0__py3-none-any.whl

allocine/client.py

@@ -0,0 +1,241 @@
+import json
+import re
+import unicodedata
+from datetime import date as Date
+from datetime import datetime, timedelta
+from os import PathLike
+
+import jmespath
+from parsel import Selector
+
+from allocine.api import AllocineApi
+from allocine.cache import CacheOption
+from allocine.models import MovieVersion, Showtime, Theater
+
+DEFAULT_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S"
+
+
+class Allocine:
+    def __init__(
+        self,
+        *,
+        cache: CacheOption = True,
+        cache_dir: str | PathLike[str] | None = None,
+    ):
+        self._client = AllocineApi(cache=cache, cache_dir=cache_dir)
+
+    def get_theater(self, theater_id: str) -> Theater:
+        resp = self._client.get_showtimelist_by_theater_id(theater_id=theater_id)
+        if not resp.get("results"):
+            raise ValueError(f"Theater not found. Is theater id {theater_id!r} correct?")
+
+        movie_id: int | None = jmespath.search("results[0].movie.internalId", resp)
+        assert movie_id is not None, "We need at least one showtime to get details about a theater"
+
+        return self._get_theater_details_from_movie_id(theater_id, movie_id)
+
+    def get_showtimes(
+        self,
+        theater_id: str,
+        from_date: Date | None = None,
+        to_date: Date | None = None,
+    ) -> list[Showtime]:
+        today = Date.today()
+        from_date = max(from_date or today, today)
+        to_date = to_date or from_date
+        if from_date > to_date:
+            raise ValueError("from_date must be before or equal to to_date")
+
+        showtimes = []
+        requested_date = from_date
+        while requested_date <= to_date:
+            response = self._client.get_showtimelist_by_theater_id(
+                theater_id=theater_id,
+                date=requested_date,
+            )
+            day_showtimes = self._parse_showtimes(response.get("results") or [])
+            for page in range(2, (jmespath.search("pagination.totalPages", response) or 1) + 1):
+                response = self._client.get_showtimelist_by_theater_id(
+                    theater_id=theater_id,
+                    date=requested_date,
+                    page=page,
+                )
+                day_showtimes.extend(self._parse_showtimes(response.get("results") or []))
+
+            showtimes.extend(showtime for showtime in day_showtimes if showtime.date == requested_date)
+            requested_date += timedelta(days=1)
+
+        return showtimes
+
+    def search_theaters(self, geocode: int | str) -> list[Theater]:
+        theaters = []
+        page = 1
+        while True:
+            selector = Selector(text=self._client.get_theaterlist_by_geocode(geocode=geocode, page=page))
+            theaters.extend(_parse_theaters(selector))
+            if not selector.css(".button-right:not(.button-disabled)"):
+                return theaters
+            page += 1
+
+    def clear_cache(self) -> int:
+        return self._client.clear_cache()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def _get_theater_details_from_movie_id(self, theater_id: str, movie_id: int) -> Theater:
+        operation = self._client.get_showtimes_by_movie_and_theater_id(
+            movie_id=movie_id,
+            theater_id=theater_id,
+        )
+        raw_theater = operation["results"]["theater"]
+        if raw_theater is None:
+            return self._get_theater_details_from_page(theater_id)
+
+        location = raw_theater["location"]
+        return Theater(
+            theater_id=raw_theater["internalId"],
+            name=raw_theater["name"],
+            address=location["address"],
+            zipcode=location["zip"],
+            city=location["city"],
+        )
+
+    def _get_theater_details_from_page(self, theater_id: str) -> Theater:
+        selector = Selector(text=self._client.get_theater_page(theater_id))
+        for raw_data in selector.css('script[type="application/ld+json"]::text').getall():
+            theater_data = json.loads(raw_data)
+            if theater_data.get("@type") != "MovieTheater":
+                continue
+
+            address = theater_data.get("address") or {}
+            return Theater(
+                theater_id=theater_id,
+                name=theater_data["name"],
+                address=address.get("streetAddress") or "",
+                zipcode=address.get("postalCode") or "",
+                city=address.get("addressLocality") or "",
+            )
+
+        raise ValueError(f"Theater details not found for theater id {theater_id!r}")
+
+    def _parse_showtimes(self, raw_showtimes: list[dict]):
+        showtimes = []
+        for showtime_data in raw_showtimes:
+            raw_movie = showtime_data.get("movie")
+            if not raw_movie:
+                continue
+            duration_match = re.fullmatch(r"(?:(\d+)h)?\s*(?:(\d+)min)?", raw_movie.get("runtime") or "")
+            duration_obj = None
+            if duration_match and any(duration_match.groups()):
+                hours, minutes = duration_match.groups(default="0")
+                duration_obj = timedelta(hours=int(hours), minutes=int(minutes))
+
+            rating = jmespath.search("stats.userRating.score", raw_movie)
+            try:
+                rating = float(rating)
+            except (ValueError, TypeError):
+                rating = None
+
+            countries = [country.get("localizedName") for country in raw_movie.get("countries") or []]
+            countries = [country for country in countries if country]
+            if year := jmespath.search("data.productionYear", raw_movie):
+                year = int(year)
+
+            directors = []
+            for credit in sorted(raw_movie.get("credits") or [], key=lambda item: item.get("rank") or 0):
+                if jmespath.search("position.name", credit) == "DIRECTOR":
+                    if name := _person_name(credit.get("person")):
+                        directors.append(name)
+
+            actors = []
+            cast = jmespath.search("cast.nodes", raw_movie) or []
+            for cast_member in sorted(cast, key=lambda item: item.get("rank") or 0):
+                person = (
+                    cast_member.get("actor") or cast_member.get("originalVoiceActor") or cast_member.get("voiceActor")
+                )
+                if name := _person_name(person):
+                    actors.append(name)
+
+            genres = ", ".join(genre["translate"] for genre in raw_movie.get("genres") or [] if genre.get("translate"))
+            for showtime_group in (showtime_data.get("showtimes") or {}).values():
+                for raw_showtime in showtime_group:
+                    tags = raw_showtime.get("tags") or []
+                    language = (
+                        "Français"
+                        if "Localization.Language.French" in tags
+                        or raw_showtime.get("diffusionVersion") in {"DUBBED", "LOCAL"}
+                        else "Version originale"
+                    )
+                    screen_formats = [
+                        {"E_4DX": "4DX", "PLF": "PLF"}.get(value, value)
+                        for value in raw_showtime.get("experience") or []
+                    ]
+                    screen_formats.extend(
+                        {"DIGITAL": "Numérique", "IMAX": "IMAX", "F_3D": "3D"}.get(value, value)
+                        for value in raw_showtime.get("projection") or []
+                        if value != "DIGITAL" or not screen_formats
+                    )
+
+                    if synopsis := raw_movie.get("synopsis"):
+                        synopsis = re.sub(r"<.*?>", "", synopsis)
+                        synopsis = synopsis.replace("\xa0", " ")  # Remove HTML tags (ex: <span>)
+                        synopsis = unicodedata.normalize("NFKD", synopsis)
+
+                    movie = MovieVersion(
+                        movie_id=raw_movie["internalId"],
+                        title=raw_movie.get("title"),
+                        rating=rating,
+                        language=language,
+                        screen_format=" ".join(screen_formats) or "Numérique",
+                        synopsis=synopsis,
+                        original_title=raw_movie.get("originalTitle"),
+                        year=year,
+                        countries=countries,
+                        genres=genres,
+                        directors=", ".join(directors),
+                        actors=", ".join(actors),
+                        duration=duration_obj,
+                    )
+                    showtimes.append(
+                        Showtime(
+                            date_time=datetime.strptime(raw_showtime["startsAt"], DEFAULT_DATE_FORMAT),
+                            movie=movie,
+                        )
+                    )
+        return showtimes
+
+
+def _person_name(person):
+    if not person:
+        return None
+    return " ".join(part for part in (person.get("firstName"), person.get("lastName")) if part)
+
+
+def _parse_theaters(selector: Selector) -> list[Theater]:
+    theaters = []
+    for card in selector.css("div.theater-card"):
+        theater_json = card.css(".add-theater-anchor[data-theater]::attr(data-theater)").get()
+        if not theater_json:
+            continue
+
+        theater_data = json.loads(theater_json)
+        full_address = " ".join((card.css("address.address").xpath("string()").get() or "").split())
+        address_match = re.fullmatch(r"(.*)\s+(\d{5})\s+(.+)", full_address)
+        address, zipcode, city = address_match.groups() if address_match else (full_address, "", "")
+        theaters.append(
+            Theater(
+                theater_id=theater_data["id"],
+                name=theater_data["name"],
+                address=address,
+                zipcode=zipcode,
+                city=city,
+            )
+        )
+    return theaters

allocine/models.py

@@ -0,0 +1,233 @@
+import logging
+import unicodedata
+from dataclasses import dataclass
+from datetime import date as Date
+from datetime import datetime, timedelta
+from datetime import time as Time
+from typing import List, Optional
+
+from allocine import nationalities
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Movie:
+    movie_id: int
+    title: str
+    original_title: str
+    rating: Optional[float]
+    duration: Optional[timedelta]
+    genres: str
+    countries: List[str]
+    directors: str
+    actors: str
+    synopsis: str
+    year: int
+
+    @property
+    def duration_str(self):
+        if self.duration is not None:
+            return _strfdelta(self.duration, "{hours:02d}h{minutes:02d}")
+        else:
+            return "HH:MM"
+
+    @property
+    def duration_short_str(self) -> str:
+        if self.duration is not None:
+            return _strfdelta(self.duration, "{hours:d}h{minutes:02d}")
+        else:
+            return "NA"
+
+    @property
+    def rating_str(self):
+        return "{0:.1f}".format(self.rating) if self.rating else ""
+
+    @property
+    def nationalities(self):
+        """Return the nationality tuples, from the movie countries.
+        Example: if self.countries = ['France'] => [('français', 'française')]
+        """
+        if self.countries:
+            nationality_tuples = []
+            for country_name in self.countries:
+                normalized_country_name = _strip_accents(country_name).lower()
+                country_code = nationalities.countries.get(normalized_country_name)
+
+                if country_code is not None:
+                    nationality_tuples.append(nationalities.nationalities[country_code])
+                else:
+                    logger.warning(f"Country {country_name!r} not found in nationalities")
+                    nationality_tuples.append((f"de {country_name}", f"de {country_name}"))
+            return nationality_tuples
+        else:
+            return None
+
+    def __str__(self):
+        return f"{self.title} [{self.movie_id}] ({self.duration_str})"
+
+    def __eq__(self, other):
+        return (self.movie_id) == (other.movie_id)
+
+    def __hash__(self):
+        """This function allows us
+        to do a set(list_of_Movie_objects)"""
+        return hash(self.movie_id)
+
+
+@dataclass
+class MovieVersion(Movie):
+    language: str
+    screen_format: str
+
+    @property
+    def version(self):
+        version = "VF" if self.language == "Français" else "VOST"
+        if self.screen_format != "Numérique":
+            version += f" {self.screen_format}"
+        return version
+
+    def get_movie(self):
+        return Movie(
+            movie_id=self.movie_id,
+            title=self.title,
+            rating=self.rating,
+            duration=self.duration,
+            original_title=self.original_title,
+            year=self.year,
+            genres=self.genres,
+            countries=self.countries,
+            directors=self.directors,
+            actors=self.actors,
+            synopsis=self.synopsis,
+        )
+
+    def __str__(self):
+        movie_str = super().__str__()
+        return f"{movie_str} ({self.version})"
+
+    def __eq__(self, other):
+        return (self.movie_id, self.version) == (other.movie_id, other.version)
+
+    def __hash__(self):
+        """This function allows us
+        to do a set(list_of_MovieVersion_objects)"""
+        return hash((self.movie_id, self.version))
+
+
+@dataclass
+class Schedule:
+    date_time: datetime
+
+    @property
+    def date(self) -> Date:
+        return self.date_time.date()
+
+    @property
+    def hour(self) -> Time:
+        return self.date_time.time()
+
+    @property
+    def hour_str(self) -> str:
+        return self.date_time.strftime("%H:%M")
+
+    @property
+    def hour_short_str(self) -> str:
+        return get_hour_short_str(self.hour)
+
+    @property
+    def date_str(self) -> str:
+        return self.date_time.strftime("%d/%m/%Y %H:%M")
+
+    @property
+    def day_str(self) -> str:
+        return day_str(self.date)
+
+    @property
+    def short_day_str(self) -> str:
+        return short_day_str(self.date)
+
+
+def get_hour_short_str(hour: Time) -> str:
+    # Ex: 9h, 11h, 23h30
+    # Minus in '%-H' removes the leading 0
+    return hour.strftime("%-Hh%M").replace("h00", "h")
+
+
+@dataclass
+class Showtime(Schedule):
+    movie: MovieVersion
+
+    def __str__(self):
+        return f"{self.date_str} : {self.movie}"
+
+
+def day_str(date: Date) -> str:
+    return to_french_weekday(date.weekday())
+
+
+def to_french_weekday(weekday: int) -> str:
+    days = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]
+    return days[weekday]
+
+
+def get_french_month(month_number: int) -> str:
+    months = [
+        "Janvier",
+        "Février",
+        "Mars",
+        "Avril",
+        "Mai",
+        "Juin",
+        "Juillet",
+        "Août",
+        "Septembre",
+        "Octobre",
+        "Novembre",
+        "Décembre",
+    ]
+    return months[month_number - 1]
+
+
+def to_french_short_weekday(weekday: int) -> str:
+    return to_french_weekday(weekday)[:3]
+
+
+def short_day_str(date: Date) -> str:
+    return day_str(date)[:3]
+
+
+@dataclass
+class Theater:
+    theater_id: str
+    name: str
+    address: str
+    zipcode: str
+    city: str
+
+    @property
+    def address_str(self):
+        address_str = f"{self.address}, " if self.address else ""
+        address_str += f"{self.zipcode} {self.city}"
+        return address_str
+
+    def __eq__(self, other):
+        return (self.theater_id) == (other.theater_id)
+
+    def __hash__(self):
+        """This function allows us to do a set(list_of_Theaters_objects)"""
+        return hash(self.theater_id)
+
+
+def _strfdelta(tdelta, fmt):
+    """Format a timedelta object"""
+    # Thanks to https://stackoverflow.com/questions/8906926
+    d = {"days": tdelta.days}
+    d["hours"], rem = divmod(tdelta.seconds, 3600)
+    d["minutes"], d["seconds"] = divmod(rem, 60)
+    return fmt.format(**d)
+
+
+def _strip_accents(s):
+    # https://stackoverflow.com/a/518232/8748757
+    return "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")