mcsmapi 0.1.0__py3-none-any.whl

mcsmapi/__init__.py

@@ -0,0 +1,8 @@
+import pkgutil
+import importlib
+
+__all__ = []
+
+for _, module_name, _ in pkgutil.iter_modules(__path__):
+	module = importlib.import_module(f".{module_name}", package=__name__)
+	__all__.append(module_name)

mcsmapi/common.py

@@ -0,0 +1,34 @@
+import requests
+
+
+class ApiClient:
+    def __init__(self, url, apikey=None, timeout=None):
+        self.url = url
+        self.apikey = apikey
+        self.timeout = timeout
+        self.cookies = None
+        self.token = None
+
+    def send(self, method, endpoint, params={}, data=None):
+        url = f"{self.url}/api/{endpoint}"
+
+        if self.apikey is not None:
+            params['apikey'] = self.apikey
+        if self.token is not None:
+            params['token'] = self.token
+
+        response = requests.request(
+            method, url, params=params, json=data, cookies=self.cookies, timeout=self.timeout)
+        response.raise_for_status()
+        return response
+
+
+def support_login(cls):
+    def login(self, username, password):
+        seq = self.client.send(
+            "POST", "auth/login", data={"username": username, "password": password})
+        self.client.cookies = seq.cookies
+        self.client.token = seq.json()["data"]
+
+    setattr(cls, 'login', login)
+    return cls

mcsmapi/daemon.py

@@ -0,0 +1,86 @@
+from .common import support_login, ApiClient
+import requests
+
+
+@support_login
+class Daemon:
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initialize a new Daemon instance.
+
+        :param url: The URL of the daemon service.
+        :param apikey: Optional API key for authentication.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def getList(self) -> list:
+        """
+        Get a list of remote services.
+
+        :return: A list of remote services.
+        """
+        return self.client.send("GET", "overview").json()["data"]["remote"]
+
+    def add(self, ip: str, port: int, remarks: str, apiKey: str, prefix: str = "") -> requests.Response:
+        """
+        Add a new remote service.
+
+        :param ip: IP address of the remote service.
+        :param port: Port number of the remote service.
+        :param remarks: Remarks or description of the remote service.
+        :param apiKey: API key for the remote service.
+        :param prefix: Optional prefix for the remote service.
+        :return: Response data from the server.
+        """
+        return self.client.send(
+            "POST", "service/remote_service", data={
+                "ip": ip,
+                "port": port,
+                "prefix": prefix,
+                "remarks": remarks,
+                "apiKey": apiKey
+            })
+
+    def delete(self, uuid: str) -> requests.Response:
+        """
+        Delete a remote service by its UUID.
+
+        :param uuid: UUID of the remote service to delete.
+        :return: Response data from the server.
+        """
+        return self.client.send(
+            "DELETE", "service/remote_service", params={"uuid": uuid})
+
+    def tryConnect(self, uuid: str) -> requests.Response:
+        """
+        Try to connect to a remote service by its UUID.
+
+        :param uuid: UUID of the remote service to connect to.
+        :return: Response data from the server.
+        """
+        return self.client.send(
+            "GET", "service/link_remote_service", params={"uuid": uuid})
+
+    def updateDaemonConnectConfig(self, uuid: str, ip: str, port: int, remarks: str, apiKey: str, available: bool = False, prefix: str = "") -> requests.Response:
+        """
+        Update the configuration of a remote service.
+
+        :param uuid: UUID of the remote service to update.
+        :param ip: New IP address of the remote service.
+        :param port: New port number of the remote service.
+        :param remarks: New remarks or description of the remote service.
+        :param apiKey: New API key for the remote service.
+        :param available: Whether the service is available.
+        :param prefix: Optional prefix for the remote service.
+        :return: Response data from the server.
+        """
+        return self.client.send(
+            "PUT", "service/remote_service", data={
+                "uuid": uuid,
+                "ip": ip,
+                "port": port,
+                "prefix": prefix,
+                "available": available,
+                "remarks": remarks,
+                "apiKey": apiKey
+            })

mcsmapi/file.py

@@ -0,0 +1,326 @@
+from .common import support_login, ApiClient
+import aiohttp
+import requests
+import os
+
+
+@support_login
+class File:
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initialize a new File instance.
+
+        :param url: The URL of the file service.
+        :param apikey: Optional API key for authentication.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def getList(self, daemonId: str, instanceUuid: str, target: str, page: int = 1, page_size: int = 10) -> requests.Response:
+        """
+        Get a list of files.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param target: Target directory path.
+        :param page: Page number (default is 1).
+        :param page_size: Number of items per page (default is 10).
+        :return: Response data from the server.
+        """
+        return self.client.send("GET", "files/list", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid,
+            "target": target,
+            "page": page,
+            "page_size": page_size
+        })
+
+    def getContents(self, daemonId: str, instanceUuid: str, target: str) -> requests.Response:
+        """
+        Get the contents of a file.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param target: Path to the file.
+        :return: Response data from the server.
+        """
+        return self.client.send("PUT", "files", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={"target": target})
+
+    def update(self, daemonId: str, instanceUuid: str, target: str, text: str) -> requests.Response:
+        """
+        Update the contents of a file.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param target: Path to the file.
+        :param text: New content for the file.
+        :return: Response data from the server.
+        """
+        return self.client.send("PUT", "files", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={"target": target, "text": text})
+
+    def download(self, daemonId: str, instanceUuid: str, file_name: str, download_to_path: str) -> str:
+        """
+        Download a file from the server.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param file_name: Name of the file to download.
+        :param download_to_path: Local path where the file will be saved.
+        :return: Path to the downloaded file.
+        """
+        seq = self.client.send("POST", "files/download", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid,
+            "file_name": file_name
+        }).json()
+        password = seq["password"]
+        addr = seq["addr"]
+
+        response = requests.get(
+            f"http://{addr}/download/{password}/{file_name}", stream=True)
+        if response.status_code == 200:
+            file_path = os.path.join(download_to_path, file_name)
+            with open(file_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=1024):
+                    if chunk:
+                        f.write(chunk)
+            return file_path
+        else:
+            raise Exception(
+                f"Failed to download file. Status code: {response.status_code}")
+
+    async def aiodownload(self, daemonId: str, instanceUuid: str, file_name: str, download_to_path: str) -> str:
+        """
+        Asynchronously download a file from the server.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param file_name: Name of the file to download.
+        :param download_to_path: Local path where the file will be saved.
+        :return: Path to the downloaded file.
+        """
+        seq = self.client.send("POST", "files/download", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid,
+            "file_name": file_name
+        }).json()
+        password = seq["password"]
+        addr = seq["addr"]
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"http://{addr}/download/{password}/{file_name}") as response:
+                if response.status == 200:
+                    file_path = os.path.join(download_to_path, file_name)
+                    async with open(file_path, "wb") as f:
+                        await f.write(await response.read())
+                    return file_path
+                else:
+                    raise Exception(
+                        f"Failed to download file. Status code: {response.status}")
+
+    def upload(self, daemonId: str, instanceUuid: str, upload_dir: str, file_data: bytes) -> bool:
+        """
+        Upload a file to the server.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param upload_dir: Directory on the server where the file will be uploaded.
+        :param file_data: Binary data of the file to upload.
+        :return: True if the upload was successful.
+        """
+        seq = self.client.send("POST", "files/upload", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid,
+            "upload_dir": upload_dir
+        }).json()
+        password = seq["password"]
+        addr = seq["addr"]
+
+        response = requests.post(
+            f"http://{addr}/upload/{password}", files={"file": file_data})
+
+        if response.status_code == 200:
+            return True
+        else:
+            raise Exception(
+                f"Failed to upload file. Status code: {response.status_code}")
+
+    async def aioupload(self, daemonId: str, instanceUuid: str, upload_dir: str, file_data: bytes) -> bool:
+        """
+        Asynchronously upload a file to the server.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param upload_dir: Directory on the server where the file will be uploaded.
+        :param file_data: Binary data of the file to upload.
+        :return: True if the upload was successful.
+        """
+        seq = self.client.send("POST", "files/upload", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid,
+            "upload_dir": upload_dir
+        }).json()
+        password = seq["password"]
+        addr = seq["addr"]
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"http://{addr}/upload/{password}", data={"file": file_data}) as response:
+                if response.status == 200:
+                    return True
+                else:
+                    raise Exception(
+                        f"Failed to upload file. Status code: {response.status}")
+
+    def copy(self, daemonId: str, instanceUuid: str, source_list: list, target_list: list) -> requests.Response:
+        """
+        Copy files from one location to another.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param source_list: List of source file paths.
+        :param target_list: List of target file paths.
+        :return: Response data from the server.
+        """
+        data = {
+            "targets": [
+                [source, target] for source, target in zip(source_list, target_list)
+            ]
+        }
+
+        return self.client.send("POST", "files/copy", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data=data)
+
+    def moveOrRename(self, daemonId: str, instanceUuid: str, source_list: list, target_list: list) -> requests.Response:
+        """
+        Move or rename files.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param source_list: List of source file paths.
+        :param target_list: List of target file paths.
+        :return: Response data from the server.
+        """
+        data = {
+            "targets": [
+                [source, target] for source, target in zip(source_list, target_list)
+            ]
+        }
+        return self.client.send("PUT", "files/move", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data=data)
+
+    def zip(self, daemonId: str, instanceUuid: str, zip_file_path: str, targets: list) -> requests.Response:
+        """
+        Compress files into a ZIP archive.
+
+        :param daemonId: ID of the daemon.
+        :param instanceUuid: UUID of the instance.
+        :param zip_file_path: Path to the resulting ZIP file.
+        :param targets: List of files to compress.
+        :return: Response data from the server.
+        """
+        zip_file_path = os.path.join(zip_file_path)
+
+        return self.client.send("POST", "files/compress", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={
+            "type": 1,
+            "code": "utf-8",
+            "source": zip_file_path,
+            "targets": targets
+        })
+
+    def unzip(self, daemonId: str, instanceUuid: str, zip_file_path: str, unzip_to: str, code: str = "utf-8") -> requests.Response:
+        """
+        Decompresses a ZIP file.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuid (str): UUID of the instance.
+            zip_file_path (str): Path to the ZIP file.
+            unzip_to (str): Directory path to extract the files to.
+            code (str, optional): Encoding type. Defaults to "utf-8". Must be one of "utf-8", "gbk", or "big5".
+
+        Returns:
+            requests.Response: Response data from the server.
+
+        Raises:
+            ValueError: If the provided encoding type is not valid.
+        """
+        if code not in ["utf-8", "gbk", "big5"]:
+            raise ValueError(
+                "code must be one of utf-8, gbk, big5")
+        return self.client.send("POST", "files/compress", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={
+            "type": 2,
+            "code": code,
+            "source": zip_file_path,
+            "target": unzip_to
+        })
+
+    def delete(self, daemonId: str, instanceUuid: str, targets: list) -> requests.Response:
+        """
+        Deletes files or directories.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuid (str): UUID of the instance.
+            targets (list): List of paths to the files or directories to delete.
+
+        Returns:
+            requests.Response: Response data from the server.
+        """
+        return self.client.send("DELETE", "files", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={
+            "targets": targets
+        })
+
+    def touch(self, daemonId: str, instanceUuid: str, target: str) -> requests.Response:
+        """
+        Creates an empty file.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuid (str): UUID of the instance.
+            target (str): Path to the file to create.
+
+        Returns:
+            requests.Response: Response data from the server.
+        """
+        return self.client.send("POST", "files/touch", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={
+            "target": target
+        })
+
+    def createFolder(self, daemonId: str, instanceUuid: str, target: str) -> requests.Response:
+        """
+        Creates a directory.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuid (str): UUID of the instance.
+            target (str): Path to the directory to create.
+
+        Returns:
+            requests.Response: Response data from the server.
+        """
+        return self.client.send("POST", "files/mkdir", params={
+            "daemonId": daemonId,
+            "uuid": instanceUuid
+        }, data={
+            "target": target
+        })

mcsmapi/image.py

@@ -0,0 +1,104 @@
+from .common import support_login, ApiClient
+import requests
+
+
+@support_login
+class Image:
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initializes a new Image instance.
+
+        Args:
+            url (str): The URL of the image service.
+            apikey (str, optional): Optional API key for authentication. Defaults to None.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def getImageList(self, daemonId: str) -> requests.Response:
+        """
+        Retrieves a list of Docker images.
+
+        DockerImageList:
+        https://docs.docker.com/engine/api/v1.37/#tag/Image/operation/ImageList
+
+        Args:
+            daemonId (str): ID of the Docker daemon.
+
+        Returns:
+            dict: Response data containing the list of Docker images.
+        """
+
+        return self.client.send("GET", "environment/image", params={
+            "daemonId": daemonId
+        })
+
+    def getContainerList(self, daemonId: str) -> requests.Response:
+        """
+        Retrieves a list of Docker containers.
+
+        DockerContainerList:
+        https://docs.docker.com/engine/api/v1.37/#tag/Container/operation/ContainerList
+
+        Args:
+            daemonId (str): ID of the Docker daemon.
+
+        Returns:
+            dict: Response data containing the list of Docker containers.
+        """
+
+        return self.client.send("GET", "environment/containers", params={
+            "daemonId": daemonId
+        })
+
+    def getNetworkModeList(self, daemonId: str) -> requests.Response:
+        """
+        Retrieves a list of Docker network modes.
+
+        DockerNetworkModeList:
+        https://docs.docker.com/engine/api/v1.37/#tag/Network/operation/NetworkList
+
+        Args:
+            daemonId (str): ID of the Docker daemon.
+
+        Returns:
+            dict: Response data containing the list of Docker network modes.
+        """
+
+        return self.client.send("GET", "environment/network", params={
+            "daemonId": daemonId
+        })
+
+    def createImage(self, daemonId: str, dockerFileConfig: dict, imageName: str, tag: str) -> requests.Response:
+        """
+        Builds a Docker image from a Dockerfile configuration.
+
+        Args:
+            daemonId (str): ID of the Docker daemon.
+            dockerFileConfig (dict): Configuration for the Dockerfile.
+            imageName (str): Name of the Docker image.
+            tag (str): Tag for the Docker image.
+
+        Returns:
+            dict: Response data indicating the status of the build process.
+        """
+        return self.client.send("POST", "environment/image", params={
+            "daemonId": daemonId
+        }, data={
+            "dockerFile": dockerFileConfig,
+            "imageName": imageName,
+            "tag": tag
+        })
+
+    def buildProgress(self, daemonId: str) -> requests.Response:
+        """
+        Retrieves the progress of a Docker image build.
+
+        Args:
+            daemonId (str): ID of the Docker daemon.
+
+        Returns:
+            dict: Response data containing the build progress information.
+        """
+        return self.client.send("GET", "environment/image/progress", params={
+            "daemonId": daemonId
+        })

mcsmapi/instance.py

@@ -0,0 +1,424 @@
+from .common import support_login, ApiClient
+import requests
+
+
+@support_login
+class Instance:
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initializes a new Instance object.
+
+        Args:
+            url (str): The URL of the service endpoint.
+            apikey (str, optional): Optional API key for authentication. Defaults to None.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def getList(self, daemonId: str, page: int = 1, page_size: int = 10, instance_name: str = "", status: str = "") -> requests.Response:
+        """
+        Retrieves a list of instances.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            page (int, optional): Page number for pagination. Defaults to 1.
+            page_size (int, optional): Number of items per page. Defaults to 10.
+            instance_name (str, optional): Filter by instance name. Defaults to "".
+            status (str, optional): Filter by instance status. Defaults to "".
+
+        Returns:
+            requests.Response: Response data containing the list of instances.
+        """
+        return self.client.send("GET", "service/remote_service_instances", params={
+            "daemonId": daemonId, "page": page, "page_size": page_size,
+            "instance_name": instance_name, "status": status})
+
+    def detail(self, instanceUuid: str, daemonId: str) -> requests.Response:
+        """
+        Retrieves details of a specific instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+
+        Returns:
+            requests.Response: Response data containing the details of the instance.
+        """
+        return self.client.send("GET", "instance ", params={
+            "uuid": instanceUuid, "daemonId": daemonId})
+
+    def create(self, daemonId: str, InstanceConfig: requests.Response) -> requests.Response:
+        """
+        Creates a new instance.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            InstanceConfig (requests.Response): Configuration for the new instance.
+
+        Returns:
+            requests.Response: Response data indicating the creation status.
+        """
+        return self.client.send("POST", "instance", params={
+            "daemonId": daemonId}, data=InstanceConfig)
+
+    def updateConfig(self, instanceUuid: str, daemonId: str, InstanceConfig: requests.Response) -> requests.Response:
+        """
+        Updates the configuration of an existing instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+            InstanceConfig (requests.Response): Updated configuration for the instance.
+
+        Returns:
+            requests.Response: Response data indicating the update status.
+        """
+        return self.client.send("POST", "instance", params={
+            "uuid": instanceUuid, "daemonId": daemonId}, data=InstanceConfig)
+
+    def delete(self, daemonId: str, instanceUuids: list, delete_file: bool = False) -> requests.Response:
+        """
+        Deletes one or more instances.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuids (list): List of UUIDs of the instances to delete.
+            delete_file (bool, optional): Whether to delete associated files. Defaults to False.
+
+        Returns:
+            requests.Response: Response data indicating the deletion status.
+        """
+        return self.client.send("DELETE", "instance", params={
+            "daemonId": daemonId}, data={"uuids": instanceUuids, "deleteFile": delete_file})
+
+    def start(self, instanceUuid: str, daemonId: str) -> requests.Response:
+        """
+        Starts an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+
+        Returns:
+            requests.Response: Response data indicating the start status.
+        """
+        return self.client.send("GET", "protected_instance/open", params={
+            "uuid": instanceUuid, "daemonId": daemonId})
+
+    def stop(self, instanceUuid: str, daemonId: str) -> requests.Response:
+        """
+        Stops an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+
+        Returns:
+            requests.Response: Response data indicating the stop status.
+        """
+        return self.client.send("GET", "protected_instance/stop", params={
+            "uuid": instanceUuid, "daemonId": daemonId})
+
+    def restart(self, instanceUuid: str, daemonId: str) -> requests.Response:
+        """
+        Restarts an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+
+        Returns:
+            requests.Response: Response data indicating the restart status.
+        """
+        return self.client.send("GET", "protected_instance/restart", params={
+            "uuid": instanceUuid, "daemonId": daemonId})
+
+    def kill(self, instanceUuid: str, daemonId: str) -> requests.Response:
+        """
+        Kills an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+
+        Returns:
+            requests.Response: Response data indicating the kill status.
+        """
+        return self.client.send("GET", "protected_instance/kill", params={
+            "uuid": instanceUuid, "daemonId": daemonId})
+
+    def batchOperation(self, daemonId: str, instanceUuid: str, operations: str) -> requests.Response:
+        """
+        Performs a batch operation on instances.
+
+        Args:
+            daemonId (str): ID of the daemon.
+            instanceUuid (str): UUID of the instance.
+            operations (str): Operation to perform. Must be one of "start", "stop", "restart", "kill".
+
+        Returns:
+            requests.Response: Response data indicating the operation status.
+
+        Raises:
+            ValueError: If the operation is not one of the allowed values.
+        """
+        if operations not in ["start", "stop", "restart", "kill"]:
+            raise ValueError(
+                "operations must be one of start, stop, restart, kill")
+        return self.client.send("POST", f"instance/multi_{operations}", params={
+            "daemonId": daemonId, "instanceUuid": instanceUuid})
+
+    def updateInstance(self, instanceUuid: str, daemonId: str, task_name: str) -> requests.Response:
+        """
+        Updates an instance with a specified task.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+            task_name (str): Name of the task to execute.
+
+        Returns:
+            requests.Response: Response data indicating the update status.
+        """
+        return self.client.send("GET", "protected_instance/asynchronous", params={
+            "uuid": instanceUuid, "daemonId": daemonId, "task_name": task_name})
+
+    def sendCommand(self, instanceUuid: str, daemonId: str, command: str) -> requests.Response:
+        """
+        Sends a command to an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+            command (str): Command to send.
+
+        Returns:
+            requests.Response: Response data indicating the command status.
+        """
+        return self.client.send("POST", "protected_instance/command", params={
+            "uuid": instanceUuid, "daemonId": daemonId, "command": command})
+
+    def getOutput(self, instanceUuid: str, daemonId: str, size: int = None) -> requests.Response:
+        """
+        Retrieves output log from an instance.
+
+        Args:
+            instanceUuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+            size (int, optional): Number of log lines to retrieve. Defaults to None.
+
+        Returns:
+            requests.Response: Response data containing the output log.
+        """
+        params = {"uuid": instanceUuid, "daemonId": daemonId}
+        if size is not None:
+            params["size"] = size
+        return self.client.send(
+            "GET", "protected_instance/outputlog", params=params)
+
+    def reinstall(self, uuid: str, daemonId: str, targetUrl: str, title: str, description: str = "") -> requests.Response:
+        """
+        Reinstalls an instance.
+
+        Args:
+            uuid (str): UUID of the instance.
+            daemonId (str): ID of the daemon.
+            targetUrl (str): Target URL for the installation.
+            title (str): Title of the instance.
+            description (str, optional): Description of the instance. Defaults to "".
+
+        Returns:
+            requests.Response: Response data indicating the reinstall status.
+        """
+        return self.client.send("GET", "protected_instance/install_instance", params={
+            "uuid": uuid, "daemonId": daemonId}, data={"targetUrl": targetUrl, "title": title, "description": description})
+
+    def typeOfInstanceConfig(self, **kwargs) -> dict:
+        """
+        Generates an instance configuration based on the provided arguments.
+
+        Args:
+            **kwargs: Keyword arguments representing the configuration parameters.
+
+        Returns:
+            dict: An instance configuration dictionary.
+
+        Raises:
+            ValueError: If any unsupported keys are provided.
+
+        Supported Keys:
+            - nickname (str): Nickname of the instance.
+            - startCommand (str): Start command for the instance.
+            - stopCommand (str): Stop command for the instance.
+            - cwd (str): Current working directory for the instance.
+            - ie (str): Input encoding.
+            - oe (str): Output encoding.
+            - createDatetime (str): Creation datetime.
+            - lastDatetime (str): Last updated datetime.
+            - type (str): Type of the instance.
+            - tag (list): Tags associated with the instance.
+            - endTime (str): End time of the instance.
+            - fileCode (str): File code.
+            - processType (str): Process type.
+            - updateCommand (str): Update command.
+            - actionCommandList (list): List of action commands.
+            - crlf (int): CRLF value.
+            - docker (dict): Docker configuration.
+            - enableRcon (bool): Enable RCON.
+            - rconPassword (str): RCON password.
+            - rconPort (int): RCON port.
+            - rconIp (str): RCON IP address.
+            - terminalOption (dict): Terminal options.
+            - eventTask (dict): Event task settings.
+            - pingConfig (dict): Ping configuration.
+        """
+        default = {
+            "nickname": "New Name",
+            "startCommand": "cmd.exe",
+            "stopCommand": "^C",
+            "cwd": "/workspaces/my_server/",
+            "ie": "utf8",
+            "oe": "gbk",
+            "createDatetime": "2022/2/3",
+            "lastDatetime": "2022/2/3 16:02",
+            "type": "universal",
+            "tag": [],
+            "endTime": "2022/2/28",
+            "fileCode": "gbk",
+            "processType": "docker",
+            "updateCommand": "shutdown -s",
+            "actionCommandList": [],
+            "crlf": 2,
+            "docker": self.typeOfDockerConfig(),
+
+            "enableRcon": True,
+            "rconPassword": "123456",
+            "rconPort": 2557,
+            "rconIp": "192.168.1.233",
+
+            "terminalOption": {
+                "haveColor": False,
+                "pty": True,
+            },
+            "eventTask": {
+                "autoStart": False,
+                "autoRestart": True,
+                "ignore": False,
+            },
+            "pingConfig": {
+                "ip": "",
+                "port": 25565,
+                "type": 1,
+            }
+        }
+
+        supported_keys = set(default.keys())
+        unsupported_keys = set(kwargs.keys()) - supported_keys
+
+        if unsupported_keys:
+            raise ValueError(
+                f"Unsupported keys: {unsupported_keys}. Supported keys are: {supported_keys}")
+
+        config = default.copy()
+        config.update(kwargs)
+
+        return config
+
+    def typeOfDockerConfig(self, **kwargs) -> dict:
+        """
+        Generates a Docker configuration based on the provided arguments.
+
+        Args:
+            **kwargs: Keyword arguments representing the configuration parameters.
+
+        Returns:
+            dict: A Docker configuration dictionary.
+
+        Raises:
+            ValueError: If any unsupported keys are provided.
+
+        Supported Keys:
+            - containerName (str): Container name.
+            - image (str): Docker image name.
+            - memory (int): Memory limit in MB.
+            - ports (list): Ports mapping.
+            - extraVolumes (list): Extra volumes.
+            - maxSpace (int): Maximum space.
+            - network (str): Network mode.
+            - io (int): IO limit.
+            - networkMode (str): Network mode.
+            - networkAliases (list): Network aliases.
+            - cpusetCpus (str): CPU set.
+            - cpuUsage (int): CPU usage.
+            - workingDir (str): Working directory.
+            - env (list): Environment variables.
+        """
+        default = {
+            "containerName": "",
+            "image": "mcsm-ubuntu:22.04",
+            "memory": 1024,
+            "ports": ["25565:25565/tcp"],
+            "extraVolumes": [],
+            "maxSpace": None,
+            "network": None,
+            "io": None,
+            "networkMode": "bridge",
+            "networkAliases": [],
+            "cpusetCpus": "",
+            "cpuUsage": 100,
+            "workingDir": "",
+            "env": []
+        }
+
+        supported_keys = set(default.keys())
+        unsupported_keys = set(kwargs.keys()) - supported_keys
+
+        if unsupported_keys:
+            raise ValueError(
+                f"Unsupported keys: {unsupported_keys}. Supported keys are: {supported_keys}")
+
+        config = default.copy()
+        config.update(kwargs)
+
+        return config
+
+# Unused functions
+# ...
+
+# Unused functions
+#    def typeOfInstanceDetail(self, **kwargs):
+#        default = {
+#            "config": self.typeOfInstanceConfig(),
+#            "info": {
+#                "currentPlayers": -1,
+#                "fileLock": 0,
+#                "maxPlayers": -1,
+#                "openFrpStatus": False,
+#                "playersChart": [],
+#                "version": "",
+#            },
+#            "instanceUuid": "50c73059001b436fa85c0d8221c157cf",
+#            "processInfo": {
+#                "cpu": 0,
+#                "memory": 0,
+#                "ppid": 0,
+#                "pid": 0,
+#                "ctime": 0,
+#                "elapsed": 0,
+#                "timestamp": 0
+#            },
+#            "space": 0,
+#            "started": 6,
+#            "status": 3,
+#        }
+#
+#       supported_keys = set(default.keys())
+#        unsupported_keys = set(kwargs.keys()) - supported_keys
+#
+#       if unsupported_keys:
+#            raise ValueError(
+#                f"Unsupported keys: {unsupported_keys}. Supported keys are: {supported_keys}")
+#
+#        config = default.copy()
+#        config.update(kwargs)
+#
+#       return config

mcsmapi/overview.py

@@ -0,0 +1,35 @@
+from .common import support_login, ApiClient
+import requests
+
+
+@support_login
+class Overview:
+    """
+    Represents an overview client that interacts with an API endpoint.
+
+    Attributes:
+        client (ApiClient): The API client used for making requests.
+
+    Args:
+        url (str): The base URL of the API.
+        apikey (str, optional): The API key for authentication. Defaults to None.
+    """
+
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initializes a new instance of the Overview class.
+
+        Args:
+            url (str): The base URL of the API.
+            apikey (str, optional): The API key for authentication. Defaults to None.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def get_data(self) -> requests.Response:
+        """
+        Retrieves overview data from the API.
+
+        Returns:
+            dict: The overview data as returned by the API.
+        """
+        return self.client.send("GET", "overview")

mcsmapi/users.py

@@ -0,0 +1,83 @@
+from .common import support_login, ApiClient
+import requests
+
+
+@support_login
+class Users:
+    """
+    Represents a users client that interacts with an API endpoint for user management.
+
+    Attributes:
+        client (ApiClient): The API client used for making requests.
+
+    Args:
+        url (str): The base URL of the API.
+        apikey (str, optional): The API key for authentication. Defaults to None.
+    """
+
+    def __init__(self, url: str, apikey: str = None):
+        """
+        Initializes a new instance of the Users class.
+
+        Args:
+            url (str): The base URL of the API.
+            apikey (str, optional): The API key for authentication. Defaults to None.
+        """
+        self.client = ApiClient(url, apikey)
+
+    def get_list(self, username: str = "", page: int = 1, page_size: int = 10, role: str = "") -> requests.Response:
+        """
+        Retrieves a list of users from the API.
+
+        Args:
+            username (str, optional): The username to search for. Defaults to "".
+            page (int, optional): The page number for pagination. Defaults to 1.
+            page_size (int, optional): The number of items per page. Defaults to 10.
+            role (str, optional): The role to filter by. Defaults to "".
+
+        Returns:
+            dict: The list of users as returned by the API.
+        """
+        return self.client.send("GET", "auth/search", params={
+            "userName": username, "page": page, "page_size": page_size, "role": role})
+
+    def create(self, username: str, password: str, permission: int = 1) -> requests.Response:
+        """
+        Creates a new user.
+
+        Args:
+            username (str): The username for the new user.
+            password (str): The password for the new user.
+            permission (int, optional): The permission level for the new user. Defaults to 1.
+
+        Returns:
+            dict: The response from the API after creating the user.
+        """
+        return self.client.send("POST", "auth", data={
+            "username": username, "password": password, "permission": permission})
+
+    def update(self, uuid: str, config: dict = {}) -> requests.Response:
+        """
+        Updates an existing user.
+
+        Args:
+            uuid (str): The UUID of the user to update.
+            config (dict, optional): The configuration updates for the user. Defaults to {}.
+
+        Returns:
+            dict: The response from the API after updating the user.
+        """
+        return self.client.send("PUT", "auth", data={
+            "uuid": uuid, "config": config})
+
+    def delete(self, uuids: list = []) -> requests.Response:
+        """
+        Deletes one or more users.
+
+        Args:
+            uuids (list, optional): A list of UUIDs of the users to delete. Defaults to [].
+
+        Returns:
+            dict: The response from the API after deleting the users.
+        """
+        return self.client.send("DELETE", "auth", data=uuids)

mcsmapi-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 molanp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcsmapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: mcsmapi
+Version: 0.1.0
+Summary: A Pypi package based on MCSManager, designed to simplify interaction with MCSM API.
+Home-page: https://github.com/molanp/mcsmapi
+Author: molanp
+Author-email: luotian233@foxmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: aiohttp
+
+# MCSM API Client
+
+![Supported MCSManager Versions](https://img.shields.io/badge/Supported%20MCSManager%20Versions-10.2.1,10.1.0-blue)
+![Python Version](https://img.shields.io/badge/Python%20Version-%3E%3D3.7-blue)
+![PyPI Downloads](https://img.shields.io/pypi/dm/mcsmapi_client)
+
+English|[简体中文](README_zh-cn.md)
+
+## Introduction
+
+`mcsmapi-client` is a Pypi package based on [MCSManager](https://github.com/MCSManager/MCSManager), designed to simplify interaction with MCSM API.
+
+Through this library, you can easily access and operate various functions provided by MCSM.
+
+## Installation
+
+You can use `pip` to install `mcsmapi-client`:
+
+```bash
+pip install mcsmapi_client
+```
+
+## Usage method
+
+### Example code
+
+Here are some examples of how to use `mcsmapi-client`:
+
+```python
+from mcsmapi import overview
+
+# if you have a apikey, you can use this method
+client = Overview(url=" https://example.com/",apikey="your_api_key")
+
+# if you do not have a apikey, you can use this method
+client = Overview(url=" https://example.com/")
+# login
+client.login(username="your_username",password="your_password")
+
+# Get dashboard data
+response = client.getData()
+print(response.json())
+```
+
+### Supported functions
+
+- [x] Login (`(func) login`)
+- [x] Dashboard Data (`(cls) Overview`)
+- [x] User Management (`(cls) Users`)
+- [x] Instance Management (`(cls) Instance`)
+- [x] Daemon Management (`(cls) Daemon`)
+- [x] File Management (`(cls) File`)
+- [x] Image Management (`(cls) Image`)
+
+## Supported MCSM versions
+
+The current version of MCSMAPI client supports the following MCSM versions:
+
+- 10.2.1
+- 10.1.0
+
+## Compatible Python versions
+
+- Python version 3.7 and above.
+
+## Contribution
+
+If you find any issues or have improvement suggestions, please feel free to submit [Issue](https://github.com/molanp/mcsmapi-client/issues) or create a [Pull Request](https://github.com/molanp/mcsmapi-client/pulls).
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT).
+
+Please refer to [LICENSE](LICENSE) File for more information.

mcsmapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+mcsmapi/__init__.py,sha256=ZZYFSPzhioM6uQOejbcrxs3phmCXT16YZF2-CZGZldk,204
+mcsmapi/common.py,sha256=rsa0lsKd2pEMvrVWTKa-pn03CQH89hlGEFm_OHmntaM,1003
+mcsmapi/daemon.py,sha256=ghkyy3aihFL4vr3qXd-LQWgujfkjEhwlfiGhU54IdXM,3100
+mcsmapi/file.py,sha256=dmd_G9zeujDs471Miw4VL0mfumcckDL-pnfHyuGfe4I,11968
+mcsmapi/image.py,sha256=aqgR5UZCqc-tfL-HXQk-KFTqkhXk75ordYf_F-Q23pY,3202
+mcsmapi/instance.py,sha256=jNGwtDJ-L636ouB2HkDwazXF5BtjkjK48lIg_KL3LRs,15296
+mcsmapi/overview.py,sha256=vzJFzE5DEmbhqSXqPk_X7kuR8mSQGEQPjuYy45BgRBE,980
+mcsmapi/users.py,sha256=BQT3dG8IVmstzJHCArv7Hfvpzw0HDj2JQ3AmvtvwVb8,2958
+mcsmapi-0.1.0.dist-info/LICENSE,sha256=kn0yZGn5uLIJtr2aAXy8pz_wJqal15ZGnynTU1fCnLQ,1063
+mcsmapi-0.1.0.dist-info/METADATA,sha256=gdqO5nYXYdx6bTDlFr3bXUuGTYCNVDUKon0sIvSZoG0,2481
+mcsmapi-0.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+mcsmapi-0.1.0.dist-info/top_level.txt,sha256=8MUYHd1Or4cbSCd93IaqLA72w0weEuKieopVwIfVlWo,8
+mcsmapi-0.1.0.dist-info/RECORD,,

mcsmapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mcsmapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcsmapi