feat: new request listener

Author: robert-nogueira

squarecloud/__init__.py

@@ -1,4 +1,4 @@
 from .client import Client, create_config_file
 from .square import File
 from .errors import *
-from .http.router import Endpoint
+from .http.endpoints import Endpoint

squarecloud/app.py

@@ -1,10 +1,11 @@
 from .data import AppData
 from abc import ABC
-from typing import Literal, TYPE_CHECKING
+from typing import Literal, TYPE_CHECKING, Callable
 from .square import File
 from .data import StatusData, LogsData, FullLogsData, BackupData
-from .http import Response
+from .http import Response, HTTPClient, Endpoint
 from .errors import SquareException
+from .listener import ListenerManager
 
 # avoid circular imports
 if TYPE_CHECKING:
@@ -57,103 +58,111 @@ class Application(AbstractApplication):
     # nine arguments is available in this case
     # pylint: disable=invalid-name
     __slots__ = [
-        '__client',
-        '__http',
-        '__id',
-        '__tag',
-        '__ram',
-        '__lang',
-        '__type',
-        '__cluster',
-        '__is_website',
-        '__avatar',
+        '_client',
+        '_http',
+        '_listener',
+        '_data',
         'cache'
     ]
 
-    def __init__(self, client: 'Client', data: AppData):
-        self.__client: Client = client
-        self.__id: str = data.id
-        self.__tag: str = data.tag
-        self.__ram: int = data.ram
-        self.__lang: Literal['javascript', 'typescript', 'python'] = data.lang
-        self.__type: Literal['free', 'paid'] = data.type
-        self.__cluster: str = data.cluster
-        self.__is_website: bool = data.isWebsite
-        self.__avatar: str = data.avatar
+    def __init__(self, client: 'Client', http: HTTPClient, data: AppData):
+        self._client: 'Client' = client
+        self._http = http
+        self._listener: ListenerManager = ListenerManager(self)
+        self._data = data
         self.cache: AppCache = AppCache()
 
     def __repr__(self):
         return f'<{self.__class__.__name__} tag={self.tag} id={self.id}>'
 
+    @property
+    def data(self):
+        return self._data
+
     @property
     def client(self):
         """client instance"""
-        return self.__client
+        return self._client
 
     @property
     def id(self):
         """application's id"""
-        return self.__id
+        return self.data.id
 
     @property
     def tag(self):
         """application's tag"""
-        return self.__tag
+        return self.data.tag
 
     @property
     def ram(self):
         """application's allocated ram"""
-        return self.__ram
+        return self.data.ram
 
     @property
     def lang(self):
         """application's programing language"""
-        return self.__lang
+        return self.data.lang
 
     @property
     def type(self):
         """application's type"""
-        return self.__type
+        return self.data.type
 
     @property
     def cluster(self):
         """application's cluster"""
-        return self.__cluster
+        return self.data.cluster
 
     @property
     def is_website(self):
         """whether the application is a website"""
-        return self.__is_website
+        return self.data.isWebsite
 
     @property
     def avatar(self):
         """application's avatar"""
-        return self.__avatar
+        return self.data.avatar
+
+    def on_request(self, endpoint: Endpoint) -> Callable:
+        def wrapper(func):
+            self._listener.add_listener(endpoint, func)
+
+        return wrapper
 
     async def logs(self, update_cache: bool = True) -> LogsData:
         """get application's logs"""
-        logs: LogsData = await self.__client.get_logs(self.id)
+        logs: LogsData = await self.client.get_logs(self.id)
+        endpoint: Endpoint = Endpoint.logs()
+        await self._listener.on_request_end(endpoint=endpoint, logs=logs)
         if update_cache:
             self.cache.logs = logs
         return logs
 
     async def full_logs(self, update_cache: bool = True) -> FullLogsData:
         """get application's full logs"""
-        full_logs: FullLogsData = await self.__client.logs_complete(self.id)
+        full_logs: FullLogsData = await self.client.full_logs(self.id)
+        endpoint: Endpoint = Endpoint.full_logs()
+        await self._listener.on_request_end(
+            endpoint=endpoint, full_logs=full_logs)
         if update_cache:
             self.cache.full_logs = full_logs
         return full_logs
 
     async def status(self, update_cache: bool = True) -> StatusData:
         """get application's status"""
-        status: StatusData = await self.__client.app_status(self.id)
+        status: StatusData = await self.client.app_status(self.id)
+        endpoint: Endpoint = Endpoint.app_status()
+        await self._listener.on_request_end(endpoint=endpoint, status=status)
         if update_cache:
             self.cache.status = status
         return status
 
     async def backup(self, update_cache: bool = True) -> BackupData:
         """make backup of this application"""
-        backup: BackupData = await self.__client.backup(self.id)
+        backup: BackupData = await self.client.backup(self.id)
+        endpoint: Endpoint = Endpoint.backup()
+        await self._listener.on_request_end(endpoint=endpoint, backup=backup)
         if update_cache:
             self.cache.backup = backup
         return backup
@@ -162,26 +171,26 @@ async def start(self, update_cache: bool = True) -> Response:
         """start the application"""
         if update_cache:
             self.cache.status.running = True
-        return await self.__client.start_app(self.id)
+        return await self.client.start_app(self.id)
 
     async def stop(self, update_cache: bool = True) -> Response:
         """stop the application"""
-        result = await self.__client.stop_app(self.id)
+        result = await self.client.stop_app(self.id)
         if update_cache:
             self.cache.status.running = False
         return result
 
     async def restart(self, update_cache: bool = True) -> Response:
         """restart the application"""
-        result = await self.__client.restart_app(self.id)
+        result = await self.client.restart_app(self.id)
         if update_cache:
             self.cache.status.status = 'restarting'
         return result
 
     async def delete(self) -> Response:
         """delete the application"""
-        return await self.__client.delete_app(self.id)
+        return await self.client.delete_app(self.id)
 
     async def commit(self, file: File) -> Response:
         """commit the application"""
-        return await self.__client.commit(self.id, file=file)
+        return await self.client.commit(self.id, file=file)

squarecloud/client.py

@@ -1,11 +1,11 @@
 """This module is a wrapper for using the SquareCloud API"""
 from __future__ import annotations
 
-import asyncio
 import logging
 from abc import ABC, abstractmethod
 from typing import List, Literal, Any, Callable
 
+from .app import Application
 from .data import (
     AppData,
     StatusData,
@@ -15,12 +15,11 @@
     FullLogsData,
     UploadData
 )
+from .errors import ApplicationNotFound, InvalidFile
 from .http import HTTPClient, Response
-from .http.router import Endpoint
+from .http.endpoints import Endpoint
 from .logs import logger
 from .square import File
-from .app import Application
-from .errors import ApplicationNotFound, InvalidFile
 from .types import (
     UserPayload,
     StatusPayload,
@@ -144,7 +143,7 @@ async def get_logs(self, app_id: str) -> LogsData:
         logs_data: LogsData = LogsData(**payload)
         return logs_data
 
-    async def logs_complete(self, app_id: str) -> FullLogsData:
+    async def full_logs(self, app_id: str) -> FullLogsData:
         """
         Get logs for an application'
 
@@ -249,7 +248,8 @@ async def app(self, app_id: str) -> Application:
             raise ApplicationNotFound
         app_data = app_data.pop()
         app: Application = Application(
-            client=self, data=AppData(**app_data))  # type: ignore
+            client=self, http=self._http,
+            data=AppData(**app_data))  # type: ignore
         return app
 
     async def all_apps(self) -> List[Application]:
@@ -264,8 +264,9 @@ async def all_apps(self) -> List[Application]:
         apps_data: List[AppData] = [
             AppData(**app_data) for app_data in  # type: ignore
             payload['applications']]
-        apps: List[Application] = [Application(client=self, data=data) for data
-                                   in apps_data]
+        apps: List[Application] = [
+            Application(client=self, http=self._http, data=data) for data
+            in apps_data]
         return apps
 
     async def upload_app(self, file: File) -> UploadData:

squarecloud/http/__init__.py

@@ -1 +1,2 @@
 from .http_client import HTTPClient, Response
+from .endpoints import Endpoint

squarecloud/http/router.py renamed to squarecloud/http/endpoints.py

@@ -25,6 +25,9 @@ def __init__(self, name: str):
         self.method: str = endpoint['METHOD']
         self.path: str = endpoint['PATH']
 
+    def __eq__(self, other: Endpoint):
+        return isinstance(other, Endpoint) and self.name == other.name
+
     def __repr__(self):
         return f"<{self.__class__.__name__}('{self.name}')>"
 

squarecloud/http/http_client.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
+
 import aiohttp
 
-from .router import Endpoint, Router
+from .endpoints import Endpoint, Router
 from ..errors import (
     NotFoundError,
     RequestError,
     BadRequestError,
     AuthenticationFailure
 )
+from typing import Any, Literal
 from ..logs import logger
 from ..square import File
-
 from ..types import RawResponseData
 
 
@@ -20,13 +21,13 @@ class Response:
 
     def __init__(self, data: RawResponseData, route) -> None:
         self.data = data
-        self.route = route
-        self.headers = data.get('headers')
-        self.status = data.get('status')
-        self.code = data.get('code')
-        self.message = data.get('message')
-        self.response = data.get('response')
-        self.app = data.get('app')
+        self.route: Router = route
+        self.headers: dict[str, Any] = data.get('headers')
+        self.status: Literal['success', 'error'] = data.get('status')
+        self.code: int = data.get('code')
+        self.message: str = data.get('message')
+        self.response: dict[str, Any] = data.get('response')
+        self.app: dict[str, Any] = data.get('app')
 
 
 class HTTPClient:
@@ -35,7 +36,6 @@ class HTTPClient:
     def __init__(self, api_key: str) -> None:
         self.api_key = api_key
         self.__session = aiohttp.ClientSession
-        self.trace_config: aiohttp.TraceConfig = aiohttp.TraceConfig()
 
     async def request(self, route: Router, **kwargs) -> Response:
         """
@@ -50,15 +50,13 @@ async def request(self, route: Router, **kwargs) -> Response:
 
         if route.method == 'POST':
             kwargs['skip_auto_headers'] = {'Content-Type'}
-        if route.endpoint.name in ('COMMIT', 'UPLOAD'):
+        if route.endpoint in (Endpoint.commit(), Endpoint.upload()):
             del kwargs['skip_auto_headers']
             file = kwargs.pop('file')
             form = aiohttp.FormData()
             form.add_field('file', file.bytes, filename=file.name)
             kwargs['data'] = form
-
-        async with self.__session(
-                headers=headers, trace_configs=[self.trace_config]) as session:
+        async with self.__session(headers=headers) as session:
             async with session.request(url=route.url, method=route.method,
                                        **kwargs) as resp:
                 status_code = resp.status