okcdn 4.0.0__tar.gz

okcdn-4.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: okcdn
+Version: 4.0.0
+Summary: High-performance Python client for OKCdn video & media streaming engine
+Author: OKCdn Team
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/your-username/OKCdn
+Project-URL: Documentation, https://github.com/your-username/OKCdn#readme
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+Dynamic: requires-python
+
+# OkCdn Python Client SDK
+
+Легковесный, быстрый и асинхронный клиент для взаимодействия с сервером **OKCdn**.
+
+## ✨ Особенности
+- **Zero-Disk RAM Streaming**: мгновенная перекачка MPEG-DASH (.mpd), HLS (.m3u8), Direct MP4 в OK.ru.
+- **Мгновенное обновление ссылок**: актуализация протухших CDN-ссылок (`<0.5s`).
+- **Пакетная параллельная загрузка**: отправка списков видео с контролируемым `concurrency`.
+- **Автоматический Retry**: устойчивость к временным сетевым сбоям с экспоненциальной задержкой.
+- **Поддержка мультиаккаунтов**: сессии кэшируются на сервере с 30-минутным умным авто-отключением сокетов.
+
+## 📦 Установка
+
+```bash
+pip install okcdn
+```
+
+## 🚀 Быстрый старт
+
+```python
+import asyncio
+from okcdn import OkCdn
+
+async def main():
+    # Инициализация клиента (можно передать параметры или задать переменные окружения)
+    async with OkCdn(
+        server_url="https://your-okcdn-server.koyeb.app",
+        auth_token="YOUR_OK_AUTHCODE_HERE",
+        default_chat_id=123456789
+    ) as cdn:
+
+        # 1. Отправка одиночного видео (HLS / DASH / MP4)
+        video = await cdn.send_video(
+            link="https://example.com/stream.m3u8",
+            caption="Мой видеострим",
+            title="video_01.mp4"
+        )
+        print("Прямой MP4:", video["mp4"])
+        print("HLS ссылка:", video["hls"])
+        print("Video ID:", video["video_id"])
+
+        # 2. Мгновенное обновление ссылок
+        fresh = await cdn.refresh_links(video_id=video["video_id"])
+        print("Обновленная ссылка:", fresh["mp4"])
+        print("Истекает через:", fresh["expires_in_sec"], "сек")
+
+        # 3. Загрузка локального файла
+        uploaded = await cdn.upload_file(
+            file_path="local_video.mp4",
+            caption="Прямая загрузка"
+        )
+        print("Загружено:", uploaded["direct"])
+
+        # 4. Пакетная параллельная отправка
+        batch = await cdn.send_videos(
+            links=[
+                "https://site.com/video1.mp4",
+                "https://site.com/video2.mp4"
+            ],
+            concurrency=2
+        )
+        for url, data in batch.items():
+            print(f"{url} -> {data.get('mp4')}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## ⚙️ Переменные окружения
+
+Вы можете задать переменные окружения, чтобы не указывать их в коде:
+- `OKCDN_SERVER_URL` — адрес запущенного сервера (по умолчанию `http://localhost:8000`)
+- `ACCOUNT_TOKEN` или `OKCDN_AUTH_TOKEN` — токен авторизации OK.ru (`AUTHCODE`)
+- `CHAT_ID` или `OKCDN_CHAT_ID` — ID чата по умолчанию

okcdn-4.0.0/README.md

@@ -0,0 +1,74 @@
+# OkCdn Python Client SDK
+
+Легковесный, быстрый и асинхронный клиент для взаимодействия с сервером **OKCdn**.
+
+## ✨ Особенности
+- **Zero-Disk RAM Streaming**: мгновенная перекачка MPEG-DASH (.mpd), HLS (.m3u8), Direct MP4 в OK.ru.
+- **Мгновенное обновление ссылок**: актуализация протухших CDN-ссылок (`<0.5s`).
+- **Пакетная параллельная загрузка**: отправка списков видео с контролируемым `concurrency`.
+- **Автоматический Retry**: устойчивость к временным сетевым сбоям с экспоненциальной задержкой.
+- **Поддержка мультиаккаунтов**: сессии кэшируются на сервере с 30-минутным умным авто-отключением сокетов.
+
+## 📦 Установка
+
+```bash
+pip install okcdn
+```
+
+## 🚀 Быстрый старт
+
+```python
+import asyncio
+from okcdn import OkCdn
+
+async def main():
+    # Инициализация клиента (можно передать параметры или задать переменные окружения)
+    async with OkCdn(
+        server_url="https://your-okcdn-server.koyeb.app",
+        auth_token="YOUR_OK_AUTHCODE_HERE",
+        default_chat_id=123456789
+    ) as cdn:
+
+        # 1. Отправка одиночного видео (HLS / DASH / MP4)
+        video = await cdn.send_video(
+            link="https://example.com/stream.m3u8",
+            caption="Мой видеострим",
+            title="video_01.mp4"
+        )
+        print("Прямой MP4:", video["mp4"])
+        print("HLS ссылка:", video["hls"])
+        print("Video ID:", video["video_id"])
+
+        # 2. Мгновенное обновление ссылок
+        fresh = await cdn.refresh_links(video_id=video["video_id"])
+        print("Обновленная ссылка:", fresh["mp4"])
+        print("Истекает через:", fresh["expires_in_sec"], "сек")
+
+        # 3. Загрузка локального файла
+        uploaded = await cdn.upload_file(
+            file_path="local_video.mp4",
+            caption="Прямая загрузка"
+        )
+        print("Загружено:", uploaded["direct"])
+
+        # 4. Пакетная параллельная отправка
+        batch = await cdn.send_videos(
+            links=[
+                "https://site.com/video1.mp4",
+                "https://site.com/video2.mp4"
+            ],
+            concurrency=2
+        )
+        for url, data in batch.items():
+            print(f"{url} -> {data.get('mp4')}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## ⚙️ Переменные окружения
+
+Вы можете задать переменные окружения, чтобы не указывать их в коде:
+- `OKCDN_SERVER_URL` — адрес запущенного сервера (по умолчанию `http://localhost:8000`)
+- `ACCOUNT_TOKEN` или `OKCDN_AUTH_TOKEN` — токен авторизации OK.ru (`AUTHCODE`)
+- `CHAT_ID` или `OKCDN_CHAT_ID` — ID чата по умолчанию

okcdn-4.0.0/okcdn/__init__.py

@@ -0,0 +1,23 @@
+"""
+OkCdn Client - Высокопроизводительный асинхронный клиент для работы с сервером OKCdn.
+"""
+
+from .client import OkCdn
+from .exceptions import (
+    OkCdnError,
+    OkCdnAuthError,
+    OkCdnServerError,
+    OkCdnBadRequestError,
+    OkCdnTimeoutError
+)
+
+__all__ = [
+    "OkCdn",
+    "OkCdnError",
+    "OkCdnAuthError",
+    "OkCdnServerError",
+    "OkCdnBadRequestError",
+    "OkCdnTimeoutError",
+]
+
+__version__ = "4.0.0"

okcdn-4.0.0/okcdn/client.py

@@ -0,0 +1,416 @@
+import os
+import asyncio
+import aiohttp
+from typing import Optional, List, Dict, Any, Union
+
+from .exceptions import (
+    OkCdnError,
+    OkCdnAuthError,
+    OkCdnServerError,
+    OkCdnBadRequestError,
+    OkCdnTimeoutError
+)
+
+
+class OkCdn:
+    """
+    Легковесный асинхронный клиент для работы с сервером OKCdn.
+    
+    Поддерживает:
+    - Загрузку видео и потоков (DASH, HLS, MP4) в OK CDN
+    - Пакетную параллельную загрузку видео
+    - Мгновенное обновление прямых ссылок
+    - Загрузку локальных файлов (direct/multipart)
+    - Отправку фото и аудио
+    - Автоматические повторные попытки (Retry) с экспоненциальной задержкой
+    """
+
+    def __init__(
+        self,
+        server_url: str,
+        auth_token: str,
+        default_chat_id: Optional[Union[int, str]] = None,
+        timeout: float = 180.0,
+        max_retries: int = 3,
+        headers: Optional[Dict[str, str]] = None
+    ):
+        """
+        Инициализация клиента OkCdn.
+
+        :param server_url: URL запущенного сервера OKCdn (например, 'https://api.yourdomain.com' или 'http://localhost:8000').
+        :param auth_token: Токен авторизации OK.ru (AUTHCODE). Обязателен.
+        :param default_chat_id: ID чата по умолчанию (опционально, если передается в каждый метод).
+        :param timeout: Таймаут запросов в секундах (по умолчанию 180с для больших стримов).
+        :param max_retries: Количество повторных попыток при сетевых сбоях (по умолчанию 3).
+        :param headers: Дополнительные HTTP заголовки.
+        """
+        if not server_url or not str(server_url).strip():
+            raise ValueError("server_url обязателен для инициализации OkCdn")
+        if not auth_token or not str(auth_token).strip():
+            raise ValueError("auth_token (AUTHCODE от OK.ru) обязателен для инициализации OkCdn")
+
+        self.server_url = str(server_url).strip().rstrip("/")
+        self.auth_token = str(auth_token).strip()
+        self.default_chat_id = int(default_chat_id) if default_chat_id is not None else None
+
+        self.timeout = timeout
+        self.max_retries = max(1, max_retries)
+        self.custom_headers = headers or {}
+        
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._session_lock = asyncio.Lock()
+
+    async def __aenter__(self):
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def _ensure_session(self) -> aiohttp.ClientSession:
+        if self._session and not self._session.closed:
+            return self._session
+
+        async with self._session_lock:
+            if self._session and not self._session.closed:
+                return self._session
+
+            headers = {
+                "User-Agent": "OkCdn-Python-Client/4.0.0",
+                "Accept": "application/json",
+                "X-OK-Token": self.auth_token,
+                **self.custom_headers
+            }
+
+            connector = aiohttp.TCPConnector(ssl=False)
+            self._session = aiohttp.ClientSession(
+                connector=connector,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=self.timeout)
+            )
+            return self._session
+
+    async def close(self):
+        """Закрывает клиентскую HTTP-сессию"""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+    def _resolve_chat_id(self, chat_id: Optional[Union[int, str]]) -> int:
+        target = chat_id if chat_id is not None else self.default_chat_id
+        if target is None:
+            raise ValueError("chat_id не указан. Передайте chat_id в метод или укажите default_chat_id при создании OkCdn")
+        try:
+            return int(target)
+        except ValueError:
+            raise ValueError(f"Некорректный chat_id: {target}. Должно быть число.")
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        custom_timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        session = await self._ensure_session()
+        url = f"{self.server_url}{path}"
+        req_timeout = aiohttp.ClientTimeout(total=custom_timeout or self.timeout)
+
+        last_error = None
+        for attempt in range(self.max_retries):
+            try:
+                async with session.request(
+                    method=method,
+                    url=url,
+                    json=json_data,
+                    params=params,
+                    data=data,
+                    timeout=req_timeout
+                ) as resp:
+                    status_code = resp.status
+                    try:
+                        res_json = await resp.json()
+                    except Exception:
+                        text = await resp.text()
+                        res_json = {"error": text}
+
+                    if status_code == 200:
+                        return res_json
+                    elif status_code == 401:
+                        raise OkCdnAuthError(
+                            res_json.get("detail") or res_json.get("error") or "Ошибка авторизации OK.ru",
+                            status_code=status_code,
+                            response=res_json
+                        )
+                    elif 400 <= status_code < 500:
+                        raise OkCdnBadRequestError(
+                            res_json.get("detail") or res_json.get("error") or f"Некорректный запрос (HTTP {status_code})",
+                            status_code=status_code,
+                            response=res_json
+                        )
+                    elif status_code >= 500:
+                        last_error = OkCdnServerError(
+                            res_json.get("detail") or res_json.get("error") or f"Ошибка сервера (HTTP {status_code})",
+                            status_code=status_code,
+                            response=res_json
+                        )
+            except (asyncio.TimeoutError, aiohttp.ServerTimeoutError):
+                last_error = OkCdnTimeoutError(f"Превышен таймаут {self.timeout}с при обращении к {url}")
+            except (aiohttp.ClientError, aiohttp.ClientConnectionError) as e:
+                last_error = OkCdnError(f"Сетевая ошибка подключения к {url}: {e}")
+
+            if attempt < self.max_retries - 1:
+                await asyncio.sleep(1.0 * (2 ** attempt))
+
+        if last_error:
+            raise last_error
+        raise OkCdnError("Неизвестная ошибка запроса")
+
+    # -------------------------------------------------------------------------
+    # 1. ОТПРАВКА ОДИНОЧНОГО ВИДЕО (send_video)
+    # -------------------------------------------------------------------------
+
+    async def send_video(
+        self,
+        link: str,
+        chat_id: Optional[Union[int, str]] = None,
+        caption: Optional[str] = None,
+        title: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Загружает видео/поток (DASH .mpd, HLS .m3u8, direct MP4) в OK.ru через сервер
+        и возвращает прямые CDN-ссылки, метаданные и метрики.
+
+        :param link: URL видеофайла или потока (.mpd, .m3u8, .mp4).
+        :param chat_id: ID чата OK.ru (если не указан default_chat_id).
+        :param caption: Подпись к видео.
+        :param title: Имя/название файла.
+        :return: Словарь со всеми CDN ссылками и метаданными.
+        """
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "link": link,
+            "chat_id": cid,
+            "caption": caption,
+            "title": title
+        }
+        return await self._request("POST", "/api/v1/video/send", json_data=payload)
+
+    # -------------------------------------------------------------------------
+    # 2. ПАКЕТНАЯ ОТПРАВКА СПИСКА ВИДЕО (send_videos) -> { url: video_data }
+    # -------------------------------------------------------------------------
+
+    async def send_videos(
+        self,
+        links: List[str],
+        chat_id: Optional[Union[int, str]] = None,
+        captions: Optional[List[str]] = None,
+        titles: Optional[List[str]] = None,
+        concurrency: int = 3
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Параллельно отправляет массив видео в OK.ru и возвращает словарь { url: video_data }.
+
+        :param links: Список URL видеофайлов/потоков.
+        :param chat_id: ID чата OK.ru.
+        :param captions: Список подписей.
+        :param titles: Список названий.
+        :param concurrency: Количество параллельных потоков перекачки на сервере.
+        :return: Словарь вида { "https://...": { "success": True, "mp4": "...", ... } }
+        """
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "links": links,
+            "chat_id": cid,
+            "captions": captions,
+            "titles": titles,
+            "concurrency": concurrency
+        }
+        return await self._request("POST", "/api/v1/video/send-batch", json_data=payload)
+
+    # -------------------------------------------------------------------------
+    # 3. МГНОВЕННОЕ ОБНОВЛЕНИЕ ПРЯМЫХ ССЫЛОК (refresh_links)
+    # -------------------------------------------------------------------------
+
+    async def refresh_links(
+        self,
+        video_id: Union[int, str],
+        chat_id: Optional[Union[int, str]] = None,
+        message_id: Optional[Union[int, str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Мгновенно (<0.5с) синхронно обновляет и возвращает свежие прямые CDN-ссылки (MP4, HLS, DASH, Poster).
+
+        :param video_id: ID видео в OK.ru.
+        :param chat_id: ID чата OK.ru.
+        :param message_id: ID сообщения OK.ru (опционально).
+        :return: Словарь со свежими ссылками и датой истечения expires_at.
+        """
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "video_id": video_id,
+            "chat_id": cid,
+            "message_id": message_id
+        }
+        return await self._request("POST", "/api/v1/video/refresh", json_data=payload)
+
+    # -------------------------------------------------------------------------
+    # 4. DIRECT UPLOAD (ПРЯМАЯ ЗАГРУЗКА В CDN OK.RU)
+    # -------------------------------------------------------------------------
+
+    async def prepare_direct_upload(
+        self,
+        chat_id: Optional[Union[int, str]] = None,
+        media_type: str = "VIDEO"
+    ) -> Dict[str, Any]:
+        """
+        Запрашивает у сервера прямую ссылку upload_url, токен и video_id от OK CDN.
+        """
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "chat_id": cid,
+            "media_type": media_type
+        }
+        return await self._request("POST", "/api/v1/upload/direct-prepare", json_data=payload)
+
+    async def finalize_direct_upload(
+        self,
+        token: str,
+        video_id: Optional[Union[int, str]] = None,
+        chat_id: Optional[Union[int, str]] = None,
+        caption: Optional[str] = None,
+        title: Optional[str] = None,
+        media_type: str = "VIDEO"
+    ) -> Dict[str, Any]:
+        """
+        Публикует загруженный токен в чат OK.ru и извлекает прямые ссылки.
+        """
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "token": token,
+            "video_id": video_id,
+            "chat_id": cid,
+            "caption": caption,
+            "title": title,
+            "media_type": media_type
+        }
+        return await self._request("POST", "/api/v1/upload/direct-finalize", json_data=payload)
+
+    # -------------------------------------------------------------------------
+    # 5. УНИВЕРСАЛЬНАЯ ЗАГРУЗКА ЛОКАЛЬНОГО ФАЙЛА (upload_file)
+    # -------------------------------------------------------------------------
+
+    async def upload_file(
+        self,
+        file_path: str,
+        chat_id: Optional[Union[int, str]] = None,
+        caption: Optional[str] = None,
+        title: Optional[str] = None,
+        media_type: str = "VIDEO"
+    ) -> Dict[str, Any]:
+        """
+        Универсальный метод загрузки локального файла с диска:
+        1. Получает direct-upload токен и URL от сервера.
+        2. Напрямую выгружает байты в OK CDN без нагрузки на сервер.
+        3. Финализирует публикацию в чате и возвращает готовые CDN-ссылки.
+        В случае сбоя direct upload делает автоматический fallback на серверный multipart endpoint.
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Файл не найден: {file_path}")
+
+        cid = self._resolve_chat_id(chat_id)
+        fname = title or os.path.basename(file_path)
+
+        # 1. Попытка Direct Upload
+        try:
+            prep = await self.prepare_direct_upload(chat_id=cid, media_type=media_type)
+            if prep.get("success") and prep.get("upload_url"):
+                upload_url = prep["upload_url"]
+                token = prep.get("token")
+                vid = prep.get("video_id")
+
+                session = await self._ensure_session()
+                data = aiohttp.FormData()
+                with open(file_path, "rb") as f:
+                    file_bytes = f.read()
+                data.add_field("file", file_bytes, filename=fname, content_type="video/mp4" if media_type == "VIDEO" else "image/jpeg")
+                if token:
+                    data.add_field("token", token)
+
+                async with session.post(upload_url, data=data, timeout=aiohttp.ClientTimeout(total=300)) as resp:
+                    if resp.status == 200:
+                        return await self.finalize_direct_upload(
+                            token=token,
+                            video_id=vid,
+                            chat_id=cid,
+                            caption=caption,
+                            title=fname,
+                            media_type=media_type
+                        )
+        except Exception:
+            pass
+
+        # 2. Fallback: Загрузка через Server Multipart Endpoint
+        session = await self._ensure_session()
+        data = aiohttp.FormData()
+        with open(file_path, "rb") as f:
+            file_bytes = f.read()
+        data.add_field("file", file_bytes, filename=fname, content_type="video/mp4")
+        data.add_field("chat_id", str(cid))
+        if caption:
+            data.add_field("caption", caption)
+        if fname:
+            data.add_field("title", fname)
+        data.add_field("media_type", media_type)
+
+        return await self._request("POST", "/api/v1/upload/file", data=data)
+
+    # -------------------------------------------------------------------------
+    # 6. ОТПРАВКА ФОТО И АУДИО (send_photo, send_audio)
+    # -------------------------------------------------------------------------
+
+    async def send_photo(
+        self,
+        link: str,
+        chat_id: Optional[Union[int, str]] = None,
+        caption: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Отправляет фото по ссылке в чат OK.ru"""
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "link": link,
+            "chat_id": cid,
+            "caption": caption
+        }
+        return await self._request("POST", "/api/v1/media/photo/send", json_data=payload)
+
+    async def send_audio(
+        self,
+        link: str,
+        chat_id: Optional[Union[int, str]] = None,
+        caption: Optional[str] = None,
+        title: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Отправляет аудиофайл с автоматической переупаковкой в MP4 Zero-Disk"""
+        cid = self._resolve_chat_id(chat_id)
+        payload = {
+            "link": link,
+            "chat_id": cid,
+            "caption": caption,
+            "title": title
+        }
+        return await self._request("POST", "/api/v1/media/audio/send", json_data=payload)
+
+    # -------------------------------------------------------------------------
+    # 7. СТАТИСТИКА И HEALTHCHECK (get_stats, health)
+    # -------------------------------------------------------------------------
+
+    async def get_stats(self) -> Dict[str, Any]:
+        """Получает статистику аккаунта и статус пула сессий сервера"""
+        return await self._request("GET", "/api/v1/stats")
+
+    async def health(self) -> Dict[str, Any]:
+        """Проверяет доступность сервера"""
+        return await self._request("GET", "/health")

okcdn-4.0.0/okcdn/exceptions.py

@@ -0,0 +1,26 @@
+class OkCdnError(Exception):
+    """Базовое исключение библиотеки OkCdn"""
+    def __init__(self, message: str, status_code: int = 0, response: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response or {}
+
+
+class OkCdnAuthError(OkCdnError):
+    """Ошибка авторизации токена OK.ru"""
+    pass
+
+
+class OkCdnServerError(OkCdnError):
+    """Ошибка сервера OKCdn (5xx)"""
+    pass
+
+
+class OkCdnBadRequestError(OkCdnError):
+    """Ошибка параметров запроса (4xx)"""
+    pass
+
+
+class OkCdnTimeoutError(OkCdnError):
+    """Превышено время ожидания ответа от сервера"""
+    pass

okcdn-4.0.0/okcdn.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: okcdn
+Version: 4.0.0
+Summary: High-performance Python client for OKCdn video & media streaming engine
+Author: OKCdn Team
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/your-username/OKCdn
+Project-URL: Documentation, https://github.com/your-username/OKCdn#readme
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+Dynamic: requires-python
+
+# OkCdn Python Client SDK
+
+Легковесный, быстрый и асинхронный клиент для взаимодействия с сервером **OKCdn**.
+
+## ✨ Особенности
+- **Zero-Disk RAM Streaming**: мгновенная перекачка MPEG-DASH (.mpd), HLS (.m3u8), Direct MP4 в OK.ru.
+- **Мгновенное обновление ссылок**: актуализация протухших CDN-ссылок (`<0.5s`).
+- **Пакетная параллельная загрузка**: отправка списков видео с контролируемым `concurrency`.
+- **Автоматический Retry**: устойчивость к временным сетевым сбоям с экспоненциальной задержкой.
+- **Поддержка мультиаккаунтов**: сессии кэшируются на сервере с 30-минутным умным авто-отключением сокетов.
+
+## 📦 Установка
+
+```bash
+pip install okcdn
+```
+
+## 🚀 Быстрый старт
+
+```python
+import asyncio
+from okcdn import OkCdn
+
+async def main():
+    # Инициализация клиента (можно передать параметры или задать переменные окружения)
+    async with OkCdn(
+        server_url="https://your-okcdn-server.koyeb.app",
+        auth_token="YOUR_OK_AUTHCODE_HERE",
+        default_chat_id=123456789
+    ) as cdn:
+
+        # 1. Отправка одиночного видео (HLS / DASH / MP4)
+        video = await cdn.send_video(
+            link="https://example.com/stream.m3u8",
+            caption="Мой видеострим",
+            title="video_01.mp4"
+        )
+        print("Прямой MP4:", video["mp4"])
+        print("HLS ссылка:", video["hls"])
+        print("Video ID:", video["video_id"])
+
+        # 2. Мгновенное обновление ссылок
+        fresh = await cdn.refresh_links(video_id=video["video_id"])
+        print("Обновленная ссылка:", fresh["mp4"])
+        print("Истекает через:", fresh["expires_in_sec"], "сек")
+
+        # 3. Загрузка локального файла
+        uploaded = await cdn.upload_file(
+            file_path="local_video.mp4",
+            caption="Прямая загрузка"
+        )
+        print("Загружено:", uploaded["direct"])
+
+        # 4. Пакетная параллельная отправка
+        batch = await cdn.send_videos(
+            links=[
+                "https://site.com/video1.mp4",
+                "https://site.com/video2.mp4"
+            ],
+            concurrency=2
+        )
+        for url, data in batch.items():
+            print(f"{url} -> {data.get('mp4')}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## ⚙️ Переменные окружения
+
+Вы можете задать переменные окружения, чтобы не указывать их в коде:
+- `OKCDN_SERVER_URL` — адрес запущенного сервера (по умолчанию `http://localhost:8000`)
+- `ACCOUNT_TOKEN` или `OKCDN_AUTH_TOKEN` — токен авторизации OK.ru (`AUTHCODE`)
+- `CHAT_ID` или `OKCDN_CHAT_ID` — ID чата по умолчанию

okcdn-4.0.0/okcdn.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+okcdn/__init__.py
+okcdn/client.py
+okcdn/exceptions.py
+okcdn.egg-info/PKG-INFO
+okcdn.egg-info/SOURCES.txt
+okcdn.egg-info/dependency_links.txt
+okcdn.egg-info/requires.txt
+okcdn.egg-info/top_level.txt

okcdn-4.0.0/okcdn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

okcdn-4.0.0/okcdn.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.8.0

okcdn-4.0.0/okcdn.egg-info/top_level.txt

@@ -0,0 +1 @@
+okcdn

okcdn-4.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "okcdn"
+version = "4.0.0"
+description = "High-performance Python client for OKCdn video & media streaming engine"
+readme = "README.md"
+authors = [{ name = "OKCdn Team" }]
+license = "MIT"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Internet :: WWW/HTTP"
+]
+dependencies = [
+    "aiohttp>=3.8.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/your-username/OKCdn"
+Documentation = "https://github.com/your-username/OKCdn#readme"

okcdn-4.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

okcdn-4.0.0/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="okcdn",
+    version="4.0.0",
+    packages=find_packages(),
+    install_requires=[
+        "aiohttp>=3.8.0",
+    ],
+    python_requires=">=3.8",
+)