videohub-python 1.1.1__py3-none-any.whl

videohub/__init__.py

@@ -0,0 +1,4 @@
+from .client import Client
+from .constants import SDK_VERSION
+
+__all__ = ["Client", "SDK_VERSION"]

videohub/client.py

@@ -0,0 +1,75 @@
+from .config import VideoHubConfig
+from .http import HTTPClient
+from .constants import WS_URL
+
+from .services.auth import AuthService
+from .services.rooms import RoomService
+from .services.calls import CallService
+from .services.admin import AdminService
+
+from .ws import WSClient
+
+import asyncio
+
+
+class Client:
+
+    def __init__(
+        self,
+        api_key: str,
+        app_id: str,
+        app_secret: str,
+        app_platform: str,
+        app_identifier: str,
+        timeout: int = 10,
+        app_name: str | None = None,
+        domain: str | None = None,
+        allow_video: bool = True,
+        allow_audio: bool = True,
+        allow_screen: bool = True,
+        debug: bool = False,
+    ):
+
+        self.config = VideoHubConfig(
+            api_key=api_key,
+            app_id=app_id,
+            app_secret=app_secret,
+            app_platform=app_platform,
+            app_identifier=app_identifier,
+            timeout=timeout,
+            app_name=app_name,
+            domain=domain,
+            allow_video=allow_video,
+            allow_audio=allow_audio,
+            allow_screen=allow_screen,
+            debug=debug,
+        )
+
+        self.http = HTTPClient(self.config)
+
+        # services
+        self.auth = AuthService(self.http)
+        self.rooms = RoomService(self.http)
+        self.calls = CallService(self.http, self.config)
+        self.admin = AdminService(self.http)
+        self.ws_url = WS_URL
+        # realtime
+        self.ws = WSClient(WS_URL)
+
+    async def close(self):
+        await self.http.close()
+        await self.ws.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    def __del__(self):
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                loop.create_task(self.close())
+        except:
+            pass

videohub/config.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class VideoHubConfig:
+
+    api_key: str
+    app_id: str
+    app_secret: str
+    app_platform: str
+    app_identifier: str
+
+    timeout: int = 10
+
+    app_name: Optional[str] = None
+    domain: Optional[str] = None
+
+    allow_video: bool = True
+    allow_audio: bool = True
+    allow_screen: bool = True
+
+    debug: bool = False

videohub/constants.py

@@ -0,0 +1,4 @@
+API_BASE = "https://videohub.askjitendra.com/v1"
+WS_URL   = "wss://streaming.askjitendra.com"
+SDK_NAME = "videohub-python"
+SDK_VERSION = "1.0.0"

videohub/exceptions.py

@@ -0,0 +1,14 @@
+class VideoHubError(Exception):
+    pass
+
+
+class AuthenticationError(VideoHubError):
+    pass
+
+
+class APIRequestError(VideoHubError):
+    pass
+
+
+class ValidationError(VideoHubError):
+    pass

videohub/http.py

@@ -0,0 +1,135 @@
+import asyncio
+from typing import Optional
+
+import httpx
+
+from .constants import API_BASE, SDK_NAME, SDK_VERSION
+from .exceptions import APIRequestError
+from .utils.validators import RequestValidator
+
+
+class HTTPClient:
+
+    def __init__(self, config):
+        self.config = config
+        self.validator = RequestValidator(config)
+
+        # lazy client
+        self._client: Optional[httpx.AsyncClient] = None
+
+
+    def _get_client(self):
+
+        if self._client is None:
+
+            limits = httpx.Limits(
+                max_connections=100,
+                max_keepalive_connections=20
+            )
+
+            self._client = httpx.AsyncClient(
+                base_url=API_BASE,
+                timeout=self.config.timeout,
+                limits=limits
+            )
+
+        return self._client
+
+    
+
+    def _build_headers(self, auth_required: bool):
+
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": f"{SDK_NAME}/{SDK_VERSION}",
+            "X-SDK-Version": SDK_VERSION,
+        }
+
+        if auth_required:
+            headers.update(self.validator.build_headers())
+
+        return headers
+
+    
+
+    async def _request(self, method: str, endpoint: str, **kwargs):
+
+        retries = 3
+        response = None
+
+        client = self._get_client()
+
+        for attempt in range(retries):
+            try:
+
+                response = await client.request(
+                    method,
+                    endpoint,
+                    **kwargs
+                )
+
+                if response.status_code < 500:
+                    break
+
+            except httpx.RequestError as e:
+
+                if attempt == retries - 1:
+                    raise APIRequestError(f"Network error: {str(e)}")
+
+                await asyncio.sleep(2 ** attempt * 0.2)
+
+        if response is None:
+            raise APIRequestError("No response from server")
+
+        if response.status_code >= 400:
+            try:
+                error = response.json()
+                message = error.get("error") or error.get("message") or str(error)
+                raise APIRequestError(message)
+            except Exception:
+                raise APIRequestError(response.text)
+
+        try:
+            return response.json()
+        except Exception:
+            return response.text
+
+    
+
+    async def post(self, endpoint: str, payload: dict, auth_required: bool = True):
+
+        headers = self._build_headers(auth_required)
+
+        if getattr(self.config, "debug", False):
+            print(f"[VideoHub SDK] POST {endpoint}")
+            print("Payload:", payload)
+
+        return await self._request(
+            "POST",
+            endpoint,
+            json=payload,
+            headers=headers
+        )
+
+    async def get(self, endpoint: str, params: Optional[dict] = None, auth_required: bool = True):
+
+        headers = self._build_headers(auth_required)
+
+        if getattr(self.config, "debug", False):
+            print(f"[VideoHub SDK] GET {endpoint}")
+            print("Params:", params)
+
+        return await self._request(
+            "GET",
+            endpoint,
+            params=params,
+            headers=headers
+        )
+
+    
+
+    async def close(self):
+
+        if self._client:
+            await self._client.aclose()
+            self._client = None

videohub/services/admin.py

@@ -0,0 +1,39 @@
+class AdminService:
+
+    def __init__(self, http):
+        self.http = http
+
+    async def kick(self, room: str, identity: str):
+
+        return await self.http.post(
+            "/client/va/kick",
+            {
+                "room_name": room,
+                "identity": identity
+            },
+            auth_required=True
+        )
+        
+        
+
+    async def mute(self, room: str, identity: str):
+
+        return await self.http.post(
+            "/client/video-hub/mute",
+            {
+                "room_name": room,
+                "identity": identity
+            },
+            auth_required=True
+        )
+        
+        
+    async def room_cleaner(self, room: str):
+        
+        return await self.http.post(
+            "/client/video-hub/end",
+            {
+                "room_name": room,
+            },
+            auth_required=True
+        )

videohub/services/auth.py

@@ -0,0 +1,15 @@
+class AuthService:
+
+    def __init__(self, http):
+        self.http = http
+
+    async def login(self, login: str, password: str):
+
+        return await self.http.post(
+            "/auth/login",
+            {
+                "login": login,
+                "password": password
+            },
+            auth_required=False
+        )

videohub/services/calls.py

@@ -0,0 +1,95 @@
+from ..exceptions import ValidationError
+
+
+class CallService:
+    def __init__(self, http, config):
+        self.http = http
+        self.config = config
+
+    
+    async def start(self, **payload):
+
+        media = payload.pop("media", None)
+
+        if media:
+            audio = media.get("audio", True)
+            video = media.get("video", True)
+            screen = media.get("screen", False)
+        else:
+            audio = payload.pop("audio", True)
+            video = payload.pop("video", True)
+            screen = payload.pop("screen", False)
+
+        if video and not self.config.allow_video:
+            raise ValidationError("Video feature not allowed")
+
+        if audio and not self.config.allow_audio:
+            raise ValidationError("Audio feature not allowed")
+
+        if screen and not self.config.allow_screen:
+            raise ValidationError("Screen sharing not allowed")
+
+        payload["media"] = {
+            "audio": audio,
+            "video": video,
+            "screen": screen,
+        }
+
+        return await self.http.post(
+            "/client/calls/start",
+            payload,
+            auth_required=True
+    )
+
+   
+    async def host_token(self, call_id: str):
+        return await self.http.post(
+            "/client/calls/token",
+            {"call_id": call_id},
+            auth_required=True
+        )
+
+    
+    async def guest_token(self, call_id: str):
+        return await self.http.post(
+            "/call/guest/token",
+            {"call_id": call_id},
+            auth_required=False
+        )
+
+    
+    async def end(self, call_id: str):
+        return await self.http.post(
+            "/client/calls/end",
+            {"call_id": call_id},
+            auth_required=True
+        )
+
+    
+    async def mute_user(self, call_id: str, identity: str, mute: bool = True):
+        return await self.http.post(
+            f"/client/calls/{call_id}/mute",
+            {"identity": identity, "mute": mute},
+            auth_required=True
+        )
+
+    async def video_off_user(self, call_id: str, identity: str, disable: bool = True):
+        return await self.http.post(
+            f"/client/calls/{call_id}/video-off",
+            {"identity": identity, "disable": disable},
+            auth_required=True
+        )
+
+    async def screen_off_user(self, call_id: str, identity: str):
+        return await self.http.post(
+            f"/client/calls/{call_id}/screen-off",
+            {"identity": identity},
+            auth_required=True
+        )
+
+    async def kick_user(self, call_id: str, identity: str):
+        return await self.http.post(
+            f"/client/calls/{call_id}/kick",
+            {"identity": identity},
+            auth_required=True
+        )

videohub/services/rooms.py

@@ -0,0 +1,35 @@
+class RoomService:
+
+    def __init__(self, http):
+        self.http = http
+
+    async def create(self, **payload):
+
+        if "room_name" not in payload:
+            raise ValueError("room_name is required")
+
+        payload.setdefault("mode", "df_video_party")
+        payload.setdefault("max_participants", 5)
+
+        return await self.http.post(
+            "/client/create/rooms",
+            payload,
+            auth_required=True
+    )
+
+    async def host_token(self, room_name: str):
+
+        return await self.http.post(
+            "/client/rooms/token/host",
+            {"room_name": room_name},
+            auth_required=True
+        )
+        
+
+    async def guest_token(self, room_name: str):
+
+        return await self.http.post(
+            "/rooms/token/guest",
+            {"room_name": room_name},
+            auth_required=False
+        )

videohub/utils/validators.py

@@ -0,0 +1,47 @@
+from ..exceptions import ValidationError
+
+
+class RequestValidator:
+
+    def __init__(self, config):
+        self.config = config
+        
+        
+    def _validate(self):
+        
+        if not self.config.api_key:
+            raise ValidationError("API key is required")
+
+        if not self.config.app_id:
+            raise ValidationError("App ID is required")
+
+        if not self.config.app_secret:
+            raise ValidationError("App secret is required")
+
+        if not self.config.app_platform:
+            raise ValidationError("App platform is required")
+
+        if not self.config.app_identifier:
+            raise ValidationError("App identifier is required")
+        
+
+    def build_headers(self):
+        
+        self._validate()
+
+        headers = {
+            "X-API-Key": self.config.api_key,
+            "X-App-ID": self.config.app_id,
+            "X-App-Secret": self.config.app_secret,
+            "X-App-Platform": self.config.app_platform,
+            "X-App-Identifier": self.config.app_identifier,
+            
+        }
+
+        if self.config.app_name:
+            headers["X-App-Name"] = self.config.app_name
+
+        if self.config.domain:
+            headers["X-Domain"] = self.config.domain
+
+        return headers

videohub/ws.py

@@ -0,0 +1,30 @@
+import json
+import websockets
+
+
+class WSClient:
+
+    def __init__(self, url: str):
+        self.url = url
+        self.ws = None
+
+    async def connect(self, token: str):
+        self.ws = await websockets.connect(f"{self.url}?token={token}")
+
+    async def send(self, data: dict):
+        if not self.ws:
+            raise RuntimeError("WebSocket not connected")
+
+        await self.ws.send(json.dumps(data))
+
+    async def receive(self):
+        if not self.ws:
+            raise RuntimeError("WebSocket not connected")
+
+        msg = await self.ws.recv()
+        return json.loads(msg)
+
+    async def close(self):
+        if self.ws:
+            await self.ws.close()
+            self.ws = None

videohub_python-1.1.1.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: videohub-python
+Version: 1.1.1
+Summary: Official VideoHub Python SDK for building video, audio, and screen sharing applications.
+Author-email: Letscms <videohubsupport@letscms.com>
+License: Copyright (c) 2026 VideoHub (https://github.com/letscms/videohub-python)
+        
+        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.
+Project-URL: Homepage, https://videohub.askjitendra.com
+Project-URL: Documentation, https://docs.videohub.askjitendra.com
+Project-URL: Repository, https://github.com/letscms/videohub-python
+Project-URL: Issues, https://github.com/letscms/videohub-python/issues
+Keywords: videohub,video sdk,webrtc,video calling,audio rooms,screen sharing,pk battle
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25
+Dynamic: license-file
+
+# VideoHub Python SDK
+
+Official Python SDK for **VideoHub** – build video calls, audio rooms, and real-time communication applications easily.
+
+VideoHub helps developers integrate **video conferencing, audio rooms, screen sharing, and real-time communication** into their applications with simple APIs.
+
+---
+
+## Installation
+
+Install the SDK from PyPI:
+
+```bash
+pip install videohub-python
+```
+
+---
+
+## Requirements
+
+* Python **3.9+**
+* VideoHub API Key
+* App credentials (App ID & App Secret)
+
+---
+
+## Quick Start
+
+```python
+from videohub import VideoHubClient, VideoHubConfig
+
+config = VideoHubConfig(
+    api_key="vhub_live_xxxxxxxxx",
+    app_id="your_app_id",
+    app_secret="your_app_secret",
+    app_platform="web",
+    app_identifier="example.com"
+)
+
+client = VideoHubClient(config)
+
+# Example: create a room token
+token = client.rooms.create_token(
+    room_name="my-room",
+    user_id="user_123"
+)
+
+print(token)
+```
+
+---
+
+## Authentication
+
+All requests require the following credentials:
+
+| Field          | Description                          |
+| -------------- | ------------------------------------ |
+| API Key        | Account authentication key           |
+| App ID         | Unique application identifier        |
+| App Secret     | Secret used for request verification |
+| App Platform   | `web`, `android`, or `ios`           |
+| App Identifier | Domain or package name               |
+
+Example configuration:
+
+```python
+config = VideoHubConfig(
+    api_key="vhub_live_xxxxx",
+    app_id="app_uuid",
+    app_secret="secret_xxxxx",
+    app_platform="web",
+    app_identifier="example.com"
+)
+```
+
+---
+
+## Features
+
+The VideoHub Python SDK supports:
+
+* Video calling
+* Audio rooms
+* Screen sharing
+* Room management
+* Call management
+* Admin APIs
+* Secure authentication
+
+---
+
+## Example: Create Room
+
+```python
+room = client.rooms.create(
+    room_name="demo-room",
+    max_participants=5
+)
+
+print(room)
+```
+
+---
+
+## Example: Generate User Token
+
+```python
+token = client.rooms.create_token(
+    room_name="demo-room",
+    user_id="user_123"
+)
+
+print(token)
+```
+
+---
+
+## Error Handling
+
+The SDK raises structured exceptions for API errors.
+
+```python
+from videohub.exceptions import VideoHubError
+
+try:
+    client.rooms.create("room1")
+except VideoHubError as e:
+    print(e)
+```
+
+---
+
+## Project Structure
+
+```
+videohub/
+│
+├── client.py
+├── config.py
+├── constants.py
+├── exceptions.py
+├── http.py
+│
+├── services/
+│   ├── auth.py
+│   ├── rooms.py
+│   ├── calls.py
+│   └── admin.py
+│
+└── utils/
+    └── validators.py
+```
+
+---
+
+## Documentation
+
+Full API documentation is available at:
+
+https://docs.videohub.askjitendra.com
+
+---
+
+## Contributing
+
+Contributions are welcome!
+
+1. Fork the repository
+2. Create a new branch
+3. Submit a pull request
+
+---
+
+## Reporting Issues
+
+If you encounter a bug or want to request a feature, please open an issue:
+
+https://github.com/letscms/videohub-python/issues
+
+---
+
+## License
+
+This project is licensed under the **MIT License**.

videohub_python-1.1.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+videohub/__init__.py,sha256=M6dI0Q21vy8dDWbEeZp32VgakwweRd3YVrDkHTGB6ko,98
+videohub/client.py,sha256=d81MQ8ca02iGnfON2YQ88OZP_Wg4naMS02svd1Ao7FY,1907
+videohub/config.py,sha256=D3ZdQSQ1RxPlUN2zzpZBJ6aEoRqvrmlemTelvsYTGRI,402
+videohub/constants.py,sha256=pCsSvm0-PZu32DHMt0BLV7MZqCk_xDemXEHp3cSnUeI,144
+videohub/exceptions.py,sha256=eKpCSGCakUv1BEeRWplRNHKY9-KRtFV2JNVU5WhoavA,191
+videohub/http.py,sha256=UgOherO59GB47kNTpSVeuI1Apw5yT9kuR37M5Ke8UOs,3317
+videohub/ws.py,sha256=oKFu3UnpH-gaAo2ip_PW2gP9hI944Z-ZYzwr3l9Y3I0,697
+videohub/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videohub/services/admin.py,sha256=5ww5G8XAOZf9zvSar_FDycGIaEDEAZZRWFz_Mu1Kv64,879
+videohub/services/auth.py,sha256=IIzsYYtVYTnU4i8aNS9KkXUl0ZaM_LAKrf8OatBK9R0,334
+videohub/services/calls.py,sha256=4jSvnINrRaqGqQ0x04FBUgUfqPTICh3rIO6w-TY43jQ,2727
+videohub/services/rooms.py,sha256=g53uBdBnP18c47dlhVfVDV5-UdoA157HNXiGWYKGMYk,861
+videohub/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videohub/utils/validators.py,sha256=TdzEOitAiwAQa5c8qwFglrKGiNJWv6kAowEdmZUHypU,1252
+videohub_python-1.1.1.dist-info/licenses/LICENSE,sha256=pOYQq7qGHhJitw-aDfiflDm7fbiknnItC8HWtgWzPhk,1096
+videohub_python-1.1.1.dist-info/METADATA,sha256=JhwgS_ohYLh-ldjEUhB6-eD48mXnclBEm300-p-WUP8,5663
+videohub_python-1.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+videohub_python-1.1.1.dist-info/top_level.txt,sha256=Ggz9Kw-6DU7kCS7_C4n4bAx13cFeSfiGmolZ86T9dyc,9
+videohub_python-1.1.1.dist-info/RECORD,,

videohub_python-1.1.1.dist-info/WHEEL

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

videohub_python-1.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 VideoHub (https://github.com/letscms/videohub-python)
+
+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.

videohub_python-1.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+videohub