allocine 0.1.0a0__py3-none-any.whl

allocine/__init__.py

@@ -0,0 +1,56 @@
+"""Top-level package for Allociné."""
+
+from importlib.metadata import version as _distribution_version
+
+from allocine.api import AllocineApi
+from allocine.client import DEFAULT_DATE_FORMAT, Allocine
+from allocine.models import (
+    Movie,
+    MovieVersion,
+    Schedule,
+    Showtime,
+    Theater,
+    day_str,
+    get_french_month,
+    get_hour_short_str,
+    short_day_str,
+    to_french_short_weekday,
+    to_french_weekday,
+)
+from allocine.schedules import (
+    build_program_str,
+    build_weekly_schedule_str,
+    check_schedules_within_week,
+    create_weekdays_str,
+    get_available_dates,
+    get_showtimes_of_a_day,
+    group_showtimes_per_schedule,
+)
+
+__author__ = "Thibault Ducret"
+__email__ = "hello@tducret.com"
+__version__ = _distribution_version("allocine")
+
+__all__ = [
+    "Allocine",
+    "AllocineApi",
+    "DEFAULT_DATE_FORMAT",
+    "Movie",
+    "MovieVersion",
+    "Schedule",
+    "Showtime",
+    "Theater",
+    "build_program_str",
+    "build_weekly_schedule_str",
+    "check_schedules_within_week",
+    "create_weekdays_str",
+    "day_str",
+    "get_available_dates",
+    "get_french_month",
+    "get_hour_short_str",
+    "get_showtimes_of_a_day",
+    "group_showtimes_per_schedule",
+    "short_day_str",
+    "to_french_short_weekday",
+    "to_french_weekday",
+]

allocine/api.py

@@ -0,0 +1,132 @@
+from datetime import date as Date
+from os import PathLike
+
+import backoff
+import httpx2
+
+from allocine.cache import CACHE_MISS, CachedResponse, CacheOption, HttpCache
+
+SHOWTIMES_BASE_URL = "https://www.allocine.fr/_/showtimes"
+THEATERS_BASE_URL = "https://www.allocine.fr/salle/cinema"
+
+
+class AllocineApi:
+    """Client to process requests with the Allocine APIs."""
+
+    def __init__(
+        self,
+        *,
+        cache: CacheOption = False,
+        cache_dir: str | PathLike[str] | None = None,
+    ):
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Macintosh; \
+                                   Intel Mac OS X 10.14; rv:63.0) \
+                                   Gecko/20100101 Firefox/63.0",
+        }
+        self.session = httpx2.Client(headers=headers, timeout=30)
+        self.cache = HttpCache(cache, cache_dir)
+
+    def get_showtimelist_by_theater_id(
+        self,
+        theater_id: str,
+        page: int | None = None,
+        date: Date | None = None,
+    ):
+        url = f"{SHOWTIMES_BASE_URL}/theater-{theater_id}/"
+        if date:
+            url += f"d-{date.isoformat()}/"
+        if page:
+            url += f"p-{page}/"
+
+        response = self._request(url, 200, not_found_ok=True)
+        if response.status_code == 404:
+            return {"results": []}
+        return response.json()
+
+    def get_showtimes_by_movie_and_theater_id(
+        self,
+        movie_id: int,
+        theater_id: str,
+    ):
+        url = f"{SHOWTIMES_BASE_URL}/ope/movie-{movie_id}/theater-{theater_id}/"
+        return self._get(url)
+
+    def get_theater_page(self, theater_id: str) -> str:
+        url = f"https://www.allocine.fr/seance/salle_gen_csalle={theater_id}.html"
+        return self._get_text(url)
+
+    def get_theaterlist_by_geocode(self, geocode: int | str, page: int = 1) -> str:
+        url = f"{THEATERS_BASE_URL}/ville-{geocode}/"
+        params = {"page": page} if page > 1 else None
+        return self._get_text(url, params=params)
+
+    def clear_cache(self) -> int:
+        return self.cache.clear()
+
+    def close(self) -> None:
+        self.session.close()
+        self.cache.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def _get(self, url: str, expected_status: int = 200, *args, **kwargs) -> dict:
+        return self._request(url, expected_status, *args, **kwargs).json()
+
+    def _get_text(self, url: str, expected_status: int = 200, *args, **kwargs) -> str:
+        return self._request(url, expected_status, *args, **kwargs).text
+
+    def _request(
+        self,
+        url: str,
+        expected_status: int,
+        *args,
+        not_found_ok: bool = False,
+        **kwargs,
+    ) -> httpx2.Response:
+        params = kwargs.get("params")
+        cached = self.cache.get(url, params)
+        if cached is not CACHE_MISS and cached.is_fresh():
+            return cached.to_response()
+
+        if cached is not CACHE_MISS:
+            headers = dict(kwargs.get("headers") or {})
+            if etag := cached.headers.get("etag"):
+                headers["If-None-Match"] = etag
+            if last_modified := cached.headers.get("last-modified"):
+                headers["If-Modified-Since"] = last_modified
+            kwargs["headers"] = headers
+
+        try:
+            response = self._fetch(url, expected_status, *args, not_found_ok=not_found_ok, **kwargs)
+        except (ValueError, httpx2.HTTPError):
+            if cached is not CACHE_MISS and cached.can_serve_on_error():
+                return cached.to_response()
+            raise
+
+        if response.status_code == 304 and cached is not CACHE_MISS:
+            response = self._revalidated_response(cached, response)
+        self.cache.set(url, response, params)
+        return response
+
+    @backoff.on_exception(backoff.expo, ValueError, max_tries=5, max_time=30)
+    def _fetch(
+        self,
+        url: str,
+        expected_status: int,
+        *args,
+        not_found_ok: bool = False,
+        **kwargs,
+    ) -> httpx2.Response:
+        ret = self.session.get(url, *args, **kwargs)
+        if ret.status_code not in {expected_status, 304} and not (not_found_ok and ret.status_code == 404):
+            raise ValueError("{!r} : expected status {}, received {}".format(url, expected_status, ret.status_code))
+        return ret
+
+    @staticmethod
+    def _revalidated_response(cached: CachedResponse, response: httpx2.Response) -> httpx2.Response:
+        return cached.to_response(response.headers)

allocine/cache.py

@@ -0,0 +1,134 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from os import PathLike
+from time import time
+from urllib.parse import urlencode
+from weakref import finalize
+
+import httpx2
+from diskcache import Cache
+from platformdirs import user_cache_path
+
+CACHE_VERSION = 3
+CACHE_MISS = object()
+
+CacheOption = bool | Cache
+
+
+@dataclass(frozen=True)
+class CachedResponse:
+    status_code: int
+    headers: dict[str, str]
+    content: bytes
+    stored_at: float
+    initial_age: int
+    max_age: int
+    stale_if_error: int
+    stale_while_revalidate: int
+
+    def age(self, now: float | None = None) -> float:
+        return self.initial_age + (time() if now is None else now) - self.stored_at
+
+    def is_fresh(self, now: float | None = None) -> bool:
+        return self.age(now) < self.max_age
+
+    def can_serve_on_error(self, now: float | None = None) -> bool:
+        return self.age(now) < self.max_age + self.stale_if_error
+
+    def retention(self) -> float:
+        stale = max(self.stale_if_error, self.stale_while_revalidate)
+        return self.max_age + stale - self.initial_age
+
+    def to_response(self, revalidation_headers: Mapping[str, str] | None = None) -> httpx2.Response:
+        headers = dict(self.headers)
+        if revalidation_headers is not None:
+            headers.pop("age", None)
+            headers.update(revalidation_headers)
+        return httpx2.Response(self.status_code, headers=_decoded_headers(headers), content=self.content)
+
+
+class HttpCache:
+    def __init__(
+        self,
+        cache: CacheOption = False,
+        cache_dir: str | PathLike[str] | None = None,
+    ) -> None:
+        if cache_dir is not None and cache is not True:
+            raise ValueError("cache_dir can only be used when cache=True")
+
+        self._owns_backend = cache is True
+        self._backend = (
+            Cache(cache_dir or user_cache_path("allocine")) if cache is True else None if cache is False else cache
+        )
+        self._finalizer = (
+            finalize(self, self._backend.close) if self._owns_backend and self._backend is not None else None
+        )
+
+    def get(self, url: str, params: dict | None = None):
+        if self._backend is None:
+            return CACHE_MISS
+        return self._backend.get(self._key(url, params), default=CACHE_MISS)
+
+    def set(self, url: str, response: httpx2.Response, params: dict | None = None) -> None:
+        if self._backend is None or (cached := _to_cached_response(response)) is None:
+            return
+        if (retention := cached.retention()) > 0:
+            self._backend.set(self._key(url, params), cached, expire=retention)
+
+    def clear(self) -> int:
+        return self._backend.clear() if self._backend is not None else 0
+
+    def close(self) -> None:
+        if self._finalizer is not None:
+            self._finalizer()
+
+    @staticmethod
+    def _key(url: str, params: dict | None) -> str:
+        query = urlencode(sorted((params or {}).items()), doseq=True)
+        return f"http:v{CACHE_VERSION}:{url}?{query}"
+
+
+def _to_cached_response(response: httpx2.Response) -> CachedResponse | None:
+    directives = _parse_cache_control(response.headers.get("cache-control", ""))
+    if "public" not in directives or "no-store" in directives or "private" in directives:
+        return None
+    if (max_age := _seconds(directives, "max-age")) is None:
+        return None
+
+    return CachedResponse(
+        status_code=response.status_code,
+        headers=_decoded_headers(response.headers),
+        content=response.content,
+        stored_at=time(),
+        initial_age=_header_seconds(response.headers.get("age")) or 0,
+        max_age=max_age,
+        stale_if_error=_seconds(directives, "stale-if-error") or 0,
+        stale_while_revalidate=_seconds(directives, "stale-while-revalidate") or 0,
+    )
+
+
+def _parse_cache_control(value: str) -> dict[str, str | None]:
+    directives = {}
+    for item in value.split(","):
+        name, separator, directive_value = item.strip().partition("=")
+        if name:
+            directives[name.lower()] = directive_value.strip('"') if separator else None
+    return directives
+
+
+def _decoded_headers(headers: Mapping[str, str]) -> dict[str, str]:
+    decoded_headers = dict(headers)
+    for name in ("content-encoding", "content-length", "transfer-encoding"):
+        decoded_headers.pop(name, None)
+    return decoded_headers
+
+
+def _seconds(directives: dict[str, str | None], name: str) -> int | None:
+    return _header_seconds(directives.get(name))
+
+
+def _header_seconds(value: str | None) -> int | None:
+    try:
+        return max(0, int(value)) if value is not None else None
+    except ValueError:
+        return None

allocine/cli.py

@@ -0,0 +1,159 @@
+"""Command-line interface for Allociné showtimes."""
+
+from datetime import date, datetime, timedelta
+
+import click
+from prettytable import ALL, FRAME, UNICODE, PrettyTable
+
+from allocine.client import Allocine
+from allocine.schedules import get_showtimes_of_a_day
+
+
+def clear_cache(ctx, param, value):
+    if not value or ctx.resilient_parsing:
+        return
+    with Allocine(cache=True) as allocine:
+        removed = allocine.clear_cache()
+    click.echo(f"Cache vidé ({removed} entrée(s)).")
+    ctx.exit()
+
+
+def extract_field_names(dict_list):
+    """Return a sorted list of field names from a dictionary list."""
+    field_names = []
+    for row_dict in dict_list:
+        field_names += row_dict.keys()
+    field_names = list(set(field_names))
+    return sorted(field_names)
+
+
+@click.command()
+@click.argument("id_cinema", type=str, required=True)
+@click.option(
+    "--clear-cache",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=clear_cache,
+    help="vide entièrement le cache et quitte",
+)
+@click.option(
+    "--jour",
+    "-j",
+    type=str,
+    help="jour des séances souhaitées \
+(au format DD/MM/YYYY ou +1 pour demain), par défaut : aujourd’hui",
+)
+@click.option(
+    "--semaine",
+    "-s",
+    is_flag=True,
+    help="affiche les séance pour les 7 prochains jours",
+)
+@click.option(
+    "--entrelignes",
+    "-e",
+    is_flag=True,
+    help="ajoute une ligne entre chaque film pour améliorer la lisibilité",
+)
+def main(id_cinema, entrelignes, jour=None, semaine=None):
+    """
+    Les séances de votre cinéma dans le terminal, avec
+    ID_CINEMA : identifiant du cinéma sur Allociné,
+    ex: C0159 pour l’UGC Ciné Cité Les Halles. Se trouve dans l’url :
+    http://allocine.fr/seance/salle_gen_csalle=<ID_CINEMA>.html
+    """
+    today = date.today()
+    allocine = Allocine(cache=True)
+
+    jours = []
+    if semaine is False:
+        if jour is None:
+            jours.append(today.strftime("%d/%m/%Y"))
+        elif jour[0] == "+":
+            delta_jours = int(jour[1:])
+            jour_obj = today + timedelta(days=delta_jours)
+            jours.append(jour_obj.strftime("%d/%m/%Y"))
+        else:
+            jours.append(jour)
+    else:
+        for delta in range(0, 7):
+            jour_obj = today + timedelta(days=delta)
+            jours.append(jour_obj.strftime("%d/%m/%Y"))
+
+    requested_dates = [datetime.strptime(jour, "%d/%m/%Y").date() for jour in jours]
+    showtimes = allocine.get_showtimes(
+        theater_id=id_cinema,
+        from_date=min(requested_dates),
+        to_date=max(requested_dates),
+    )
+    try:
+        theater = allocine.get_theater(theater_id=id_cinema)
+    except ValueError as error:
+        raise click.ClickException(str(error)) from None
+
+    print("{}, le ".format(theater.name), end="")
+    for jour in jours:
+        print(get_showtime_table(showtimes=showtimes, entrelignes=entrelignes, jour=jour))
+        print()
+
+
+def get_showtime_table(showtimes, entrelignes, jour):
+    showtime_table = []
+
+    date_obj = datetime.strptime(jour, "%d/%m/%Y").date()
+    day_showtimes = get_showtimes_of_a_day(showtimes, date=date_obj)
+    movies_available_today = set(showtime.movie for showtime in day_showtimes)
+
+    for movie_version in movies_available_today:
+        title = movie_version.title
+        if len(title) >= 31:  # On tronque les titres trop longs
+            title = title[:31] + "..."
+
+        # '*1_film' pour être sûr que cela soit la 1ère colonne
+        movie_row = {"*1_film": "{} ({}) - {}".format(title, movie_version.version, movie_version.duration_str)}
+
+        movie_row["*2_note"] = "{}*".format(movie_version.rating_str)
+
+        for showtime in day_showtimes:
+            if showtime.movie != movie_version:
+                continue
+            hour = showtime.hour_str.split(":")[0]  # 11:15 => 11
+            movie_row[hour] = showtime.hour_str
+
+        showtime_table.append(movie_row)
+
+    seances = showtime_table
+
+    retour = "{}\n".format(jour)
+
+    if len(seances) <= 0:
+        retour += "Aucune séance"
+
+    else:
+        table = PrettyTable()
+        table.set_style(UNICODE)
+        table.header = False
+
+        if entrelignes is True:
+            table.hrules = ALL
+        else:
+            table.hrules = FRAME
+
+        table.field_names = extract_field_names(seances)
+
+        for seances_film in seances:
+            row = []
+            for field_name in table.field_names:
+                row.append(seances_film.get(field_name, ""))
+            table.add_row(row)
+
+        table.align["*1_film"] = "l"
+        table.sortby = "*1_film"
+        retour += str(table)
+
+    return retour
+
+
+if __name__ == "__main__":
+    main()