Metadata-Version: 2.3
Name: aiorezka
Version: 1.3.0
Summary: 
Author: iYasha
Author-email: 33287747+iYasha@users.noreply.github.com
Requires-Python: >=3.9,<4.0
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Provides-Extra: downloader
Requires-Dist: aiofiles (>=23.2.1,<24.0.0)
Requires-Dist: aiohttp (>=3.9.1,<4.0.0)
Requires-Dist: beautifulsoup4 (>=4.11.1,<5.0.0)
Requires-Dist: faker (>=21.0.0,<22.0.0)
Requires-Dist: pydantic (>=2.5.3,<3.0.0)
Requires-Dist: yt-dlp[aria2c] (>=2025.7.21,<2026.0.0) ; extra == "downloader"
Description-Content-Type: text/markdown

# aiorezka

## Installation

### Without cache
```bash
pip install aiorezka
```

### With cache
_It's recommended to use cache, because it will reduce load on Rezka API._

```bash
pip install aiorezka[request_cache]
```

## Usage
```python
from aiorezka.api import RezkaAPI
import asyncio

async def main():
    async with RezkaAPI() as api:
        details = await api.movie_detail.get(
            'https://rezka.ag/cartoons/comedy/2136-rik-i-morti-2013.html'
        )
        print(details)

asyncio.run(main())
```
You can find more examples in [examples](examples) directory.

## Download TV series
1. Install [aria2](https://aria2.github.io/) and [ffmpeg](https://ffmpeg.org/).
2. Install downloader extras for `aiorezka`:
```bash
pip install aiorezka[downloader]
```
3. Run download process:
```python
python -m aiorezka -u https://rezka.ag/cartoons/comedy/2136-rik-i-morti-2013-latest.html -a Сыендук -s 1
```

```python
Aiorezka CLI

options:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit
  -u URL, --url URL     URL of the movie or TV series to download. Can be full
                        URL or just urn (e.g. /films/series/12345.html)
  -p PATH, --path PATH  Path to save downloaded files (default: current
                        directory)
  -s SEASON, --season SEASON
                        Season number for TV series (default: 1)
  -a AUDIO_TRACK, --audio-track AUDIO_TRACK
                        Preferred audio track for TV series
```

## Configuration
### Hostname configuration
You can configure hostname for requests. By default it will use `rezka.ag` hostname.
To change it, you can pass environment variable `REZKA_HOSTNAME` or change it in code:
```python 
import aiorezka

aiorezka.host = 'rezka.co'
```

### Concurrency configuration
You can configure concurrency for API client, basically it will limit number of concurrent requests via asyncio.Semaphore.
By default it will use 60 concurrent requests.
To change it, you can pass environment variable `REZKA_CONCURRENCY_LIMIT` or change it in code:
```python
import aiorezka

aiorezka.concurrency_limit = 100
```

### Retry configuration
You can configure retry policy for requests. By default it will retry 3 times with 1 * (backoff ** retry_no) second delay.
To change it, you can pass environment variables, such as `REZKA_MAX_RETRY` and `REZKA_RETRY_DELAY` or change it in code:
```python
import aiorezka

aiorezka.max_retry = 5
aiorezka.retry_delay = 2
```

### Cache configuration
You can configure cache for requests. By default, it will use `aiorezka.cache.QueryCache` + `aiorezka.cache.DiskCacheThreadProvider` with 1 day TTL.
Cache will periodically save to disk, so you can use it between restarts.


#### use_cache
Enable or disable cache. By default, it's disabled.
```python
import aiorezka

aiorezka.use_cache = False  # disable cache
```
or use environment variable `REZKA_USE_CACHE`

#### cache_directory
Directory where cache will be stored. By default, it's `/tmp/aiorezka_cache`.
```python
import aiorezka

aiorezka.cache_directory = '/tmp/aiorezka_cache'
```
or use environment variable `REZKA_CACHE_DIRECTORY`

#### memcache_max_len
Max number of items in memory cache. When it's reached, it will be saved to disk. 

By default, it's 1000.
```python
import aiorezka

aiorezka.memcache_max_len = 1000
```
or use environment variable `REZKA_MEMCACHE_MAX_LEN`

#### cache_ttl
TTL for cache objects.

By default, it's 1 day.
```python
import aiorezka

aiorezka.cache_ttl = 60 * 60 * 24  # 1 day
```
or use environment variable `REZKA_CACHE_TTL`

#### max_open_files
Max number of open files for cache. It's used for `aiorezka.cache.DiskCacheThreadProvider`. When app starts cache will be rebuilt on disk, so it will open a lot of files to check if they are expired.

By default, it's 5000.
```python
import aiorezka

aiorezka.max_open_files = 5000
```
or use environment variable `REZKA_MAX_OPEN_FILES`

You can disable cache rebuild on start, then TTL will be ignored.
```python
from aiorezka.api import RezkaAPI

async def main():
    async with RezkaAPI(cache_rebuild_on_start=False) as api:
        pass
```

### Logging configuration
You can configure logging for aiorezka. By default, it will use `logging.INFO` level.
```python
import aiorezka

aiorezka.log_level = "DEBUG"
```
or use environment variable `REZKA_LOG_LEVEL`

## Debugging
### Measure RPS
Measure requests per second, use it only for debug purposes.
```python
import asyncio

from aiorezka.api import RezkaAPI
from aiorezka.cli import measure_rps


@measure_rps
async def main():
    async with RezkaAPI() as api:
        movies = await api.movie.iter_pages(range(1, 10), chain=True)
        detailed_movies = await api.movie_detail.many(movies)
        for movie in detailed_movies:
            attributes = '\n'.join([f'{attr["key"]}: {attr["value"]}' for attr in movie.attributes])
            print(f'{movie.title}\n{attributes}\n')

if __name__ == '__main__':
    asyncio.run(main())
```
Output will look like:
```bash
[main][333 requests in 37.82s] 8.81 rps
```

