webinardump 0.1.1__tar.gz

webinardump-0.1.1/.gitignore

@@ -0,0 +1 @@
+dump/

webinardump-0.1.1/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: webinardump
+Version: 0.1.1
+Summary: Make local backup copies of webinars
+Project-URL: Homepage, https://github.com/idlesign/webinardump
+Author-email: Igor Starikov <idlesign@yandex.ru>
+License-Expression: BSD-3-Clause
+Keywords: backup,webinars
+Requires-Python: >=3.11
+Requires-Dist: requests>=2.31.0
+Description-Content-Type: text/markdown
+
+# webinardump
+
+<https://github.com/idlesign/webinardump>
+
+[![PyPI - Version](https://img.shields.io/pypi/v/webinardump)](https://pypi.python.org/pypi/webinardump)
+[![License](https://img.shields.io/pypi/l/webinardump)](https://pypi.python.org/pypi/webinardump)
+[![Coverage](https://img.shields.io/coverallsCoverage/github/idlesign/webinardump)](https://coveralls.io/r/idlesign/webinardump)
+
+## Описание
+
+*Приложение позволяет скачать запись вебинара и сохранить в виде .mp4 файла.*
+
+
+## Откуда качает
+
+* Яндекс.Диск (записи стримов)
+* webinar.ru
+
+
+## Зависимости
+
+Что нужно иметь для запуска приложения и работы с ним.
+
+* Linux (Unix)
+* Python 3.11+
+* ffmpeg (для Ubuntu: `sudo apt install ffmpeg`)
+* uv (для установки и обновления приложения)
+* Базовые знания о работе в браузере с отладочной консолью.
+
+
+## Установка и обновление
+
+Производится при помощи приложения [uv](https://docs.astral.sh/uv/getting-started/installation/):
+
+```shell
+$ uv tool install webinardump
+```
+
+После этого запускать приложение можно командой
+
+```shell
+$ webinardump
+```
+
+Для обновления выполните
+
+```shell
+$ uv tool upgrade webinardump
+```
+
+## Как использовать
+
+Переместитесь в желаемый каталог и выполните следующую команду. 
+
+```shell
+
+; Указываем путь для скачивания - my_webinar_dir/
+; Указываем таймаут запросов - 10 секунд
+; Указываем максимальное количество одновременных запросов - 20
+uv run webinar.py --target my_webinar_dir/ --timeout 10 --rmax 20
+```
+Приложение скачает фрагменты вебинара, а потом соберёт из них единый файл.
+
+
+### disk.yandex.ru
+
+1. Взять ссылку на вебинар (запись стрима). Вида https://disk.yandex.ru/i/xxx
+2. Запустить скачиватель и скормить ему ссылку из предыдущего пункта.
+
+
+### webinar.ru
+
+Процесс скачивания автоматизирован не полностью, потребуется искать
+некоторые ссылки при помощи браузера.
+
+1. Взять ссылку на вебинар. Вида https://events.webinar.ru/event/xxx/yyy/zzz
+2. Открыть в браузере.
+3. Включить отладочную консоль (F12).
+4. Запустить воспроизведение.
+5. Отыскать ссылку с `record-new/` и запомнить её.
+6. Отыскать ссылку, оканчивающуюся на `chunklist.m3u8` и запомнить её.
+7. Запустить скачиватель и скормить ему ссылки и двух предыдущих пунктов.
+
+## Для разработки
+
+При разработке используется [makeapp](https://pypi.org/project/makeapp/). Ставим:
+
+```shell
+$ uv tool install makeapp
+```
+
+После клонирования репозитория sponsrdump, в его директории выполняем:
+
+```shell
+# ставим утилиты
+$ ma tools
+
+# инициализируем виртуальное окружение
+$ ma up --tool
+
+# теперь в окружении доступны зависимости и команда sponsrdump
+```
+
+Проверь стиль перед отправкой кода на обзор:
+
+```shell
+# проверяем стиль
+$ ma style
+```

webinardump-0.1.1/README.md

@@ -0,0 +1,109 @@
+# webinardump
+
+<https://github.com/idlesign/webinardump>
+
+[![PyPI - Version](https://img.shields.io/pypi/v/webinardump)](https://pypi.python.org/pypi/webinardump)
+[![License](https://img.shields.io/pypi/l/webinardump)](https://pypi.python.org/pypi/webinardump)
+[![Coverage](https://img.shields.io/coverallsCoverage/github/idlesign/webinardump)](https://coveralls.io/r/idlesign/webinardump)
+
+## Описание
+
+*Приложение позволяет скачать запись вебинара и сохранить в виде .mp4 файла.*
+
+
+## Откуда качает
+
+* Яндекс.Диск (записи стримов)
+* webinar.ru
+
+
+## Зависимости
+
+Что нужно иметь для запуска приложения и работы с ним.
+
+* Linux (Unix)
+* Python 3.11+
+* ffmpeg (для Ubuntu: `sudo apt install ffmpeg`)
+* uv (для установки и обновления приложения)
+* Базовые знания о работе в браузере с отладочной консолью.
+
+
+## Установка и обновление
+
+Производится при помощи приложения [uv](https://docs.astral.sh/uv/getting-started/installation/):
+
+```shell
+$ uv tool install webinardump
+```
+
+После этого запускать приложение можно командой
+
+```shell
+$ webinardump
+```
+
+Для обновления выполните
+
+```shell
+$ uv tool upgrade webinardump
+```
+
+## Как использовать
+
+Переместитесь в желаемый каталог и выполните следующую команду. 
+
+```shell
+
+; Указываем путь для скачивания - my_webinar_dir/
+; Указываем таймаут запросов - 10 секунд
+; Указываем максимальное количество одновременных запросов - 20
+uv run webinar.py --target my_webinar_dir/ --timeout 10 --rmax 20
+```
+Приложение скачает фрагменты вебинара, а потом соберёт из них единый файл.
+
+
+### disk.yandex.ru
+
+1. Взять ссылку на вебинар (запись стрима). Вида https://disk.yandex.ru/i/xxx
+2. Запустить скачиватель и скормить ему ссылку из предыдущего пункта.
+
+
+### webinar.ru
+
+Процесс скачивания автоматизирован не полностью, потребуется искать
+некоторые ссылки при помощи браузера.
+
+1. Взять ссылку на вебинар. Вида https://events.webinar.ru/event/xxx/yyy/zzz
+2. Открыть в браузере.
+3. Включить отладочную консоль (F12).
+4. Запустить воспроизведение.
+5. Отыскать ссылку с `record-new/` и запомнить её.
+6. Отыскать ссылку, оканчивающуюся на `chunklist.m3u8` и запомнить её.
+7. Запустить скачиватель и скормить ему ссылки и двух предыдущих пунктов.
+
+## Для разработки
+
+При разработке используется [makeapp](https://pypi.org/project/makeapp/). Ставим:
+
+```shell
+$ uv tool install makeapp
+```
+
+После клонирования репозитория sponsrdump, в его директории выполняем:
+
+```shell
+# ставим утилиты
+$ ma tools
+
+# инициализируем виртуальное окружение
+$ ma up --tool
+
+# теперь в окружении доступны зависимости и команда sponsrdump
+```
+
+Проверь стиль перед отправкой кода на обзор:
+
+```shell
+# проверяем стиль
+$ ma style
+```

webinardump-0.1.1/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "webinardump"
+dynamic = ["version"]
+description = "Make local backup copies of webinars"
+authors = [
+    { name = "Igor Starikov", email = "idlesign@yandex.ru" }
+]
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+keywords = ["backup", "webinars"]
+dependencies = [
+    "requests>=2.31.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/idlesign/webinardump"
+
+[project.scripts]
+webinardump = "webinardump.cli:main"
+
+[dependency-groups]
+dev = [
+    {include-group = "linters"},
+    {include-group = "tests"},
+]
+linters = [
+#    "ruff",
+]
+tests = [
+    "pytest",
+    "pytest-responsemock",
+    "pytest-datafixtures",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/webinardump/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/webinardump"]
+
+[tool.hatch.build.targets.sdist]
+packages = ["src/"]
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]
+
+[tool.coverage.run]
+source = [
+    "src/",
+]
+omit = [
+    "*/cli.py",
+]
+
+[tool.coverage.report]
+fail_under = 99.00
+exclude_also = [
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+]
+
+[tool.tox]
+skip_missing_interpreters = true
+env_list = [
+  "py311",
+  "py312",
+  "py313",
+]
+
+[tool.tox.env_run_base]
+dependency_groups = ["tests"]
+commands = [
+  ["pytest", { replace = "posargs", default = ["tests"], extend = true }],
+]

webinardump-0.1.1/src/webinardump/__init__.py

@@ -0,0 +1 @@
+VERSION = '0.1.1'

webinardump-0.1.1/src/webinardump/cli.py

@@ -0,0 +1,46 @@
+import argparse
+import logging
+from pathlib import Path
+
+from .dumpers import Dumper
+
+
+def get_user_input(param: str, hint: str, *, choices: list[str] | None = None) -> str:
+
+    choices = set(choices or [])
+
+    while True:
+        data = input(f'{hint}: ')
+        data = data.strip()
+        if not data or (choices and data not in choices):
+            continue
+
+        return data
+
+
+def main():
+    parser = argparse.ArgumentParser(prog='webinardump')
+    parser.add_argument('-t', '--target', type=Path, default=Path(), help='Directory to dump to')
+    parser.add_argument('--timeout', type=int, default=3, help='Request timeout')
+    parser.add_argument('--rmax', type=int, default=10, help='Max concurrent requests number')
+    parser.add_argument('--debug', help='Show debug information', action='store_true')
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO, format='%(levelname)-8s: %(message)s')
+
+    dumper_choices = []
+    print('Available dumpers:')
+
+    for idx, dumper in enumerate(Dumper.registry, 1):
+        print(f'{idx} — {dumper.title}')
+        dumper_choices.append(f'{idx}')
+
+    chosen = get_user_input('', 'Select dumper number', choices=dumper_choices)
+
+    dumper = Dumper.registry[int(chosen)-1](
+        target_dir=args.target,
+        timeout=args.timeout,
+        concurrent=args.rmax,
+    )
+    dumper.run(get_user_input)

webinardump-0.1.1/src/webinardump/dumpers/__init__.py

@@ -0,0 +1,9 @@
+from .base import Dumper
+from .webinarru import WebinarRu
+from .yadisk import YandexDisk
+
+__all__ = [
+    'Dumper',
+    'WebinarRu',
+    'YandexDisk',
+]

webinardump-0.1.1/src/webinardump/dumpers/base.py

@@ -0,0 +1,242 @@
+import shutil
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import chdir
+from pathlib import Path
+from random import choice
+from threading import Lock
+from time import sleep
+from typing import ClassVar
+
+import requests
+from requests import Session
+from requests.adapters import HTTPAdapter, Retry
+
+from ..utils import LOGGER, call
+
+
+class Dumper:
+
+    title: str = ''
+
+    _user_input_map: ClassVar[dict[str, str]]
+
+    _headers: ClassVar[dict[str, str]] = {
+        'Connection': 'keep-alive',
+        'Accept': '*/*',
+        'User-Agent': (
+            'Mozilla/5.0 (X11; Linux x86_64) '
+            'AppleWebKit/537.36 (KHTML, like Gecko) '
+            'Chrome/79.0.3945.136 YaBrowser/20.2.3.320 (beta) Yowser/2.5 Safari/537.36'
+        ),
+        'Sec-Fetch-Site': 'same-site',
+        'Sec-Fetch-Mode': 'cors',
+        'Accept-Language': 'ru,en;q=0.9',
+        'Accept-Encoding': 'gzip, deflate, sdch, br',
+    }
+
+    registry: ClassVar[list[type['Dumper']]] = []
+
+    def __init_subclass__(cls):
+        super().__init_subclass__()
+        cls.registry.append(cls)
+
+    def __init__(self, *, target_dir: Path, timeout: int = 3, concurrent: int = 10, sleepy: bool = False) -> None:
+        self._target_dir = target_dir
+        self._timeout = timeout
+        self._concurrent = concurrent
+        self._user_input_map = self._user_input_map or {}
+        self._session = self._get_session()
+        self._sleepy = sleepy
+
+    def __str__(self):
+        return self.title
+
+    def _get_session(self) -> Session:
+        # todo при ошибках сессия в нитях блокируется. можно попробовать несколько сессий
+        session = requests.Session()
+        session.headers = self._headers
+        retries = Retry(total=3, backoff_factor=0.1, status_forcelist=[500])
+        session.mount('http://', HTTPAdapter(max_retries=retries))
+        session.mount('https://', HTTPAdapter(max_retries=retries))
+        return session
+
+    def _get_args(self, *, get_param_hook: Callable[[str, str], str]) -> dict:
+        input_data = {}
+
+        for param, hint in self._user_input_map.items():
+            input_data[param] = get_param_hook(param, hint)
+
+        return input_data
+
+    def _chunks_get_list(self, url: str) -> list[str]:
+        """Get video chunks names from playlist file at URL.
+
+        :param url: File URL.
+
+        """
+        LOGGER.info(f'Getting video chunks from playlist {url} ...')
+
+        playlist = self._get_response_simple(url)
+        chunk_lists = []
+
+        for line in playlist.splitlines():
+            line = line.strip()
+
+            if not line.partition('?')[0].endswith('.ts'):
+                continue
+
+            chunk_lists.append(line)
+
+        assert chunk_lists, 'No .ts chunks found in playlist file'
+
+        return chunk_lists
+
+    def _chunks_download(
+        self,
+        *,
+        url_video_root: str,
+        dump_dir: Path,
+        chunk_names: list[str],
+        start_chunk: str,
+        headers: dict[str, str] | None = None,
+        concurrent: int = 10,
+    ) -> None:
+
+        chunks_total = len(chunk_names)
+
+        progress_file = (dump_dir / 'files.txt')
+        progress_file.touch()
+
+        files_done = dict.fromkeys(progress_file.read_text().splitlines())
+        lock = Lock()
+
+        def dump(*, name: str, url: str, session: Session, sleepy: bool, timeout: int) -> None:
+
+            name = name.partition('?')[0]
+
+            if name in files_done:
+                LOGGER.info(f'File {name} has been already downloaded before. Skipping.')
+                return
+
+            with session.get(url, headers=headers or {}, stream=True, timeout=timeout) as r:
+                r.raise_for_status()
+                with (dump_dir / name).open('wb') as f:
+                    f.writelines(r.iter_content(chunk_size=8192))
+
+            files_done[name] = True
+            with lock:
+                progress_file.write_text('\n'.join(files_done))
+
+            if sleepy:
+                sleep(choice([1, 0.5, 0.7, 0.6]))
+
+        with ThreadPoolExecutor(max_workers=concurrent) as executor:
+
+            future_url_map = {}
+
+            for chunk_name in chunk_names:
+
+                if chunk_name == start_chunk:
+                    start_chunk = ''  # clear to allow further download
+
+                if start_chunk:
+                    continue
+
+                chunk_url = f'{url_video_root.rstrip("/")}/{chunk_name}'
+                submitted = executor.submit(
+                    dump,
+                    name=chunk_name,
+                    url=chunk_url,
+                    session=self._session,
+                    sleepy=self._sleepy,
+                    timeout=self._timeout,
+                )
+
+                future_url_map[submitted] = (chunk_name, chunk_url)
+
+            if future_url_map:
+                LOGGER.info(f'Downloading up to {concurrent} files concurrently ...')
+
+                counter = 1
+                for future in as_completed(future_url_map):
+                    chunk_name, chunk_url = future_url_map[future]
+                    future.result()
+                    percent = round(counter * 100 / chunks_total, 1)
+                    counter += 1
+                    LOGGER.info(f'Got {counter}/{chunks_total} ({chunk_name.partition("?")[0]}) [{percent}%] ...')
+
+    def _video_concat(self, path: Path) -> Path:
+
+        LOGGER.info('Concatenating video ...')
+
+        fname_video = 'all_chunks.mp4'
+        fname_index = 'all_chunks.txt'
+
+        call(f'for i in `ls *.ts | sort -V`; do echo "file $i"; done >> {fname_index}', path=path)
+        call(f'ffmpeg -f concat -i {fname_index} -c copy -bsf:a aac_adtstoasc {fname_video}', path=path)
+
+        return path / fname_video
+
+    def _get_response_simple(self, url: str, *, json: bool = False) -> str | dict:
+        """Returns a text or a dictionary from a URL.
+
+        :param url:
+        :param json:
+
+        """
+        response = self._session.get(url)
+        response.raise_for_status()
+
+        if json:
+            return response.json()
+
+        return response.text
+
+    def _video_dump(
+        self,
+        *,
+        title: str,
+        url_playlist: str,
+        url_referer: str,
+        start_chunk: str = '',
+    ) -> Path:
+        assert url_playlist.endswith('m3u8'), f'No playlist in `{url_playlist}`'
+
+        LOGGER.info(f'Title: {title}')
+
+        chunk_names = self._chunks_get_list(url_playlist)
+
+        target_dir = self._target_dir
+        LOGGER.info(f'Downloading video into {target_dir} ...')
+
+        with chdir(target_dir):
+            dump_dir = (target_dir / title).absolute()
+            dump_dir.mkdir(parents=True, exist_ok=True)
+
+            url_root = url_playlist.rpartition('/')[0]  # strip playlist filename
+
+            self._chunks_download(
+                url_video_root=url_root,
+                dump_dir=dump_dir,
+                chunk_names=chunk_names,
+                start_chunk=start_chunk,
+                headers={'Referer': url_referer.strip()},
+                concurrent=self._concurrent,
+            )
+
+            fpath_video_target = Path(f'{title}.mp4').absolute()
+            fpath_video = self._video_concat(dump_dir)
+
+            shutil.move(fpath_video, fpath_video_target)
+            shutil.rmtree(dump_dir, ignore_errors=True)
+
+        LOGGER.info(f'Video is ready: {fpath_video_target}')
+        return fpath_video_target
+
+    def _gather(self, *, url_video: str, start_chunk: str = '', **params) -> Path:
+        raise NotImplementedError
+
+    def run(self, params_or_hook: Callable[[str, str], str] | dict[str, str]) -> Path:
+        params = params_or_hook if isinstance(params_or_hook, dict) else self._get_args(get_param_hook=params_or_hook)
+        return self._gather(**params)

webinardump-0.1.1/src/webinardump/dumpers/webinarru.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+from typing import ClassVar
+
+from ..utils import LOGGER
+from .base import Dumper
+
+
+class WebinarRu(Dumper):
+
+    title = 'webinar.ru'
+
+    _user_input_map: ClassVar[dict[str, str]] = {
+        'url_video': 'Video URL (with `record-new/`)',
+        'url_playlist': 'Video chunk list URL (with `chunklist.m3u8`)',
+    }
+
+    _headers: ClassVar[dict[str, str]] = {
+        **Dumper._headers,
+        'Origin': 'https://events.webinar.ru',
+    }
+
+    def _gather(self, *, url_video: str, start_chunk: str = '', url_playlist: str = '', **params) -> Path:
+        """Runs video dump.
+
+        :param url_video: Video URL. Hint: has record-new/
+        :param url_playlist: Video chunk list URL. Hint: ends with chunklist.m3u8
+        :param start_chunk: Optional chunk name to continue download from.
+        """
+        assert url_playlist, 'Playlist URL must be specified'
+
+        assert 'record-new/' in url_video, (
+            'Unexpected video URL format\n'
+            f'Given:    {url_video}.\n'
+            f'Expected: https://events.webinar.ru/xxx/yyy/record-new/aaa/bbb')
+
+        _, _, tail = url_video.partition('record-new/')
+        session_id, _, video_id = tail.partition('/')
+
+        LOGGER.info('Getting manifest ...')
+
+        manifest = self._get_response_simple(
+            f'https://events.webinar.ru/api/eventsessions/{session_id}/record/isviewable?recordAccessToken={video_id}',
+            json=True
+        )
+
+        return self._video_dump(
+            title=manifest['name'],
+            url_playlist=url_playlist,
+            url_referer=url_video,
+            start_chunk=start_chunk,
+        )

webinardump-0.1.1/src/webinardump/dumpers/yadisk.py

@@ -0,0 +1,57 @@
+import json
+import re
+from pathlib import Path
+from typing import ClassVar
+
+from ..utils import LOGGER
+from .base import Dumper
+
+
+class YandexDisk(Dumper):
+
+    title = 'Яндекс.Диск'
+
+    _user_input_map: ClassVar[dict[str, str]] = {
+        'url_video': 'Video URL (https://disk.yandex.ru/i/xxx)',
+    }
+
+    def _get_manifest(self, url: str) -> dict:
+        LOGGER.debug(f'Getting manifest from {url} ...')
+
+        contents = self._get_response_simple(url)
+        manifest = re.findall(r'id="store-prefetch">([^<]+)</script', contents)
+        assert manifest, f'Manifest not found for {url}'
+        manifest = manifest[0]
+        manifest = json.loads(manifest)
+        return manifest
+
+    def _get_playlist_and_title(self, manifest: dict) -> tuple[str, str]:
+
+        resources = list(manifest['resources'].values())
+        resource = resources[0]
+
+        dimension_max = 0
+        url_playlist = '<none>'
+
+        for stream_info in resource['videoStreams']['videos']:
+            dimension, *_ = stream_info['dimension'].partition('p')
+            if not dimension.isnumeric():
+                continue  # e.g. 'adaptive'
+            dimension = int(dimension)
+            if dimension_max < dimension:
+                dimension_max = dimension
+                url_playlist = stream_info['url']
+
+        return url_playlist, resource['name']
+
+    def _gather(self, *, url_video: str, start_chunk: str = '', **params) -> Path:
+
+        manifest = self._get_manifest(url_video)
+        url_playlist, title = self._get_playlist_and_title(manifest)
+
+        return self._video_dump(
+            title=title,
+            url_playlist=url_playlist,
+            url_referer=url_video,
+            start_chunk=start_chunk,
+        )

webinardump-0.1.1/src/webinardump/utils.py

@@ -0,0 +1,9 @@
+import logging
+from pathlib import Path
+from subprocess import check_call
+
+LOGGER = logging.getLogger('webinardump')
+
+
+def call(cmd: str, *, path: Path):
+    return check_call(cmd, cwd=path, shell=True)