anilibria-api-client 0.1.4__py3-none-any.whl

anilibria_api_client-0.1.4.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: anilibria-api-client
+Version: 0.1.4
+Summary: Python async API wrapper for AniLibria Swagger
+Author-email: semen-bol <syoma.bolotov@bk.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/semen-bol/Anilibria-Api-Client
+Project-URL: Issues, https://github.com/semen-bol/Anilibria-Api-Client/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp==3.12.15
+Requires-Dist: aiofiles==24.1.0
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: m3u8-To-MP4==0.1.11
+Requires-Dist: ffmpeg-python==0.2.0
+Dynamic: license-file
+
+# Anilibria-Api-Client
+
+[![pypi](https://img.shields.io/badge/anilibria_api_client_on_PyPi-blue)](https://pypi.org/project/anilibria-api-client)
+![version](https://img.shields.io/badge/Version-0.1.4-blue)
+![licence](https://img.shields.io/badge/License-MIT-green)
+![python](https://img.shields.io/badge/Python-3.13%2B-blue)
+
+> [!CAUTION]  
+> **It is not an official wrapper.** [Official AniLibria's Swagger](https://anilibria.top/api/docs/v1)
+
+Anilibria-API-Client - this a async client to work with Anilibria API, use a aiohttp. Full writed at python
+
+## Installing
+Tested at python 3.13
+### pip
+```bash
+$ pip install anilibria-api-client
+```
+## Usage
+```python
+from anilibria_client import AsyncAnilibriaAPI # Client
+from anilibria_client.exceptions import AnilibriaException, AnilibriaValidationException # Errors
+from anilibria_client.types import * # Types for some methods
+from anilibria_client.models import * # Models for some methods
+from anilibria_client.helper import * # Download anime, save torrents files and more
+
+async def main():
+    async with AsyncAnilibriaAPI() as api: # async with
+        await api.teams.users(include="nickname")
+
+    api = AsyncAnilibriaAPI() # like js support
+    await api.teams.users(include="nickname")
+```
+
+## Documentation 📃
+Docs..
+## Issues/Contributing
+### Issues
+Report for any issues [here](https://github.com/semen-bol/Anilibria-Api-Client/issues)
+### Contributing
+We allow contributing! Read the [CODE_OF_CONDUCT.md](https://github.com/semen-bol/Anilibria-Api-Client/blob/main/CODE_OF_CONDUCT.md)
+
+## License 📄
+Anilibria-Api-Client is [MIT](https://github.com/semen-bol/Anilibria-Api-Client/blob/main/LICENSE) licenced.

anilibria_api_client-0.1.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+anilibria_api_client-0.1.4.dist-info/licenses/LICENSE,sha256=gr_OTPhIQY61xF6N31e1tkelwhltQiSRA4t9HcdU11g,1091
+base_api/api_class.py,sha256=g3tcpeZyappRG99L-0uWvcFO74Eqo5ubwvbhI9UGxQw,11486
+methods/__init__.py,sha256=zZ2EpsQUYnke7AedgMe6vKYaWk9BSocO0M423UPqsyI,188
+methods/_helper.py,sha256=2eQIaitEJ_DaSqxwPug0-zW7cM2he7-6KHtrDxb0dY8,9961
+methods/_libria.py,sha256=R0l59PRMkfvAMF_aET-9rvjcTLdwueDdxusiTUxSqX0,206
+methods/accounts.py,sha256=H3lbSrTmISyZwpREnrTlD8RhepYnIa1sKLiQMQEHEfw,13583
+methods/ads.py,sha256=6h8vFwLre6_5k26GTcS6eiUL-jx0uRqrb1zm9m2Pnz0,717
+methods/anime.py,sha256=Cw-dvBypJ9YV3QOTXWeBsAe1_R4Z1uQdxb79xCyq7-M,23423
+methods/app.py,sha256=yw7L4Z0XTxIBSWJK_kZSRSK0a_ojNQdbGmzu_m4AIt4,1063
+methods/media.py,sha256=9I20jNpDTrUDTY6kHf_SNuewZ7p9ptMhbZ0_9IDD8A0,1431
+methods/teams.py,sha256=dQJiB7LdwyrDZ88zh0bA2IplK2--g7eQszKDHOPth6c,1792
+anilibria_api_client-0.1.4.dist-info/METADATA,sha256=BLapOeuZt97orzeA7885KZVLmxSuNI1KabHmjCed_H0,2347
+anilibria_api_client-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anilibria_api_client-0.1.4.dist-info/top_level.txt,sha256=YHiyWxRvAMuzBoCiZP2JLMvOc4f3hXjcV7o_OIGzZQ0,17
+anilibria_api_client-0.1.4.dist-info/RECORD,,

anilibria_api_client-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

anilibria_api_client-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Semen Bolotov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

anilibria_api_client-0.1.4.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+base_api
+methods

base_api/api_class.py

@@ -0,0 +1,284 @@
+import aiohttp
+
+from typing import Dict, Any, Optional, Union
+from urllib.parse import urlencode, urljoin, quote
+from ..exceptions import AnilibriaValidationException, AnilibriaException
+
+
+class AsyncBaseAPI:
+    """
+    Асинхронный базовый класс для работы с API.
+    Предоставляет основные методы для отправки HTTP-запросов и работы с URL.
+    """
+    
+    def __init__(
+        self,
+        base_url: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: int = 10,
+    ):
+        """
+        Инициализация асинхронного API клиента.
+        
+        :param base_url: Базовый URL API
+        :param headers: Заголовки по умолчанию для всех запросов
+        :param timeout: Таймаут запросов в секундах
+        """
+        self.base_url = base_url.rstrip('/')
+        self.headers = headers or {}
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self.session: Optional[aiohttp.ClientSession] = None
+        
+    
+    async def __aenter__(self):
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+            self._own_session = True
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._own_session and self._session:
+            await self._session.close()
+            self.session = None
+            self._own_session = False
+    
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Получить сессию, создавая новую если нужно"""
+        if self.session is None:
+            session = aiohttp.ClientSession()
+            self.session = session
+            self._own_session = True
+        return self.session
+    
+    @staticmethod
+    def build_query_string(params: Dict[str, Any]) -> str:
+        """
+        Создает query string из параметров.
+        
+        :param params: Словарь параметров
+        :return: Строка вида ?key1=value1&key2=value2
+        """
+        if not params:
+            return ""
+        
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        if not filtered_params:
+            return ""
+        
+        return "?" + urlencode(filtered_params, doseq=True)
+    
+    @staticmethod
+    def build_url(base_url: str, endpoint: str, params: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Строит полный URL с параметрами.
+        
+        :param base_url: Базовый URL
+        :param endpoint: Конечная точка
+        :param params: Параметры запроса
+        :return: Полный URL с query-параметрами
+        """
+
+        url = urljoin(base_url + '/', endpoint.lstrip('/'))
+        if params:
+            url += AsyncBaseAPI.build_query_string(params)
+        return url
+    
+    def encode_path_param(self, param: Any) -> str:
+        """
+        Кодирует параметр для использования в пути URL.
+        
+        :param param: Параметр для кодирования
+        :return: Закодированная строка
+        """
+
+        return quote(str(param))
+    
+    def build_endpoint_with_params(self, endpoint_template: str, **path_params) -> str:
+        """
+        Строит endpoint с подставленными параметрами пути.
+        
+        :param endpoint_template: Шаблон endpoint (например: '/users/{user_id}/posts/{post_id}')
+        :param path_params: Параметры для подстановки в путь
+        :return: Готовый endpoint с подставленными параметрами
+        """
+
+        encoded_params = {k: self.encode_path_param(v) for k, v in path_params.items()}
+        return endpoint_template.format(**encoded_params)
+    
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Базовый метод для отправки HTTP-запросов.
+        
+        :param method: HTTP метод (GET, POST, PUT, DELETE и т.д.)
+        :param endpoint: Конечная точка API (относительный путь)
+        :param params: Параметры запроса (для GET)
+        :param data: Тело запроса (для POST, PUT)
+        :param json_data: JSON тело запроса
+        :param headers: Дополнительные заголовки запроса
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API (десериализованный JSON или сырые данные)
+        :raises: HTTPError если статус ответа не 2xx
+        """
+        sees = await self._get_session()
+        if not self.session or not sees:
+            raise RuntimeError("Session not initialized. Use async with context manager.")
+        
+        url = self.build_url(self.base_url, endpoint, params)
+        request_headers = {**self.headers, **(headers or {})}
+        
+        try:
+            async with self.session.request(
+                method=method,
+                url=url,
+                data=data,
+                json=json_data,
+                headers=request_headers,
+                **kwargs
+            ) as response:
+                if response.status == 422:
+                    error_data = await response.json()
+                    if error_data.get("errors"):
+                        raise AnilibriaValidationException(error_data)
+                    else:
+                        raise AnilibriaValidationException({"error": "Ошибка валидации входных параметров"})    
+
+                response.raise_for_status()
+                
+                content_type = response.headers.get('Content-Type', '')
+                if 'application/json' in content_type:
+                    return await response.json()
+                elif 'application/x-bittorrent' in content_type:
+                    return await response.read()
+                
+                return await response.text()
+                
+        except aiohttp.ClientError as e:
+            raise self._handle_error(e)
+        
+        finally:
+            if self._own_session and self.session:
+                await self.session.close()
+                self.session = None
+                self._own_session = False
+    
+    def _handle_error(self, error: aiohttp.ClientError) -> Exception:
+        """
+        Обработка ошибок запроса.
+        
+        :param error: Исключение aiohttp
+        :return: Исключение для проброса
+        """
+
+        if hasattr(error, 'errors'):
+            return error
+        return AnilibriaException(error)
+    
+    async def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Отправка GET запроса.
+        
+        :param endpoint: Конечная точка API
+        :param params: Параметры запроса
+        :param headers: Дополнительные заголовки
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API
+        """
+
+        return await self._request('GET', endpoint, params=params, headers=headers, **kwargs)
+    
+    async def post(
+        self,
+        endpoint: str,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Отправка POST запроса.
+        
+        :param endpoint: Конечная точка API
+        :param data: Тело запроса
+        :param json_data: JSON тело запроса
+        :param headers: Дополнительные заголовки
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API
+        """
+
+        return await self._request('POST', endpoint, data=data, json_data=json_data, headers=headers, **kwargs)
+    
+    async def put(
+        self,
+        endpoint: str,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Отправка PUT запроса.
+        
+        :param endpoint: Конечная точка API
+        :param data: Тело запроса
+        :param json_data: JSON тело запроса
+        :param headers: Дополнительные заголовки
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API
+        """
+
+        return await self._request('PUT', endpoint, data=data, json_data=json_data, headers=headers, **kwargs)
+    
+    async def delete(
+        self,
+        endpoint: str,
+        headers: Optional[Dict[str, str]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Отправка DELETE запроса.
+        
+        :param endpoint: Конечная точка API
+        :param headers: Дополнительные заголовки
+        :param json_data: JSON тело запроса
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API
+        """
+
+        return await self._request('DELETE', endpoint, json_data=json_data, headers=headers, **kwargs)
+    
+    async def patch(
+        self,
+        endpoint: str,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], str, bytes]:
+        """
+        Отправка PATCH запроса.
+        
+        :param endpoint: Конечная точка API
+        :param data: Тело запроса
+        :param json_data: JSON тело запроса
+        :param headers: Дополнительные заголовки
+        :param kwargs: Дополнительные аргументы для aiohttp
+        :return: Ответ от API
+        """
+
+        return await self._request('PATCH', endpoint, data=data, json_data=json_data, headers=headers, **kwargs)

methods/__init__.py

@@ -0,0 +1,6 @@
+from .accounts import AccountsMethod
+from .ads import AdsMethod
+from .anime import AnimeMethod
+from .app import AppMethod
+from .media import MediaMethod
+from .teams import TeamsMethod

methods/_helper.py

@@ -0,0 +1,218 @@
+from typing import Dict, Any
+from ..types import AgeRating, SortType, ContentType, Seasons, PublishStatusesType, ProductionStatusesType
+from ..models import ReleaseCollection, Release
+
+async def validate_filters(params: Release) -> Dict[str, Any]:
+    """
+    Валидация параметров фильтров в формате f["название_переменной"]
+    
+    Args:
+        filters: Словарь с параметрами фильтров
+    """
+    filters = {
+        "genres": params.genres,
+        "types": params.types,
+        "seasons": params.seasons,
+        "from_year": params.from_year,
+        "to_year": params.to_year,
+        "search": params.search,
+        "sorting": params.sorting,
+        "age_ratings": params.age_ratings,
+        "publish_statuses": params.publish_statuses,
+        "production_statuses": params.production_statuses
+    }
+    validated_filters = {}
+    
+    # Валидация genres
+    if "genres" in filters and filters["genres"] is not None:
+        if not isinstance(filters["genres"], str):
+            raise ValueError("genres должен быть строкой")
+        validated_filters["f[genres]"] = filters["genres"]
+    
+    # Валидация types (список ContentType)
+    if "types" in filters and filters["types"] is not None:
+        if not isinstance(filters["types"], list) or not all(isinstance(t, ContentType) for t in filters["types"]):
+            raise ValueError("types должен быть списком ContentType")
+        validated_filters["f[types]"] = [t.value for t in filters["types"]]
+    
+    # Валидация seasons (список Seasons)
+    if "seasons" in filters and filters["seasons"] is not None:
+        if not isinstance(filters["seasons"], list) or not all(isinstance(s, Seasons) for s in filters["seasons"]):
+            raise ValueError("seasons должен быть списком Seasons")
+        validated_filters["f[seasons]"] = [s.value for s in filters["seasons"]]
+    
+    # Валидация from_year
+    if "from_year" in filters and filters["from_year"] is not None:
+        if not isinstance(filters["from_year"], int) or filters["from_year"] < 1900:
+            raise ValueError("from_year должен быть целым числом не менее 1900")
+        validated_filters["f[from_year]"] = filters["from_year"]
+    
+    # Валидация to_year
+    if "to_year" in filters and filters["to_year"] is not None:
+        if not isinstance(filters["to_year"], int) or filters["to_year"] < 1900:
+            raise ValueError("to_year должен быть целым числом не менее 1900")
+        validated_filters["f[to_year]"] = filters["to_year"]
+    
+    # Валидация search
+    if "search" in filters and filters["search"] is not None:
+        if not isinstance(filters["search"], str):
+            raise ValueError("search должен быть строкой")
+        validated_filters["f[search]"] = filters["search"]
+    
+    # Валидация sorting
+    if "sorting" in filters and filters["sorting"] is not None:
+        if not isinstance(filters["sorting"], SortType):
+            raise ValueError("sorting должен быть экземпляром SortType")
+        validated_filters["f[sorting]"] = filters["sorting"].value
+    
+    # Валидация age_ratings (список AgeRating)
+    if "age_ratings" in filters and filters["age_ratings"] is not None:
+        if not isinstance(filters["age_ratings"], list) or not all(isinstance(a, AgeRating) for a in filters["age_ratings"]):
+            raise ValueError("age_ratings должен быть списком AgeRating")
+        validated_filters["f[age_ratings]"] = [a.value for a in filters["age_ratings"]]
+    
+    # Валидация publish_statuses (список PublishStatusesType)
+    if "publish_statuses" in filters and filters["publish_statuses"] is not None:
+        if not isinstance(filters["publish_statuses"], list) or not all(isinstance(p, PublishStatusesType) for p in filters["publish_statuses"]):
+            raise ValueError("publish_statuses должен быть списком PublishStatusesType")
+        validated_filters["f[publish_statuses]"] = [p.value for p in filters["publish_statuses"]]
+    
+    # Валидация production_statuses (список ProductionStatusesType)
+    if "production_statuses" in filters and filters["production_statuses"] is not None:
+        if not isinstance(filters["production_statuses"], list) or not all(isinstance(p, ProductionStatusesType) for p in filters["production_statuses"]):
+            raise ValueError("production_statuses должен быть списком ProductionStatusesType")
+        validated_filters["f[production_statuses]"] = [p.value for p in filters["production_statuses"]]
+    
+    return validated_filters
+
+async def create_filters_from_release(release: Release) -> Dict[str, Any]:
+    """
+    Создает фильтры в формате API из объекта Release
+    
+    Args:
+        release: Объект Release с параметрами фильтрации
+    """
+    filters = {}
+    
+    # genres
+    if release.genres is not None:
+        filters["genres"] = release.genres
+    
+    # types
+    if release.types is not None:
+        filters["types"] = [t.value for t in release.types]
+    
+    # seasons
+    if release.seasons is not None:
+        filters["seasons"] = [s.value for s in release.seasons]
+    
+    # years (объединяем from_year и to_year)
+    if release.from_year is not None or release.to_year is not None:
+        years = {}
+        if release.from_year is not None:
+            years["from_year"] = release.from_year
+        if release.to_year is not None:
+            years["to_year"] = release.to_year
+        filters["years"] = years
+    
+    # search
+    if release.search is not None:
+        filters["search"] = release.search
+    
+    # sorting
+    if release.sorting is not None and release.sorting:
+        filters["sorting"] = release.sorting.value
+    
+    # age_ratings
+    if release.age_ratings is not None:
+        filters["age_ratings"] = [a.value for a in release.age_ratings]
+    
+    # publish_statuses
+    if release.publish_statuses is not None:
+        filters["publish_statuses"] = [p.value for p in release.publish_statuses]
+    
+    # production_statuses
+    if release.production_statuses is not None:
+        filters["production_statuses"] = [p.value for p in release.production_statuses]
+    
+    return {"f": filters}
+
+async def validate_collection(params: ReleaseCollection) -> Dict[str, Any]:
+    """
+    Валидация параметров фильтров для ReleaseCollection в формате f["название_переменной"]
+    
+    Args:
+        params: Объект ReleaseCollection с параметрами фильтрации
+    """
+    filters = {
+        "genres": params.genres,
+        "types": params.types,
+        "years": params.years,
+        "search": params.search,
+        "age_ratings": params.age_ratings
+    }
+    validated_filters = {}
+    
+    # Валидация genres
+    if "genres" in filters and filters["genres"] is not None:
+        if not isinstance(filters["genres"], str):
+            raise ValueError("genres должен быть строкой")
+        validated_filters["f[genres]"] = filters["genres"]
+    
+    # Валидация types (список ContentType)
+    if "types" in filters and filters["types"] is not None:
+        if not isinstance(filters["types"], list) or not all(isinstance(t, ContentType) for t in filters["types"]):
+            raise ValueError("types должен быть списком ContentType")
+        validated_filters["f[types]"] = [t.value for t in filters["types"]]
+    
+    # Валидация years
+    if "years" in filters and filters["years"] is not None:
+        if not isinstance(filters["years"], str):
+            raise ValueError("years должен быть строкой")
+        validated_filters["f[years]"] = filters["years"]
+    
+    # Валидация search
+    if "search" in filters and filters["search"] is not None:
+        if not isinstance(filters["search"], str):
+            raise ValueError("search должен быть строкой")
+        validated_filters["f[search]"] = filters["search"]
+    
+    # Валидация age_ratings (список AgeRating)
+    if "age_ratings" in filters and filters["age_ratings"] is not None:
+        if not isinstance(filters["age_ratings"], list) or not all(isinstance(a, AgeRating) for a in filters["age_ratings"]):
+            raise ValueError("age_ratings должен быть списком AgeRating")
+        validated_filters["f[age_ratings]"] = [a.value for a in filters["age_ratings"]]
+    
+    return validated_filters
+
+
+async def validated_json_collection(release: ReleaseCollection) -> Dict[str, Any]:
+    """
+    Создает фильтры в формате API из объекта ReleaseCollection
+    
+    Args:
+        release: Объект ReleaseCollection с параметрами фильтрации
+    """
+    filters = {}
+    
+    # genres
+    if release.genres is not None:
+        filters["genres"] = release.genres
+    
+    # types
+    if release.types is not None:
+        filters["types"] = [t.value for t in release.types]
+    
+    # years
+    if release.years is not None:
+        filters["years"] = release.years
+    
+    # search
+    if release.search is not None:
+        filters["search"] = release.search
+    
+    # age_ratings
+    if release.age_ratings is not None:
+        filters["age_ratings"] = [a.value for a in release.age_ratings]
+    
+    return {"f": filters}

methods/_libria.py

@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from ..api_client import AsyncAnilibriaAPI
+
+class BaseMethod:
+    def __init__(self, api: 'AsyncAnilibriaAPI'):
+        self._api = api
+