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

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

@@ -1,187 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-def add_log_entry_api_v1_logging_log_post(
-    data: LoggingRequest,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> LoggingResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/logging/log"
-    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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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 LoggingResponse(**response.json()) if response.json() is not None else LoggingResponse()
-
-
-def list_developer_sessions_api_v1_logging_sessions_get(
-    authorization: Optional[str] = None, 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/logging/sessions"
-    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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-def start_logging_session_api_v1_logging_sessions_start_post(
-    data: SessionStartRequest,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> LoggingResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/logging/sessions/start"
-    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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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 LoggingResponse(**response.json()) if response.json() is not None else LoggingResponse()
-
-
-def terminate_session_api_v1_logging_sessions__session_id__delete(
-    session_id: str, authorization: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> LoggingResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/logging/sessions/{session_id}"
-    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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = client.request(
-            "delete",
-            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 LoggingResponse(**response.json()) if response.json() is not None else LoggingResponse()
-
-
-def get_session_logs_api_v1_logging_sessions__session_id__logs_get(
-    session_id: str,
-    count: Optional[int] = None,
-    authorization: Optional[str] = None,
-    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/logging/sessions/{session_id}/logs"
-    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] = {"count": count}
-
-    query_params = {key: value for (key, value) in query_params.items() if value is not None}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-def get_logging_stats_api_v1_logging_stats_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/logging/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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()

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

@@ -1,119 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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/WebSocketAPI_service.py

@@ -1,198 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-    )
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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/admin_service.py

@@ -1,125 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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()
-
-
-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}
-
-    with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
-        response = 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_http/services/async_None_service.py

@@ -1,35 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def root__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"/"
-    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()