nexus-hostinger 1.0.0__py3-none-any.whl

nexus_hosting/__init__.py

@@ -0,0 +1,20 @@
+"""
+SDK Oficial da NEXUS HOSTINGER para Python.
+"""
+
+from .client import NexusClient
+from .exceptions import (
+    NexusApiError,
+    NexusAuthError,
+    NexusRateLimitError,
+    NexusNotFoundError,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "NexusClient",
+    "NexusApiError",
+    "NexusAuthError",
+    "NexusRateLimitError",
+    "NexusNotFoundError",
+]

nexus_hosting/client.py

@@ -0,0 +1,212 @@
+"""
+Cliente oficial síncrono para a API da NEXUS HOSTINGER em Python.
+"""
+
+from typing import Dict, Any, Optional, List
+import requests
+from .exceptions import (
+    NexusApiError,
+    NexusAuthError,
+    NexusRateLimitError,
+    NexusNotFoundError,
+)
+
+class _AccountResource:
+    def __init__(self, client: "NexusClient"):
+        self._client = client
+
+    def get_resources(self) -> Dict[str, Any]:
+        """Consulta cota total de vCPU, memória RAM e instâncias contratadas vs utilizadas."""
+        return self._client._request("GET", "/account/resources")
+
+class _FilesResource:
+    def __init__(self, client: "NexusClient"):
+        self._client = client
+
+    def list(self, bot_id: str) -> List[Dict[str, Any]]:
+        """Lista todos os arquivos e diretórios da aplicação."""
+        res = self._client._request("GET", f"/bots/{bot_id}/files")
+        return res.get("data", [])
+
+    def read(self, bot_id: str, path: str) -> Dict[str, Any]:
+        """Lê o conteúdo em texto de um arquivo específico."""
+        res = self._client._request("GET", f"/bots/{bot_id}/files/content", params={"path": path})
+        return res.get("data", {})
+
+    def save(self, bot_id: str, path: str, content: str) -> Dict[str, Any]:
+        """Salva ou atualiza um arquivo no contêiner da aplicação."""
+        return self._client._request("PUT", f"/bots/{bot_id}/files", json={"path": path, "content": content})
+
+    def delete(self, bot_id: str, path: str) -> Dict[str, Any]:
+        """Exclui um arquivo da aplicação."""
+        return self._client._request("DELETE", f"/bots/{bot_id}/files", params={"path": path})
+
+class _BotsResource:
+    def __init__(self, client: "NexusClient"):
+        self._client = client
+        self.files = _FilesResource(client)
+
+    def list(self) -> List[Dict[str, Any]]:
+        """Lista todos os bots/servidores do workspace."""
+        res = self._client._request("GET", "/bots")
+        return res.get("data", [])
+
+    def get(self, bot_id: str) -> Dict[str, Any]:
+        """Retorna detalhes de configuração e status de um bot."""
+        res = self._client._request("GET", f"/bots/{bot_id}")
+        return res.get("data", {})
+
+    def create(
+        self,
+        name: str,
+        runtime: str = "NODEJS_20",
+        entrypoint: Optional[str] = None,
+        memory_limit_mb: int = 256,
+        cpu_limit: float = 0.25,
+        app_type: str = "BOT",
+        subdomain: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Provisiona um novo bot consumindo os recursos do plano."""
+        body = {
+            "name": name,
+            "runtime": runtime,
+            "entrypoint": entrypoint,
+            "memoryLimitMb": memory_limit_mb,
+            "cpuLimit": cpu_limit,
+            "appType": app_type,
+            "subdomain": subdomain,
+        }
+        return self._client._request("POST", "/bots", json=body)
+
+    def update(
+        self,
+        bot_id: str,
+        name: Optional[str] = None,
+        entrypoint: Optional[str] = None,
+        cpu_limit: Optional[float] = None,
+        memory_limit_mb: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Atualiza configurações de um bot existente."""
+        body = {}
+        if name is not None:
+            body["name"] = name
+        if entrypoint is not None:
+            body["entrypoint"] = entrypoint
+        if cpu_limit is not None:
+            body["cpuLimit"] = cpu_limit
+        if memory_limit_mb is not None:
+            body["memoryLimitMb"] = memory_limit_mb
+        return self._client._request("PATCH", f"/bots/{bot_id}", json=body)
+
+    def delete(self, bot_id: str) -> Dict[str, Any]:
+        """Exclui permanentemente o bot e libera os recursos no plano."""
+        return self._client._request("DELETE", f"/bots/{bot_id}")
+
+    def start(self, bot_id: str) -> Dict[str, Any]:
+        """Inicia o contêiner do bot."""
+        return self._client._request("POST", f"/bots/{bot_id}/start")
+
+    def stop(self, bot_id: str) -> Dict[str, Any]:
+        """Desliga o contêiner do bot."""
+        return self._client._request("POST", f"/bots/{bot_id}/stop")
+
+    def restart(self, bot_id: str) -> Dict[str, Any]:
+        """Reinicia o contêiner do bot."""
+        return self._client._request("POST", f"/bots/{bot_id}/restart")
+
+    def stats(self, bot_id: str) -> Dict[str, Any]:
+        """Consulta métricas de hardware (CPU, RAM, rede) em tempo real."""
+        res = self._client._request("GET", f"/bots/{bot_id}/stats")
+        return res.get("data", {})
+
+    def logs(self, bot_id: str, lines: int = 100) -> List[str]:
+        """Retorna as últimas linhas de log do console."""
+        res = self._client._request("GET", f"/bots/{bot_id}/logs", params={"lines": lines})
+        return res.get("data", {}).get("logs", [])
+
+    def exec(self, bot_id: str, command: str) -> Dict[str, Any]:
+        """Executa um comando shell de forma segura no contêiner isolado."""
+        res = self._client._request("POST", f"/bots/{bot_id}/exec", json={"command": command})
+        return res.get("data", {})
+
+    def get_env(self, bot_id: str) -> List[Dict[str, Any]]:
+        """Lista variáveis de ambiente cadastradas."""
+        res = self._client._request("GET", f"/bots/{bot_id}/env")
+        return res.get("data", [])
+
+    def set_env(self, bot_id: str, variables: Dict[str, str]) -> Dict[str, Any]:
+        """Injeta ou atualiza variáveis de ambiente em lote."""
+        return self._client._request("POST", f"/bots/{bot_id}/env", json={"variables": variables})
+
+    def delete_env(self, bot_id: str, key: str) -> Dict[str, Any]:
+        """Remove uma variável de ambiente específica."""
+        return self._client._request("DELETE", f"/bots/{bot_id}/env/{key}")
+
+    def list_backups(self, bot_id: str) -> List[Dict[str, Any]]:
+        """Lista backups da aplicação."""
+        res = self._client._request("GET", f"/bots/{bot_id}/backups")
+        return res.get("data", [])
+
+    def create_backup(self, bot_id: str, name: Optional[str] = None) -> Dict[str, Any]:
+        """Cria um backup dos arquivos sob demanda."""
+        return self._client._request("POST", f"/bots/{bot_id}/backups", json={"name": name} if name else {})
+
+class NexusClient:
+    """Cliente oficial para integração com a API da NEXUS HOSTINGER."""
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://nexushost.cloud/api/v1",
+        timeout: int = 15,
+    ):
+        if not api_key:
+            raise ValueError("api_key é obrigatória para inicializar o NexusClient.")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": "NexusHosting-PythonSDK/1.0.0",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+
+        self.account = _AccountResource(self)
+        self.bots = _BotsResource(self)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        try:
+            res = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as e:
+            raise NexusApiError(f"Falha de conexão com a API NEXUS: {str(e)}")
+
+        try:
+            data = res.json()
+        except ValueError:
+            data = {"raw": res.text}
+
+        if not res.ok:
+            msg = data.get("message") or f"Erro na requisição para {url} (HTTP {res.status_code})"
+            if res.status_code in (401, 403):
+                raise NexusAuthError(msg, res.status_code, data)
+            if res.status_code == 429:
+                raise NexusRateLimitError(msg, res.status_code, data)
+            if res.status_code == 404:
+                raise NexusNotFoundError(msg, res.status_code, data)
+            raise NexusApiError(msg, res.status_code, data)
+
+        return data

nexus_hosting/exceptions.py

@@ -0,0 +1,28 @@
+"""
+Exceções customizadas do SDK NEXUS HOSTINGER.
+"""
+
+class NexusApiError(Exception):
+    """Exceção base lançada em erros de requisição ou retorno HTTP da API NEXUS."""
+    def __init__(self, message: str, status_code: int = 0, response_body: dict = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.response_body = response_body or {}
+
+    def __str__(self):
+        if self.status_code:
+            return f"[HTTP {self.status_code}] {self.message}"
+        return self.message
+
+class NexusAuthError(NexusApiError):
+    """Lançada quando a API Key é inválida, revogada ou expirou."""
+    pass
+
+class NexusRateLimitError(NexusApiError):
+    """Lançada quando a cota de requisições por minuto do plano foi atingida."""
+    pass
+
+class NexusNotFoundError(NexusApiError):
+    """Lançada quando o recurso (bot, arquivo, backup) não foi localizado."""
+    pass

nexus_hostinger-1.0.0.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: nexus-hostinger
+Version: 1.0.0
+Summary: SDK Oficial em Python para automação e integração com a API da NEXUS HOSTINGER
+Author-email: NEXUS HOSTINGER <suporte@nexushost.cloud>
+Project-URL: Homepage, https://nexushost.cloud
+Project-URL: Documentation, https://nexushost.cloud/docs
+Project-URL: Discord, https://discord.gg/9F99uS7UWe
+Keywords: nexus,discord,hosting,cloud,bots,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: async
+Requires-Dist: httpx>=0.24.0; extra == "async"
+
+# ⚡ NEXUS HOSTINGER — Python SDK
+
+SDK Oficial em Python para automação, monitoramento e gerenciamento de aplicações na plataforma [NEXUS HOSTINGER](https://nexushost.cloud).
+
+---
+
+## 📦 Instalação
+
+```bash
+pip install nexus-hostinger
+```
+
+---
+
+## 🚀 Como Usar
+
+### 1. Inicializando o Cliente
+
+Gere sua Chave de API no painel em **Desenvolvedor > Chaves de API**:
+
+```python
+from nexus_hosting import NexusClient
+
+nexus = NexusClient(api_key="nexus_live_sua_chave_aqui")
+```
+
+---
+
+### 2. Exemplos Práticos
+
+#### 📊 Consultar Recursos do Workspace
+```python
+resources = nexus.account.get_resources()
+print(resources["data"]["resources"])
+```
+
+#### 🤖 Gerenciar Bots
+```python
+# Listar todos os bots
+bots = nexus.bots.list()
+for bot in bots:
+    print(f"[{bot['status']}] {bot['name']} (ID: {bot['id']})")
+
+# Iniciar, desligar ou reiniciar
+nexus.bots.restart("id-do-bot")
+
+# Inspecionar estatísticas em tempo real
+stats = nexus.bots.stats("id-do-bot")
+print(f"Uso de RAM: {stats.get('memoryUsageMb', 0)}MB")
+
+# Consultar logs do console
+logs = nexus.bots.logs("id-do-bot", lines=50)
+for line in logs:
+    print(line)
+```
+
+#### ⚡ Execução de Comandos Shell no Contêiner
+```python
+res = nexus.bots.exec("id-do-bot", "pip list")
+print(res["output"])
+```
+
+#### 📁 Manipulação de Arquivos (REST Files API)
+```python
+# Listar arquivos
+files = nexus.bots.files.list("id-do-bot")
+
+# Ler arquivo
+config = nexus.bots.files.read("id-do-bot", "config.json")
+print(config["content"])
+
+# Salvar ou atualizar arquivo
+nexus.bots.files.save("id-do-bot", "config.json", '{"prefix": "!"}')
+```
+
+---
+
+## 🛡️ Tratamento de Erros
+
+```python
+from nexus_hosting import NexusClient, NexusAuthError, NexusRateLimitError, NexusApiError
+
+try:
+    nexus = NexusClient(api_key="chave_invalida")
+    bots = nexus.bots.list()
+except NexusAuthError:
+    print("Chave de API inválida ou expirada!")
+except NexusRateLimitError:
+    print("Limite de requisições por minuto atingido. Aguarde alguns instantes.")
+except NexusApiError as e:
+    print(f"Erro na API NEXUS: {e}")
+```
+
+---
+
+## 🌐 Links Oficiais
+* **Painel:** https://nexushost.cloud
+* **Documentação:** https://nexushost.cloud/docs
+* **Comunidade Discord:** https://discord.gg/9F99uS7UWe

nexus_hostinger-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+nexus_hosting/__init__.py,sha256=CwPpXo30UXbnFxM1AqTTK4M-oI_SFcSmt-6SrP9DY7Y,353
+nexus_hosting/client.py,sha256=ityc_geXVR3kNbxNq58Jje9l9WNB5QtLQDBmGeVHLPw,8251
+nexus_hosting/exceptions.py,sha256=H9JcrfZRYeEMTWf_4oxrQi8xDR9RtMRRAsZipGjgvKU,948
+nexus_hostinger-1.0.0.dist-info/METADATA,sha256=flwBl9Zdshr55eunq4Pp9PhqX6fBFn2XrcYIJP4VTVM,3194
+nexus_hostinger-1.0.0.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+nexus_hostinger-1.0.0.dist-info/top_level.txt,sha256=WUzcrP-AEBbQ50XIvE2RBUlz9D9wKUJN_mhfi25WXvI,14
+nexus_hostinger-1.0.0.dist-info/RECORD,,

nexus_hostinger-1.0.0.dist-info/WHEEL

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

nexus_hostinger-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nexus_hosting