docs: Adding docstring to some functions

Author: Jhonatan-Jeferson

squarecloud/app.py

@@ -655,12 +655,28 @@ async def github_integration(self, access_token: str) -> str:
         return webhook
 
     async def domain_analytics(self) -> DomainAnalytics:
+        """
+        Retrieve analytics data for the application's domain.
+        
+        :param self: Refer to the instance of the class.
+        :returns: An instance of :class:`DomainAnalytics` containing analytics data for the domain.
+        :rtype: DomainAnalytics
+        :raises Exception: If the analytics data could not be retrieved.
+        """
         analytics: DomainAnalytics = await self.client.domain_analytics(
             self.id, avoid_listener=True
         )
-        return analytics  # TODO:
+        return analytics
 
     async def set_custom_domain(self, custom_domain: str) -> Response:
+        """
+        Sets a custom domain for the application.
+
+        :param custom_domain: The custom domain to be assigned to the application.
+        :type custom_domain: str
+        :return: The response from the domain assignment operation.
+        :rtype: Response
+        """
         response: Response = await self.client.set_custom_domain(
             self.id, custom_domain, avoid_listener=True
         )
@@ -672,28 +688,82 @@ async def all_backups(self) -> list[SnapshotInfo]:
         return backups
 
     async def all_snapshots(self) -> list[SnapshotInfo]:
+        """
+        Retrieve all snapshots of the application.
+        
+        :return: A list of SnapshotInfo objects representing all snapshots of the application.
+        :rtype: list[SnapshotInfo]
+        """
         snapshots: list[SnapshotInfo] = await self.client.all_app_snapshots(self.id)
         return snapshots
 
     @validate
     async def move_file(self, origin: str, dest: str) -> Response:
+        """
+        Moves a file from the origin path to the destination path within the application.
+        
+        :param origin: The source path of the file to be moved.
+        :type origin: str
+        :param dest: The destination path where the file should be moved.
+        :type dest: str
+        :return: A Response object containing the result of the file move operation.
+        :rtype: Response
+        """
+        
         return await self.client.move_app_file(self.id, origin, dest)
 
     async def current_integration(self) -> Response:
         return await self.client.current_app_integration(self.id)
 
     @_notify_listener(Endpoint.dns_records())
     async def dns_records(self) -> list[DNSRecord]:
+        """
+        Retrieve the DNS records associated with the application.
+        
+        :returns: A list of DNSRecord objects representing the DNS records.
+        :rtype: list[DNSRecord]
+        """
+        
         return await self.client.dns_records(self.id)
 
     async def get_envs(self) -> dict[str, str]:
+        """
+        Get environment variables of the application.
+
+        :return: A dictionary of the environment variables that were set.
+        :rtype: dict[str, str]
+        """
         return await self.client.get_app_envs(self.id)
 
     async def set_envs(self, envs: dict[str, str]) -> dict[str,str]:
+        """
+        Set environment variables or edits for the application.
+
+        :param envs: A dictionary containing environment variable names and their corresponding values.
+        :type envs: dict[str, str]
+        :return: A dictionary of the environment variables that were set.
+        :rtype: dict[str, str]
+        """
         return await self.client.set_app_envs(self.id, envs)
 
     async def delete_envs(self, keys: list[str]) -> dict[str,str]:
+        """
+        Deletes environment variables from the application.
+
+        :param keys: A list of environment variable keys to be deleted.
+        :type keys: list[str]
+        :returns: A dictionary containing the remaining variables.
+        :rtype: dict[str, str]
+        """
         return await self.client.delete_app_envs(self.id, keys)
 
     async def overwrite_env(self, envs: dict[str, str]) -> dict[str,str]:
+        """
+        Overwrites the environment variables for the application.
+
+        :param envs: A dictionary containing the environment variables to set, where keys are variable names and values are their corresponding values.
+        :type envs: dict[str, str]
+        :return: A dictionary of the environment variables.
+        :rtype: dict[str, str]
+        """
         return await self.client.overwrite_app_envs(self.id, envs)

squarecloud/client.py

@@ -714,13 +714,36 @@ async def all_app_backups(
     async def all_app_snapshots(
         self, app_id: str, **_kwargs
     ) -> list[SnapshotInfo]:
+        """
+        Retrieve all snapshots for a specific application.
+        This method fetches a list of snapshots associated with the 
+        given application ID and returns them as a list of `SnapshotInfo` objects.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :param _kwargs: Additional keyword arguments.
+        :type _kwargs: dict
+        :return: A list of `SnapshotInfo` objects representing the snapshots of 
+                 the specified application.
+        :rtype: list[SnapshotInfo]
+        """
         response: Response = await self._http.get_all_app_snapshots(
             app_id=app_id
         )
-        return [SnapshotInfo(**backup_data) for backup_data in response.response]
+        return [SnapshotInfo(**snapshot_data) for snapshot_data in response.response]
 
     @_notify_listener(Endpoint.all_apps_status())
     async def all_apps_status(self, **_kwargs) -> list[ResumedStatus]:
+        """
+        Retrieve the status of all applications.
+        This method fetches the status of all applications
+        and returns a list of `ResumedStatus` objects for applications
+        that are currently running.
+        :param _kwargs: Additional keyword arguments.
+        :type _kwargs: dict
+        :return: A list of `ResumedStatus` objects representing the status
+                 of running applications.
+        :rtype: list[ResumedStatus]
+        """
         response: Response = await self._http.all_apps_status()
         all_status = []
         for status in response.response:
@@ -733,6 +756,19 @@ async def all_apps_status(self, **_kwargs) -> list[ResumedStatus]:
     async def move_app_file(
         self, app_id: str, origin: str, dest: str, **_kwargs
     ) -> Response:
+        """
+        Moves a file within an application from the origin path to the destination path.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :param origin: The current path of the file to be moved.
+        :type origin: str
+        :param dest: The target path where the file should be moved.
+        :type dest: str
+        :param _kwargs: Additional keyword arguments.
+        :type _kwargs: dict
+        :return: The response object containing the result of the move operation.
+        :rtype: Response
+        """
         response: Response = await self._http.move_app_file(
             app_id=app_id, origin=origin, dest=dest
         )
@@ -741,6 +777,14 @@ async def move_app_file(
     @validate
     @_notify_listener(Endpoint.dns_records())
     async def dns_records(self, app_id: str) -> list[DNSRecord]:
+        """
+        Retrieve DNS records for a specific application.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :return: A list of DNSRecord objects representing the DNS records of the application.
+        :rtype: list[DNSRecord]
+        """
+        
         response: Response = await self._http.dns_records(app_id)
         return [DNSRecord(**data) for data in response.response]
 
@@ -753,21 +797,74 @@ async def current_app_integration(self, app_id: str) -> str | None:
         return response.response["webhook"]
 
     async def get_app_envs(self, app_id: str) -> dict[str, str]:
+        """
+        Retrieve the environment variables of a specific application.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :return: A dictionary containing the environment variables as key-value pairs.
+        :rtype: dict[str, str]
+        """
         response: Response = await self._http.get_environment_variables(app_id)
         return response.response
 
     async def set_app_envs(self, app_id: str, envs: dict[str, str]) -> dict[str, str]:
+        """
+        Sets or edits environment variables for a specific application.
+        This method sends a request to update the environment variables of the
+        specified application with the provided key-value pairs.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :param envs: A dictionary containing the environment variables to set,
+                     where the keys are variable names and the values are their
+                     corresponding values.
+        :type envs: dict[str, str]
+        :return: A dictionary containing the updated environment with all variables.
+        :rtype: dict[str, str]
+        :raises HTTPException: If the HTTP request fails or returns an error response.
+        """
+        
         response: Response = await self._http.set_environment_variable(app_id, envs)
         return response.response
 
     async def delete_app_envs(self, app_id: str, keys: list[str]) -> dict[str, str]:
+        """
+        Deletes specified environment variables for a given application.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :param keys: A list of keys representing the environment variables to be deleted.
+        :type keys: list[str]
+        :return: A dictionary containing the remaining variables.
+        :rtype: dict[str, str]
+        """
         response: Response = await self._http.delete_environment_variable(app_id, keys)
         return response.response
 
     async def overwrite_app_envs(self, app_id: str, envs: dict[str, str]) -> dict[str, str]:
+        """
+        Overwrite the environment variables of a specific application.
+        This method sets the dictionary provided as the new environment for the application.
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :param envs: A dictionary containing the new environment variables to set
+                     for the application. Keys and values must both be strings.
+        :type envs: dict[str, str]
+        :return: A dictionary containing the new environment after overwriting the
+                 environment variables.
+        :rtype: dict[str, str]
+        """
         response: Response = await self._http.overwrite_environment_variables(app_id, envs)
         return response.response
 
     async def clear_app_envs(self, app_id: str) -> dict[str, str]:
+        """
+        Clears all environment variables for the specified application.
+        This method overwrites the application's environment variables with an empty dictionary,
+        effectively removing all existing environment variables.
+        
+        :param app_id: Specify the application by id.
+        :type app_id: str
+        :return: A dictionary containing the response from the server.
+        :rtype: dict[str, str]
+        """
         response: Response = await self._http.overwrite_environment_variables(app_id, {})
         return response.response

squarecloud/http/http_client.py

@@ -759,21 +759,66 @@ def last_response(self) -> Response | None:
         return self._last_response
 
     async def get_environment_variables(self, app_id: str) -> Response:
+        """
+        Retrieve the environment variables for a specific application.
+
+        :param app_id: The unique identifier of the application.
+        :type app_id: str
+        :return: The response containing the environment variables.
+        :rtype: Response
+        """
         route: Router = Router(Endpoint.envs_get(), app_id=app_id)
         response: Response = await self.request(route)
         return response
 
     async def set_environment_variable(self, app_id: str, keys: dict[str, str]) -> Response:
+        """
+        Sets environment variables for a specific application.
+        This method sends a request to set the specified environment variables
+        for the application identified by the given `app_id`.
+        :param app_id: The ID of the application for which the environment 
+                       variables will be set.
+        :type app_id: str
+        :param keys: A dictionary containing the environment variable names 
+                     as keys and their corresponding values.
+        :type keys: dict[str, str]
+        :return: The response object containing the result of the operation.
+        :rtype: Response
+        """
+        
         route: Router = Router(Endpoint.envs_post(), app_id=app_id)
         response: Response = await self.request(route, json={"envs": keys})
         return response
 
     async def delete_environment_variable(self, app_id: str, keys: list[str]) -> Response:
+        """
+        Deletes one or more environment variables for a specific application.
+        :param app_id: The ID of the application whose environment variables are to be deleted.
+        :type app_id: str
+        :param keys: A list of environment variable keys to be deleted.
+        :type keys: list[str]
+        :return: The response object containing the result of the deletion operation.
+        :rtype: Response
+        """
         route: Router = Router(Endpoint.envs_delete(), app_id=app_id)
         response: Response = await self.request(route, json={"envs": keys})
         return response
 
     async def overwrite_environment_variables(self, app_id: str, keys: dict[str, str]) -> Response:
+        """
+        Overwrites the environment variables for a specific application.
+        This method sends a request to update the environment variables of the
+        specified application with the provided key-value pairs.
+        :param app_id: The ID of the application whose environment variables 
+                       are to be overwritten.
+        :type app_id: str
+        :param keys: A dictionary containing the environment variable keys and 
+                     their corresponding values to be set.
+        :type keys: dict[str, str]
+        :return: The response object containing the result of the operation.
+        :rtype: Response
+        """
+        
         route: Router = Router(Endpoint.envs_put(), app_id=app_id)
         response: Response = await self.request(route, json={"envs": keys})
         return response