feat: capture_listeners and request_listeners added

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.endpoints import Endpoint
+from .square import File

squarecloud/app.py

@@ -1,11 +1,12 @@
-from .data import AppData
 from abc import ABC
-from typing import Literal, TYPE_CHECKING, Callable
-from .square import File
+from typing import TYPE_CHECKING, Callable
+
+from .data import AppData
 from .data import StatusData, LogsData, FullLogsData, BackupData
-from .http import Response, HTTPClient, Endpoint
 from .errors import SquareException
-from .listener import ListenerManager
+from .http import Response, HTTPClient, Endpoint
+from .listener import ListenerManager, Listener
+from .square import File
 
 # avoid circular imports
 if TYPE_CHECKING:
@@ -68,7 +69,7 @@ class Application(AbstractApplication):
     def __init__(self, client: 'Client', http: HTTPClient, data: AppData):
         self._client: 'Client' = client
         self._http = http
-        self._listener: ListenerManager = ListenerManager(self)
+        self._listener: ListenerManager = Listener
         self._data = data
         self.cache: AppCache = AppCache()
 
@@ -124,17 +125,20 @@ def avatar(self):
         """application's avatar"""
         return self.data.avatar
 
-    def on_request(self, endpoint: Endpoint) -> Callable:
+    def capture(self, endpoint: Endpoint) -> Callable:
         def wrapper(func):
-            self._listener.add_listener(endpoint, func)
+            if not self._listener.get_capture_listener(endpoint):
+                return self._listener.add_capture_listener(endpoint, func)
+            raise SquareException(
+                f'Already exists an capture_listener for {endpoint}')
 
         return wrapper
 
     async def logs(self, update_cache: bool = True) -> LogsData:
         """get application's logs"""
         logs: LogsData = await self.client.get_logs(self.id)
         endpoint: Endpoint = Endpoint.logs()
-        await self._listener.on_request_end(endpoint=endpoint, logs=logs)
+        await self._listener.on_capture(endpoint=endpoint, logs=logs)
         if update_cache:
             self.cache.logs = logs
         return logs
@@ -143,7 +147,7 @@ async def full_logs(self, update_cache: bool = True) -> FullLogsData:
         """get application's full logs"""
         full_logs: FullLogsData = await self.client.full_logs(self.id)
         endpoint: Endpoint = Endpoint.full_logs()
-        await self._listener.on_request_end(
+        await self._listener.on_capture(
             endpoint=endpoint, full_logs=full_logs)
         if update_cache:
             self.cache.full_logs = full_logs
@@ -153,7 +157,7 @@ async def status(self, update_cache: bool = True) -> StatusData:
         """get application's status"""
         status: StatusData = await self.client.app_status(self.id)
         endpoint: Endpoint = Endpoint.app_status()
-        await self._listener.on_request_end(endpoint=endpoint, status=status)
+        await self._listener.on_capture(endpoint=endpoint, status=status)
         if update_cache:
             self.cache.status = status
         return status
@@ -162,35 +166,53 @@ async def backup(self, update_cache: bool = True) -> BackupData:
         """make backup of this application"""
         backup: BackupData = await self.client.backup(self.id)
         endpoint: Endpoint = Endpoint.backup()
-        await self._listener.on_request_end(endpoint=endpoint, backup=backup)
+        await self._listener.on_capture(endpoint=endpoint, backup=backup)
         if update_cache:
             self.cache.backup = backup
         return backup
 
     async def start(self, update_cache: bool = True) -> Response:
         """start the application"""
+        response: Response = await self.client.start_app(self.id)
+        endpoint: Endpoint = Endpoint.start()
         if update_cache:
             self.cache.status.running = True
-        return await self.client.start_app(self.id)
+        await self._listener.on_capture(endpoint=endpoint,
+                                        response=response)
+        return response
 
     async def stop(self, update_cache: bool = True) -> Response:
         """stop the application"""
-        result = await self.client.stop_app(self.id)
+        response: Response = await self.client.stop_app(self.id)
+        endpoint: Endpoint = Endpoint.stop()
         if update_cache:
             self.cache.status.running = False
-        return result
+        await self._listener.on_capture(endpoint=endpoint,
+                                        response=response)
+        return response
 
     async def restart(self, update_cache: bool = True) -> Response:
         """restart the application"""
-        result = await self.client.restart_app(self.id)
+        response: Response = await self.client.restart_app(self.id)
+        endpoint: Endpoint = Endpoint.restart()
+        await self._listener.on_capture(endpoint=endpoint,
+                                        response=response)
         if update_cache:
             self.cache.status.status = 'restarting'
-        return result
+        return response
 
     async def delete(self) -> Response:
         """delete the application"""
-        return await self.client.delete_app(self.id)
+        response: Response = await self.client.delete_app(self.id)
+        endpoint: Endpoint = Endpoint.delete()
+        await self._listener.on_capture(endpoint=endpoint,
+                                        response=response)
+        return response
 
     async def commit(self, file: File) -> Response:
         """commit the application"""
-        return await self.client.commit(self.id, file=file)
+        response: Response = await self.client.commit(self.id, file=file)
+        endpoint: Endpoint = Endpoint.commit()
+        await self._listener.on_capture(endpoint=endpoint,
+                                        response=response)
+        return response

squarecloud/client.py

@@ -15,19 +15,20 @@
     FullLogsData,
     UploadData
 )
-from .errors import ApplicationNotFound, InvalidFile
+from .errors import ApplicationNotFound, InvalidFile, SquareException
 from .http import HTTPClient, Response
 from .http.endpoints import Endpoint
+from .listener import ListenerManager, Listener
 from .logs import logger
-from .square import File
-from .types import (
+from .payloads import (
     UserPayload,
     StatusPayload,
     LogsPayload,
     BackupPayload,
     FullLogsPayload,
     UploadPayload,
 )
+from .square import File
 
 
 class AbstractClient(ABC):
@@ -102,7 +103,7 @@ def __init__(self, api_key: str, debug: bool = True) -> None:
         self.debug = debug
         self._api_key = api_key
         self._http = HTTPClient(api_key=api_key)
-        self._listeners: dict[list[Endpoint], Callable]
+        self._listener: ListenerManager = Listener
         if self.debug:
             logger.setLevel(logging.DEBUG)
 
@@ -116,16 +117,35 @@ def api_key(self) -> str:
         """
         return self._api_key
 
-    async def user_info(self) -> UserData:
+    def on_request(self, endpoint: Endpoint):
+        def wrapper(func: Callable):
+            if not self._listener.get_request_listener(endpoint):
+                return self._listener.add_request_listener(endpoint, func)
+            raise SquareException(
+                f'Already exists an capture_listener for {endpoint}')
+
+        return wrapper
+
+    async def me(self) -> UserData:
+        response: Response = await self._http.fetch_user_info()
+        payload: UserPayload = response.response
+        user_data: UserData = UserData(**payload['user'])
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return user_data
+
+    async def user_info(self, user_id: int | None = None) -> UserData:
         """
         Get user information
 
         Returns:
             UserData
         """
-        result: Response = await self._http.fetch_user_info()
-        payload: UserPayload = result.response
+        response: Response = await self._http.fetch_user_info(user_id=user_id)
+        payload: UserPayload = response.response
         user_data: UserData = UserData(**payload['user'])
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return user_data
 
     async def get_logs(self, app_id: str) -> LogsData:
@@ -138,9 +158,11 @@ async def get_logs(self, app_id: str) -> LogsData:
         Returns:
             LogData
         """
-        result: Response = await self._http.fetch_logs(app_id)
-        payload: LogsPayload = result.response
+        response: Response = await self._http.fetch_logs(app_id)
+        payload: LogsPayload = response.response
         logs_data: LogsData = LogsData(**payload)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return logs_data
 
     async def full_logs(self, app_id: str) -> FullLogsData:
@@ -153,9 +175,11 @@ async def full_logs(self, app_id: str) -> FullLogsData:
         Returns:
             FullLogsData
         """
-        result: Response = await self._http.fetch_logs_complete(app_id)
-        payload: FullLogsPayload = result.response
+        response: Response = await self._http.fetch_logs_complete(app_id)
+        payload: FullLogsPayload = response.response
         logs_data: FullLogsData = FullLogsData(**payload)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return logs_data
 
     async def app_status(self, app_id: str) -> StatusData:
@@ -168,9 +192,11 @@ async def app_status(self, app_id: str) -> StatusData:
         Returns:
             StatusData
         """
-        result: Response = await self._http.fetch_app_status(app_id)
-        payload: StatusPayload = result.response
+        response: Response = await self._http.fetch_app_status(app_id)
+        payload: StatusPayload = response.response
         status: StatusData = StatusData(**payload)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return status
 
     async def start_app(self, app_id: str) -> Response:
@@ -180,7 +206,11 @@ async def start_app(self, app_id: str) -> Response:
         Args:
             app_id: the application ID
         """
-        return await self._http.start_application(app_id)
+
+        response: Response = await self._http.start_application(app_id)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return response
 
     async def stop_app(self, app_id: str) -> Response:
         """
@@ -189,7 +219,10 @@ async def stop_app(self, app_id: str) -> Response:
         Args:
             app_id: the application ID
         """
-        return await self._http.stop_application(app_id)
+        response: Response = await self._http.stop_application(app_id)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return response
 
     async def restart_app(self, app_id: str) -> Response:
         """
@@ -198,7 +231,10 @@ async def restart_app(self, app_id: str) -> Response:
         Args:
             app_id: the application ID
         """
-        return await self._http.restart_application(app_id)
+        response: Response = await self._http.restart_application(app_id)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return response
 
     async def backup(self, app_id: str) -> BackupData:
         """
@@ -209,9 +245,11 @@ async def backup(self, app_id: str) -> BackupData:
         Returns:
             Backup
         """
-        result: Response = await self._http.backup(app_id)
-        payload: BackupPayload = result.response
+        response: Response = await self._http.backup(app_id)
+        payload: BackupPayload = response.response
         backup: BackupData = BackupData(**payload)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return backup
 
     async def delete_app(self, app_id: str) -> Response:
@@ -221,7 +259,10 @@ async def delete_app(self, app_id: str) -> Response:
         Args:
             app_id: the application ID
         """
-        return await self._http.delete_application(app_id)
+        response: Response = await self._http.delete_application(app_id)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return response
 
     async def commit(self, app_id: str, file: File) -> Response:
         """
@@ -231,7 +272,10 @@ async def commit(self, app_id: str, file: File) -> Response:
             app_id: the application ID
             file: the file object to be committed
         """
-        return await self._http.commit(app_id, file)
+        response: Response = await self._http.commit(app_id, file)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
+        return response
 
     async def app(self, app_id: str) -> Application:
         """
@@ -240,8 +284,8 @@ async def app(self, app_id: str) -> Application:
         Args:
             app_id: the application ID
         """
-        result: Response = await self._http.fetch_user_info()
-        payload: UserPayload = result.response
+        response: Response = await self._http.fetch_user_info()
+        payload: UserPayload = response.response
         app_data = list(filter(lambda application: application['id'] == app_id,
                                payload['applications']))
         if not app_data:
@@ -259,8 +303,8 @@ async def all_apps(self) -> List[Application]:
         Returns:
             List[AppData]
         """
-        result: Response = await self._http.fetch_user_info()
-        payload: UserPayload = result.response
+        response: Response = await self._http.fetch_user_info()
+        payload: UserPayload = response.response
         apps_data: List[AppData] = [
             AppData(**app_data) for app_data in  # type: ignore
             payload['applications']]
@@ -275,7 +319,9 @@ async def upload_app(self, file: File) -> UploadData:
                 f'you need provide an {File.__name__} object')
         if file.name.split('.')[-1] != 'zip':
             raise InvalidFile('the file must be a .zip file')
-        result: Response = await self._http.upload(file)
-        payload: UploadPayload = result.app
+        response: Response = await self._http.upload(file)
+        payload: UploadPayload = response.app
         app: UploadData = UploadData(**payload)
+        endpoint: Endpoint = response.route.endpoint
+        await self._listener.on_request(endpoint=endpoint, response=response)
         return app

squarecloud/data.py

@@ -48,7 +48,8 @@ class UserData:
     """user data class"""
     id: int
     tag: str
-    email: str | Literal['Access denied']
+    locale: str
+    email: str | None
     plan: PlanData
     blocklist: bool
 

squarecloud/http/__init__.py

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