unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_sdk/src/clients/python_http/services/async_SystemHealth_service.py

@@ -1,123 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def system_health_check_api_v1_health__get(api_config_override: Optional[APIConfig] = None) -> HealthResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/health/"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return HealthResponse(**response.json()) if response.json() is not None else HealthResponse()
-
-
-async def health_statistics_api_v1_health_statistics_get(
-    api_config_override: Optional[APIConfig] = None,
-) -> SuccessResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/health/statistics"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def quick_health_status_api_v1_health_status_get(
-    api_config_override: Optional[APIConfig] = None,
-) -> SuccessResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/health/status"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def legacy_health_check_health_get(api_config_override: Optional[APIConfig] = None) -> Any:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/health"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return response.json()

unrealon_sdk/src/clients/python_http/services/async_WebSocketAPI_service.py

@@ -1,200 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def broadcast_to_room_api_v1_ws_broadcast__room__post(
-    room: str, data: BroadcastMessage, api_config_override: Optional[APIConfig] = None
-) -> BroadcastResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/broadcast/{room}"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request("post", httpx.URL(path), headers=headers, params=query_params, json=data.model_dump())
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return BroadcastResponse(**response.json()) if response.json() is not None else BroadcastResponse()
-
-
-async def get_connections_api_v1_ws_connections_get(
-    api_config_override: Optional[APIConfig] = None,
-) -> ConnectionsResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/connections"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return ConnectionsResponse(**response.json()) if response.json() is not None else ConnectionsResponse()
-
-
-async def websocket_health_check_api_v1_ws_health_get(api_config_override: Optional[APIConfig] = None) -> HealthStatus:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/health"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return HealthStatus(**response.json()) if response.json() is not None else HealthStatus()
-
-
-async def broadcast_system_notification_api_v1_ws_notification_system_post(
-    title: str, content: str, priority: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> SystemNotificationResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/notification/system"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {"title": title, "content": content, "priority": priority}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "post",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return (
-        SystemNotificationResponse(**response.json()) if response.json() is not None else SystemNotificationResponse()
-    )
-
-
-async def send_to_developer_api_v1_ws_send_developer__developer_id__post(
-    developer_id: str, data: BroadcastMessage, api_config_override: Optional[APIConfig] = None
-) -> DeveloperMessageResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/send/developer/{developer_id}"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request("post", httpx.URL(path), headers=headers, params=query_params, json=data.model_dump())
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return DeveloperMessageResponse(**response.json()) if response.json() is not None else DeveloperMessageResponse()
-
-
-async def send_to_parser_api_v1_ws_send_parser__parser_id__post(
-    parser_id: str, data: BroadcastMessage, api_config_override: Optional[APIConfig] = None
-) -> ParserMessageResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/send/parser/{parser_id}"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request("post", httpx.URL(path), headers=headers, params=query_params, json=data.model_dump())
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return ParserMessageResponse(**response.json()) if response.json() is not None else ParserMessageResponse()
-
-
-async def websocket_stats_api_v1_ws_stats_get(api_config_override: Optional[APIConfig] = None) -> ConnectionStats:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/ws/stats"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return ConnectionStats(**response.json()) if response.json() is not None else ConnectionStats()

unrealon_sdk/src/clients/python_http/services/async_admin_service.py

@@ -1,125 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def broadcast_message_api_v1_admin_broadcast_post(
-    data: BroadcastMessageRequest,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> BroadcastResultResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/admin/broadcast"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-        **({"authorization": authorization} if authorization is not None else {}),
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request("post", httpx.URL(path), headers=headers, params=query_params, json=data.model_dump())
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return BroadcastResultResponse(**response.json()) if response.json() is not None else BroadcastResultResponse()
-
-
-async def manage_maintenance_mode_api_v1_admin_maintenance_post(
-    data: MaintenanceModeRequest,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> MaintenanceStatusResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/admin/maintenance"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-        **({"authorization": authorization} if authorization is not None else {}),
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request("post", httpx.URL(path), headers=headers, params=query_params, json=data.model_dump())
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return MaintenanceStatusResponse(**response.json()) if response.json() is not None else MaintenanceStatusResponse()
-
-
-async def get_maintenance_status_api_v1_admin_maintenance_status_get(
-    authorization: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> MaintenanceStatusResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/admin/maintenance/status"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-        **({"authorization": authorization} if authorization is not None else {}),
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return MaintenanceStatusResponse(**response.json()) if response.json() is not None else MaintenanceStatusResponse()
-
-
-async def get_admin_service_stats_api_v1_admin_stats_get(
-    authorization: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> ServiceStatsResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/admin/stats"
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": f"Bearer { api_config.get_access_token() }",
-        **({"authorization": authorization} if authorization is not None else {}),
-    }
-    query_params: Dict[str, Any] = {}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "get",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 200:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return ServiceStatsResponse(**response.json()) if response.json() is not None else ServiceStatsResponse()

unrealon_sdk/src/clients/python_websocket/__init__.py

@@ -1,28 +0,0 @@
-"""
-Python WebSocket Client for UnrealServer
-
-Asyncio-based WebSocket client with automatic reconnection,
-event routing, and full type safety.
-
-Usage:
-    from python_websocket import WebSocketClient, SocketEvent
-    
-    client = WebSocketClient("ws://localhost:8000")
-    await client.connect()
-    
-    await client.emit(SocketEvent.PING, {"message": "hello"})
-"""
-
-__version__ = "1.0.0"
-
-from .client import WebSocketClient, WebSocketConfig, ConnectionState, WebSocketRoutes
-from .events import SocketEvent, EventType
-
-__all__ = [
-    "WebSocketClient",
-    "WebSocketConfig", 
-    "ConnectionState",
-    "WebSocketRoutes",
-    "SocketEvent",
-    "EventType",
-]