diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..efa407c --- /dev/null +++ b/.gitignore @@ -0,0 +1,162 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ \ No newline at end of file diff --git a/README.md b/README.md index a26ea28..4fe8921 100644 --- a/README.md +++ b/README.md @@ -4,11 +4,13 @@ A small website that compares and presents overlapping items between two people' This was made with the intention of helping people find something to watch together. -This is running at https://anilist.abstractumbra.dev/, you must provide two usernames within the path to query, like so: -https://anilist.abstractumbra.dev/AbstractUmbra/OtherUmbra +This is running at https://anilist.abstractumbra.dev/, you must provide at least two usernames within the path to query, like so: +https://anilist.abstractumbra.dev/AbstractUmbra/OtherUmbra/etc... By default this will compare entries in the "Planning" category. -You can also add a query parameter to further refine what category you wish to see! +You can add a `status` query parameter to further refine what category you wish to see! + +You can also pass one (or more) `exclude` query parameters to exclude a column. The `?status=` parameter accepts the following values:- ``` @@ -20,6 +22,14 @@ paused repeating ``` +The `?exclude=` parameter accepts the following values:- +``` +romaji +english +native +``` + + ## Running your own The provided docker-compose file should work on it's own, otherwise just clone the repository and install the necessary dependencies and run the `main.py` with a Python version >= 3.11 diff --git a/anilist-cmp/__init__.py b/anilist-cmp/__init__.py index bc7e4e7..e7aadd2 100644 --- a/anilist-cmp/__init__.py +++ b/anilist-cmp/__init__.py @@ -1,7 +1,9 @@ from __future__ import annotations +from functools import reduce +from operator import or_, and_ from enum import Enum -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Sequence import httpx from litestar import Litestar, MediaType, Response, get, status_codes @@ -10,39 +12,28 @@ if TYPE_CHECKING: from .types_.responses import AnilistError, AnilistErrorResponse, AnilistResponse, InnerMediaEntry, MediaEntry +USER_QUERY = """ +user{number}: MediaListCollection(userName: $username{number}, status: $status, type: ANIME) {{ + lists {{ + entries {{ + media {{ + id + title {{ + romaji + english + native + }} + siteUrl + }} + }} + }} +}} +""" + QUERY = """ -query ($username1: String, $username2: String, $status: MediaListStatus) { - user1: MediaListCollection(userName: $username1, status: $status, type: ANIME) { - lists { - entries { - media { - id - title { - romaji - english - native - } - siteUrl - } - } - } - } - user2: MediaListCollection(userName: $username2, status: $status, type: ANIME) { - lists { - entries { - media { - id - title { - romaji - english - native - } - siteUrl - } - } - } - } -} +query ({parameters}, $status: MediaListStatus) {{ + {subqueries} +}} """ OPENGRAPH_HEAD = """ @@ -51,38 +42,36 @@ Hi - - + + """ +HEADINGS = ["romaji", "english", "native"] + TABLE = """ - - - +{included} -{body} +{{body}}
Media IDRomajiEnglishJapaneseURL
""" ROW = """ -{id} -{title[romaji]} -{title[english]} -{title[native]} -Anilist +{{id}} +{included} +Anilist """ @@ -102,19 +91,22 @@ class Status(Enum): repeating = "REPEATING" -def format_entries_as_table(entries: dict[int, InnerMediaEntry]) -> str: - rows = [ROW.format_map(entry) for entry in entries.values()] - return TABLE.format(body="\n".join(rows)) +def format_entries_as_table(entries: dict[int, InnerMediaEntry], excluded: list[str]) -> str: + included = "\n".join(f"{{title[{h}]}}" for h in HEADINGS if h not in excluded) + rows = [ROW.format(included=included).format_map(entry) for entry in entries.values()] + formatted_headings = "\n".join(f"{h.title()}" for h in HEADINGS if h not in excluded) + return TABLE.format(included=formatted_headings).format(body="\n".join(rows)) async def _fetch_user_entries(*usernames: str, status: Status) -> AnilistResponse | AnilistErrorResponse: - username1, username2 = usernames + parameters = ", ".join(f"$username{n}: String" for n in range(len(usernames))) + subqueries = "".join(USER_QUERY.format(number=n) for n in range(len(usernames))) + variables = {f"username{n}": name for n, name in enumerate(usernames)} + variables.update(status=status.value) + query = QUERY.format(parameters=parameters, subqueries=subqueries) async with httpx.AsyncClient() as session: - resp = await session.post( - "https://graphql.anilist.co", - json={"query": QUERY, "variables": {"username1": username1, "username2": username2, "status": status.value}}, - ) + resp = await session.post("https://graphql.anilist.co", json={"query": query, "variables": variables}) return resp.json() @@ -124,37 +116,46 @@ def _restructure_entries(entries: list[MediaEntry]) -> dict[int, InnerMediaEntry def _get_common_planning(data: AnilistResponse) -> dict[int, InnerMediaEntry]: - user1_data = data["data"]["user1"]["lists"] - user2_data = data["data"]["user2"]["lists"] - if not user1_data: - raise NoPlanningData(1) - elif not user2_data: - raise NoPlanningData(2) + media_entries: list[dict[int, InnerMediaEntry]] = [] + + for index, item in enumerate(data["data"].values()): + if not item: + raise NoPlanningData(index) - user1_entries = _restructure_entries(user1_data[0]["entries"]) - user2_entries = _restructure_entries(user2_data[0]["entries"]) + media_entries.append(_restructure_entries(item["lists"][0]["entries"])) - all_anime = user1_entries | user2_entries - common_anime = user1_entries.keys() & user2_entries.keys() + all_anime: dict[int, InnerMediaEntry] = reduce(or_, media_entries) + common_anime: set[int] = reduce(and_, map(lambda d: d.keys(), media_entries)) return {id_: all_anime[id_] for id_ in common_anime} -def _handle_errors(errors: list[AnilistError], user1: str, user2: str) -> list[str]: +def _handle_errors(errors: list[AnilistError], *users: str) -> list[str]: missing_users: list[str] = [] for error in errors: if error["message"] == "User not found" and error["status"] == 404: for location in error["locations"]: - print(location, flush=True) - if location["line"] == 3: - missing_users.append(user1) - elif location["line"] == 18: - missing_users.append(user2) - + line = location["line"] - 4 + index = line // len(USER_QUERY.splitlines()) + missing_users.append(users[index]) return missing_users +def _human_join(seq: Sequence[str], /, *, delimiter: str = ", ", final: str = "and") -> str: + size = len(seq) + if size == 0: + return "" + + if size == 1: + return seq[0] + + if size == 2: + return f"{seq[0]} {final} {seq[1]}" + + return delimiter.join(seq[:-1]) + f" {final} {seq[-1]}" + + @get("/") async def index() -> Response[str]: return Response( @@ -164,23 +165,46 @@ async def index() -> Response[str]: ) -@get("/{user1:str}/{user2:str}") -async def get_matches(user1: str, user2: str, status: str = "planning") -> Response[str]: - if user1.casefold() == user2.casefold(): +@get("/{user_list:path}") +async def get_matches(user_list: str, exclude: list[str] | None = None, status: str = "planning") -> Response[str]: + users = list(set([user.casefold() for user in user_list.lstrip("/").split("/")])) + + if len(users) <= 1: return Response( - "Haha, you're really funny.", media_type=MediaType.TEXT, status_code=status_codes.HTTP_418_IM_A_TEAPOT + f"Only {len(users)} user(s) provided. You must provide at least two, for example: /user1/user2/etc...", + media_type=MediaType.TEXT, + status_code=status_codes.HTTP_400_BAD_REQUEST, ) + for user in users: + if not user.isalnum() or len(user) > 20: + return Response( + f"User {user} is not a valid AniList username.", + media_type=MediaType.TEXT, + status_code=status_codes.HTTP_400_BAD_REQUEST, + ) + try: selected_status = Status[status.casefold()] except KeyError: _statuses = "\n".join(item.name for item in Status) return Response(f"Sorry, your chosen status of {status} is not valid. Please choose from:-\n\n{_statuses}") - data = await _fetch_user_entries(user1.casefold(), user2.casefold(), status=selected_status) + excluded = list(set([ex.casefold() for ex in exclude or []])) + + faulty = [ex for ex in excluded if ex not in HEADINGS] + + if faulty: + return Response( + f"Unknown excluded headings: {_human_join(faulty)}. Supported: {_human_join(HEADINGS)}", + media_type=MediaType.TEXT, + status_code=status_codes.HTTP_400_BAD_REQUEST, + ) + + data = await _fetch_user_entries(*users, status=selected_status) if errors := data.get("errors"): - errored_users = _handle_errors(errors, user1, user2) + errored_users = _handle_errors(errors, *users) fmt = ", ".join(errored_users) return Response( @@ -192,7 +216,7 @@ async def get_matches(user1: str, user2: str, status: str = "planning") -> Respo try: matching_items = _get_common_planning(data) # type: ignore # the type is resolved above. except NoPlanningData as err: - errored_user = user1 if err.user == 1 else user2 + errored_user = users[err.user] return Response( f"Sorry, but {errored_user} has no {selected_status.value.lower()} entries!", media_type=MediaType.TEXT, @@ -206,8 +230,8 @@ async def get_matches(user1: str, user2: str, status: str = "planning") -> Respo status_code=status_codes.HTTP_412_PRECONDITION_FAILED, ) - head = OPENGRAPH_HEAD.format(user1=user1, user2=user2, mutual=len(matching_items), status=selected_status.value.title()) - formatted = format_entries_as_table(matching_items) + head = OPENGRAPH_HEAD.format(users=_human_join(users), mutual=len(matching_items), status=selected_status.value.title()) + formatted = format_entries_as_table(matching_items, excluded=excluded) return Response(head + "\n" + formatted, media_type=MediaType.HTML, status_code=status_codes.HTTP_200_OK) @@ -220,4 +244,5 @@ async def get_matches(user1: str, user2: str, status: str = "planning") -> Respo rate_limit_reset_header_key="X-Ratelimit-Reset", ) + app = Litestar(route_handlers=[index, get_matches], middleware=[RL_CONFIG.middleware]) diff --git a/anilist-cmp/types_/responses.py b/anilist-cmp/types_/responses.py index 97336dc..b43af63 100644 --- a/anilist-cmp/types_/responses.py +++ b/anilist-cmp/types_/responses.py @@ -27,13 +27,8 @@ class MediaListCollection(TypedDict): lists: list[MediaListEntry] -class MediaListCollectionResponse(TypedDict): - user1: MediaListCollection - user2: MediaListCollection - - class AnilistResponse(TypedDict): - data: MediaListCollectionResponse + data: dict[str, MediaListCollection] class AnilistErrorLocation(TypedDict):