feat: cache system implemented

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 import Routes
+from .http import Endpoint

squarecloud/app.py

@@ -0,0 +1,185 @@
+from .data import AppData
+from abc import ABC
+from typing import Literal, TYPE_CHECKING
+from .square import File
+from .data import StatusData, LogsData, FullLogsData, BackupData
+from .http import Response
+from .errors import SquareException
+
+# avoid circular imports
+if TYPE_CHECKING:
+    from .client import Client
+
+
+class AppCache:
+    def __init__(self):
+        self.status: StatusData | None = None
+        self.logs: LogsData | None = None
+        self.full_logs: FullLogsData | None = None
+        self.backup: BackupData | None = None
+
+    def clear_cache(self):
+        self.status = None
+        self.logs = None
+        self.full_logs = None
+
+    def update(self, *args):
+        for arg in args:
+            if isinstance(arg, StatusData):
+                self.status = arg
+            elif isinstance(arg, LogsData):
+                self.logs = arg
+            elif isinstance(arg, FullLogsData):
+                self.full_logs = arg
+            elif isinstance(arg, BackupData):
+                self.status = arg
+            else:
+                types: list = [
+                    i.__name__ for i in [
+                        StatusData,
+                        LogsData,
+                        FullLogsData,
+                        BackupData,
+                    ]
+                ]
+                raise SquareException(
+                    f'you must provide stats of the following types:\n{types}')
+
+
+class AbstractApplication(ABC):
+    """Abstract application class"""
+
+
+class Application(AbstractApplication):
+    """Represents an application"""
+    # pylint: disable=too-many-instance-attributes
+    # nine arguments is available in this case
+    # pylint: disable=invalid-name
+    __slots__ = [
+        '__client',
+        '__id',
+        '__tag',
+        '__ram',
+        '__lang',
+        '__type',
+        '__cluster',
+        '__is_website',
+        '__avatar',
+        '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
+        self.cache: AppCache = AppCache()
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__} tag={self.tag} id={self.id}>'
+
+    @property
+    def client(self):
+        """client instance"""
+        return self.__client
+
+    @property
+    def id(self):
+        """application's id"""
+        return self.__id
+
+    @property
+    def tag(self):
+        """application's tag"""
+        return self.__tag
+
+    @property
+    def ram(self):
+        """application's allocated ram"""
+        return self.__ram
+
+    @property
+    def lang(self):
+        """application's programing language"""
+        return self.__lang
+
+    @property
+    def type(self):
+        """application's type"""
+        return self.__type
+
+    @property
+    def cluster(self):
+        """application's cluster"""
+        return self.__cluster
+
+    @property
+    def is_website(self):
+        """whether the application is a website"""
+        return self.__is_website
+
+    @property
+    def avatar(self):
+        """application's avatar"""
+        return self.__avatar
+
+    async def logs(self, update_cache: bool = True) -> LogsData:
+        """get application's logs"""
+        logs: LogsData = await self.__client.get_logs(self.id)
+        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)
+        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)
+        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)
+        if update_cache:
+            self.cache.backup = backup
+        return backup
+
+    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)
+
+    async def stop(self, update_cache: bool = True) -> Response:
+        """stop the application"""
+        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)
+        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)
+
+    async def commit(self, file: File) -> Response:
+        """commit the application"""
+        return await self.__client.commit(self.id, file=file)

squarecloud/client.py

@@ -11,18 +11,19 @@
     UserData,
     LogsData,
     BackupData,
-    CompleteLogsData,
+    FullLogsData,
 )
-from .http import HTTPClient, Response, Routes
+from .http import HTTPClient, Response, Endpoint
 from .logs import logger
-from .square import File, Application
+from .square import File
+from .app import Application
 from .errors import ApplicationNotFound, InvalidFile
 from .types import (
     UserPayload,
     StatusPayload,
     LogsPayload,
     BackupPayload,
-    CompleteLogsPayload,
+    FullLogsPayload,
 )
 
 
@@ -36,11 +37,11 @@ def api_key(self):
 
 
 def create_config_file(
+        path: str,
         display_name: str,
         main: str,
         memory: int,
         version: Literal['recommended', 'latest'],
-        path: str,
         avatar: str | None = None,
         description: str | None = None,
         subdomain: str | None = None,
@@ -79,9 +80,9 @@ def create_config_file(
         if value is not None:
             string: str = f'{key}={value}\n'
             content += string
-    with open(f'./{path}/squarecloud.app', 'w') as f:
-        f.write(content)
-        return f
+    with open(f'./{path}/squarecloud.app', 'w', encoding='utf-8') as file:
+        file.write(content)
+        return file
 
 
 class Client(AbstractClient):
@@ -98,7 +99,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[Routes, Callable]
+        self._listeners: dict[Endpoint, Callable]
         if self.debug:
             logger.setLevel(logging.DEBUG)
 
@@ -139,19 +140,19 @@ 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) -> CompleteLogsData:
+    async def logs_complete(self, app_id: str) -> FullLogsData:
         """
         Get logs for an application'
 
         Args:
             app_id: the application ID
 
         Returns:
-            CompleteLogsData
+            FullLogsData
         """
         result: Response = await self.__http.fetch_logs_complete(app_id)
-        payload: CompleteLogsPayload = result.response
-        logs_data: CompleteLogsData = CompleteLogsData(**payload)
+        payload: FullLogsPayload = result.response
+        logs_data: FullLogsData = FullLogsData(**payload)
         return logs_data
 
     async def app_status(self, app_id: str) -> StatusData:
@@ -169,32 +170,32 @@ async def app_status(self, app_id: str) -> StatusData:
         status: StatusData = StatusData(**payload)
         return status
 
-    async def start_app(self, app_id: str) -> None:
+    async def start_app(self, app_id: str) -> Response:
         """
         Start an application
 
         Args:
             app_id: the application ID
         """
-        await self.__http.start_application(app_id)
+        return await self.__http.start_application(app_id)
 
-    async def stop_app(self, app_id: str) -> None:
+    async def stop_app(self, app_id: str) -> Response:
         """
         Stop an application
 
         Args:
             app_id: the application ID
         """
-        await self.__http.stop_application(app_id)
+        return await self.__http.stop_application(app_id)
 
-    async def restart_app(self, app_id: str) -> None:
+    async def restart_app(self, app_id: str) -> Response:
         """
         Restart an application
 
         Args:
             app_id: the application ID
         """
-        await self.__http.restart_application(app_id)
+        return await self.__http.restart_application(app_id)
 
     async def backup(self, app_id: str) -> BackupData:
         """
@@ -210,24 +211,24 @@ async def backup(self, app_id: str) -> BackupData:
         backup: BackupData = BackupData(**payload)
         return backup
 
-    async def delete_app(self, app_id: str) -> None:
+    async def delete_app(self, app_id: str) -> Response:
         """
         Delete an application
 
         Args:
             app_id: the application ID
         """
-        await self.__http.delete_application(app_id)
+        return await self.__http.delete_application(app_id)
 
-    async def commit(self, app_id: str, file: File) -> None:
+    async def commit(self, app_id: str, file: File) -> Response:
         """
         Commit an application
 
         Args:
             app_id: the application ID
             file: the file object to be committed
         """
-        await self.__http.commit(app_id, file)
+        return await self.__http.commit(app_id, file)
 
     async def app(self, app_id: str) -> Application:
         """
@@ -263,12 +264,12 @@ async def all_apps(self) -> List[Application]:
                                    in apps_data]
         return apps
 
-    async def upload_app(self, zip: File, check_zip: bool = True):
-        if not isinstance(zip, File):
+    async def upload_app(self, file: File) -> Response:
+        if not isinstance(file, File):
             raise InvalidFile(
                 f'you need provide an {File.__name__} object')
-        elif zip.name.split('.')[-1] != 'zip':
+        if file.name.split('.')[-1] != 'zip':
             raise InvalidFile('the file must be a .zip file')
-        await self.__http.upload(zip)
+        return await self.__http.upload(file)
 
     # async def on_request(self):

squarecloud/data.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Literal, Any, Optional
+from typing import Dict, Literal, Any
 
 
 # pylint: disable=too-many-instance-attributes
@@ -27,7 +27,7 @@ class StatusData:
     network: Dict[str, Any]
     requests: int
     uptime: int
-    time: Optional[int] = None
+    time: int | None = None
 
 
 @dataclass
@@ -60,7 +60,7 @@ class LogsData:
 
 
 @dataclass
-class CompleteLogsData:
+class FullLogsData:
     """complete logs data class"""
     logs: str