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

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

@@ -1,190 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def list_parsers_api_v1_parsers__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/parsers/"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def register_parser_api_v1_parsers_register_post(
-    data: ParserRegistrationRequest,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> ParserRegistrationResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/parsers/register"
-    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 != 201:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return (
-        ParserRegistrationResponse(**response.json()) if response.json() is not None else ParserRegistrationResponse()
-    )
-
-
-async def get_parser_api_v1_parsers__parser_id__get(
-    parser_id: str, 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/parsers/{parser_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}
-
-    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 delete_parser_api_v1_parsers__parser_id__delete(
-    parser_id: str, authorization: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> None:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/parsers/{parser_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}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await client.request(
-            "delete",
-            httpx.URL(path),
-            headers=headers,
-            params=query_params,
-        )
-
-    if response.status_code != 204:
-        raise HTTPException(response.status_code, f" failed with status code: {response.status_code}")
-
-    return None
-
-
-async def execute_parser_command_api_v1_parsers__parser_id__commands_post(
-    parser_id: str,
-    data: ParserCommandRequest,
-    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/parsers/{parser_id}/commands"
-    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 != 202:
-        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 get_parser_status_api_v1_parsers__parser_id__status_get(
-    parser_id: str, 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/parsers/{parser_id}/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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()

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

@@ -1,289 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async def list_proxies_api_v1_proxies__get(
-    status: Optional[Union[ProxyStatus]] = None,
-    country: Optional[str] = None,
-    provider: Optional[Union[ProxyProvider]] = None,
-    healthy_only: Optional[bool] = None,
-    skip: Optional[int] = None,
-    limit: Optional[int] = None,
-    authorization: Optional[str] = None,
-    api_config_override: Optional[APIConfig] = None,
-) -> ProxyListResponse:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/proxies/"
-    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] = {
-        "status": status,
-        "country": country,
-        "provider": provider,
-        "healthy_only": healthy_only,
-        "skip": skip,
-        "limit": limit,
-    }
-
-    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 ProxyListResponse(**response.json()) if response.json() is not None else ProxyListResponse()
-
-
-async def cleanup_expired_proxies_api_v1_proxies_maintenance_cleanup_post(
-    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/proxies/maintenance/cleanup"
-    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,
-        )
-
-    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 sync_proxies_api_v1_proxies_maintenance_sync_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/proxies/maintenance/sync"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def purchase_proxies_api_v1_proxies_procurement_purchase_post(
-    data: ProxyPurchaseRequest,
-    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/proxies/procurement/purchase"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def report_blocked_proxy_api_v1_proxies_rotation_block_post(
-    data: ProxyBlockRequest,
-    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/proxies/rotation/block"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def request_proxy_rotation_api_v1_proxies_rotation_request_post(
-    data: ProxyRotationRequest,
-    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/proxies/rotation/request"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()
-
-
-async def get_proxy_statistics_api_v1_proxies_statistics_get(
-    authorization: Optional[str] = None, api_config_override: Optional[APIConfig] = None
-) -> Dict[str, Any]:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f"/api/v1/proxies/statistics"
-    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 response.json()
-
-
-async def get_proxy_details_api_v1_proxies__proxy_id__get(
-    proxy_id: str, 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/proxies/{proxy_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}
-
-    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 record_proxy_usage_api_v1_proxies__proxy_id__usage_post(
-    proxy_id: str,
-    data: ProxyUsageRequest,
-    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/proxies/{proxy_id}/usage"
-    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 SuccessResponse(**response.json()) if response.json() is not None else SuccessResponse()

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

@@ -1,189 +0,0 @@
-import json
-from typing import *
-
-import httpx
-
-from ..api_config import APIConfig, HTTPException
-from ..models import *
-
-
-async 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}
-
-    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 LoggingResponse(**response.json()) if response.json() is not None else LoggingResponse()
-
-
-async 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}
-
-    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 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}
-
-    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 LoggingResponse(**response.json()) if response.json() is not None else LoggingResponse()
-
-
-async 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}
-
-    async with httpx.AsyncClient(base_url=base_path, verify=api_config.verify) as client:
-        response = await 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()
-
-
-async 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}
-
-    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 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}
-
-    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()