golv 1.1.0__py3-none-any.whl

golv/__init__.py

@@ -0,0 +1,25 @@
+from .setup_golv import GoLVSetup
+from .client import GoLVClient
+from .agent import GoLVAgent
+from .models import (
+    VMConfig, VMType, CommandResult,
+    CommandRequest, CommandSecurityLevel, VMStatus, AgentConfig
+)
+from .exceptions import GoLVError, AuthError, VMNotFoundError, SecurityError
+
+__all__ = [
+    "GoLVSetup",
+    "GoLVClient",
+    "GoLVAgent",
+    "VMConfig",
+    "VMType",
+    "CommandResult",
+    "CommandRequest",
+    "CommandSecurityLevel",
+    "VMStatus",
+    "AgentConfig",
+    "GoLVError",
+    "AuthError",
+    "VMNotFoundError",
+    "SecurityError",
+]

golv/agent.py

@@ -0,0 +1,142 @@
+from typing import Optional, List, Dict, Any
+from .client import GoLVClient
+from .models import VMConfig, AgentConfig, CommandSecurityLevel, CommandResult
+from .exceptions import SecurityError
+
+class GoLVAgent:
+    """Agent sécurisé pour l'exécution de commandes par IA"""
+    
+    def __init__(self, config: AgentConfig):
+        self.config = config
+        self.client = GoLVClient(api_key=config.api_key)
+        
+        # Initialiser ou créer la VM
+        if config.vm_config.vm_id:
+            self.vm_id = config.vm_config.vm_id
+        else:
+            self._create_vm()
+    
+    def _create_vm(self):
+        """Créer une nouvelle VM selon la configuration"""
+        vm_data = self.client.create_vm(self.config.vm_config)
+        self.vm_id = vm_data.get("vm_id")
+        print(f"✅ VM créée: {self.vm_id}")
+    
+    def _validate_command(self, command: str) -> bool:
+        """Valider une commande pour la sécurité"""
+        # Longueur maximale
+        if len(command) > self.config.max_command_length:
+            raise SecurityError(f"Commande trop longue ({len(command)} > {self.config.max_command_length})")
+        
+        # Commandes bannies
+        banned_patterns = [
+            "rm -rf", "shutdown", "reboot", "dd", "mkfs", 
+            ":(){", "chmod 777", "> /dev/sda", "mkfifo"
+        ]
+        
+        for banned in banned_patterns:
+            if banned in command.lower():
+                raise SecurityError(f"Commande bannie détectée: {banned}")
+        
+        # Vérifier si la commande est autorisée
+        if self.config.use_command:
+            first_word = command.split()[0] if command.split() else ""
+            
+            # Toujours autoriser echo et python
+            if first_word in ["echo", "python", "python3"]:
+                return True
+            
+            # Vérifier dans la liste des commandes autorisées
+            if first_word not in self.config.allowed_commands:
+                raise SecurityError(f"Commande non autorisée: {first_word}")
+        
+        return True
+    
+    def execute(self, command: str, timeout: Optional[int] = None) -> CommandResult:
+        """Exécuter une commande de manière sécurisée"""
+        try:
+            # Validation de sécurité
+            self._validate_command(command)
+            
+            # Exécution
+            result = self.client.execute_command(
+                vm_id=self.vm_id,
+                command=command,
+                timeout=timeout or self.config.timeout
+            )
+            
+            # Journalisation
+            self._log_execution(command, result)
+            
+            return result
+            
+        except Exception as e:
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr=f"Erreur sécurité: {str(e)}",
+                return_code=1,
+                vm_id=self.vm_id,
+                command=command,
+                duration_ms=0,
+                executed_at=""
+            )
+    
+    def execute_safe(self, command: str) -> str:
+        """Exécuter une commande et retourner seulement la sortie"""
+        result = self.execute(command)
+        return result.stdout if result.success else f"Erreur: {result.stderr}"
+    
+    def execute_python(self, code: str) -> CommandResult:
+        """Exécuter du code Python"""
+        # Échapper les guillemets
+        escaped_code = code.replace('"', '\\"').replace("'", "\\'")
+        command = f'python3 -c "{escaped_code}"'
+        return self.execute(command)
+    
+    def execute_git(self, git_command: str) -> CommandResult:
+        """Exécuter une commande Git"""
+        if "git" not in self.config.allowed_commands:
+            raise SecurityError("Commandes Git non autorisées")
+        
+        command = f"git {git_command}"
+        return self.execute(command)
+    
+    def predefined(self, command_type: str) -> CommandResult:
+        """Exécuter une commande pré-définie"""
+        return self.client.execute_predefined(self.vm_id, command_type)
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Récupérer le statut de la VM"""
+        return self.client.get_vm_status(self.vm_id)
+    
+    def _log_execution(self, command: str, result: CommandResult):
+        """Journaliser l'exécution (peut être étendu)"""
+        status = "✅" if result.success else "❌"
+        print(f"{status} [{result.duration_ms}ms] {command[:50]}...")
+    
+    def interactive_session(self):
+        """Session interactive pour débogage"""
+        print(f"🔧 Session interactive GoLV Agent")
+        print(f"VM ID: {self.vm_id}")
+        print(f"Sécurité: {self.config.security_level.value}")
+        print(f"Commandes autorisées: {len(self.config.allowed_commands)}")
+        print("Tapez 'exit' pour quitter")
+        print("-" * 50)
+        
+        while True:
+            try:
+                cmd = input(f"golv:{self.vm_id[:8]} $ ")
+                if cmd.lower() in ['exit', 'quit', 'q']:
+                    break
+                if not cmd.strip():
+                    continue
+                
+                result = self.execute(cmd)
+                print(result.output)
+                
+            except KeyboardInterrupt:
+                print("\nInterrompu")
+                break
+            except Exception as e:
+                print(f"Erreur: {e}")

golv/client.py

@@ -0,0 +1,158 @@
+import requests
+import json
+from typing import Optional, Dict, Any, List
+from .models import VMConfig, CommandResult
+from .exceptions import GoLVError, AuthError, VMNotFoundError
+
+class GoLVClient:
+    """Client pour l'API GoLV"""
+    
+    def __init__(self, base_url: str = "https://golv.onrender.com", api_key: Optional[str] = None):
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.session = requests.Session()
+        
+        if api_key:
+            self.session.headers.update({
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            })
+    
+    def authenticate(self, username: str, password: str) -> str:
+        """Authentification et récupération du token"""
+        try:
+            response = self.session.post(
+                f"{self.base_url}/api/auth/login",
+                json={"username": username, "password": password}
+            )
+            response.raise_for_status()
+            data = response.json()
+            self.api_key = data["access_token"]
+            self.session.headers.update({"Authorization": f"Bearer {self.api_key}"})
+            return self.api_key
+        except requests.exceptions.RequestException as e:
+            raise AuthError(f"Erreur d'authentification: {e}")
+    
+    def create_vm(self, config: VMConfig) -> Dict[str, Any]:
+        """Créer une nouvelle VM"""
+        try:
+            payload = {
+                "name": config.name or f"VM-{config.vm_type}",
+                "vm_type": config.vm_type.value,
+                "version": config.version,
+                "is_public": config.is_public,
+                "tags": config.tags
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/api/vms",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise GoLVError(f"Erreur création VM: {e}")
+    
+    def execute_command(self, vm_id: str, command: str, 
+                       timeout: int = 30, working_dir: Optional[str] = None) -> CommandResult:
+        """Exécuter une commande dans une VM"""
+        try:
+            payload = {
+                "command": command,
+                "timeout": timeout
+            }
+            
+            if working_dir:
+                payload["working_dir"] = working_dir
+            
+            response = self.session.post(
+                f"{self.base_url}/api/vms/{vm_id}/execute",
+                json=payload
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            if data.get("success"):
+                cmd_data = data["data"]
+                return CommandResult(
+                    success=cmd_data["success"],
+                    stdout=cmd_data["stdout"],
+                    stderr=cmd_data["stderr"],
+                    return_code=cmd_data.get("return_code", 0),
+                    vm_id=vm_id,
+                    command=command,
+                    duration_ms=cmd_data["duration_ms"],
+                    executed_at=cmd_data["executed_at"]
+                )
+            else:
+                raise GoLVError(f"Échec exécution: {data}")
+                
+        except requests.exceptions.RequestException as e:
+            if e.response and e.response.status_code == 404:
+                raise VMNotFoundError(f"VM {vm_id} non trouvée")
+            raise GoLVError(f"Erreur exécution commande: {e}")
+    
+    def execute_predefined(self, vm_id: str, command_type: str) -> CommandResult:
+        """Exécuter une commande pré-définie"""
+        try:
+            response = self.session.post(
+                f"{self.base_url}/api/vms/{vm_id}/execute/predefined",
+                json=command_type
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            if data.get("success"):
+                cmd_data = data["data"]
+                return CommandResult(
+                    success=cmd_data["success"],
+                    stdout=cmd_data["stdout"],
+                    stderr=cmd_data["stderr"],
+                    return_code=cmd_data.get("return_code", 0),
+                    vm_id=vm_id,
+                    command=f"Predefined: {command_type}",
+                    duration_ms=cmd_data["duration_ms"],
+                    executed_at=cmd_data["executed_at"]
+                )
+            else:
+                raise GoLVError(f"Échec commande pré-définie: {data}")
+                
+        except requests.exceptions.RequestException as e:
+            raise GoLVError(f"Erreur commande pré-définie: {e}")
+    
+    def get_vm_status(self, vm_id: str) -> Dict[str, Any]:
+        """Récupérer le statut d'une VM"""
+        try:
+            response = self.session.get(
+                f"{self.base_url}/api/vms/{vm_id}/status"
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise GoLVError(f"Erreur statut VM: {e}")
+    
+    def list_vms(self, public_only: bool = False) -> List[Dict[str, Any]]:
+        """Lister les VMs"""
+        try:
+            response = self.session.get(
+                f"{self.base_url}/api/vms",
+                params={"public_only": public_only}
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("data", [])
+        except requests.exceptions.RequestException as e:
+            raise GoLVError(f"Erreur liste VMs: {e}")
+    
+    def generate_api_key(self, name: str, expires_in: int = 30) -> str:
+        """Générer une nouvelle clé API"""
+        try:
+            response = self.session.post(
+                f"{self.base_url}/api/api-key/generate",
+                json={"name": name, "expires_in": expires_in}
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("api_key", "")
+        except requests.exceptions.RequestException as e:
+            raise GoLVError(f"Erreur génération clé API: {e}")

golv/exeptions.py

@@ -0,0 +1,19 @@
+class GoLVError(Exception):
+    """Exception de base pour GoLV"""
+    pass
+
+class AuthError(GoLVError):
+    """Erreur d'authentification"""
+    pass
+
+class VMNotFoundError(GoLVError):
+    """VM non trouvée"""
+    pass
+
+class SecurityError(GoLVError):
+    """Erreur de sécurité"""
+    pass
+
+class CommandTimeoutError(GoLVError):
+    """Timeout de commande"""
+    pass

golv/models.py

@@ -0,0 +1,111 @@
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+from enum import Enum
+
+class CommandSecurityLevel(str, Enum):
+    """Niveaux de sécurité pour les commandes"""
+    LOW = "low"      # Commandes basiques (echo, ls, cat)
+    MEDIUM = "medium" # Développement (python, git, npm)
+    HIGH = "high"    # Administration limitée
+    AI = "ai"        # Mode spécial pour IA (toutes commandes sécurisées)
+
+class VMType(str, Enum):
+    """Types de VMs disponibles"""
+    UBUNTU = "ubuntu"
+    DEBIAN = "debian"
+    PYTHON_DEV = "python-dev"
+    NODEJS = "nodejs"
+    DOCKER_HOST = "docker-host"
+    WORDPRESS = "wordpress"
+
+@dataclass
+class VMConfig:
+    """Configuration d'une VM"""
+    vm_id: Optional[str] = None
+    vm_type: VMType = VMType.UBUNTU
+    version: str = "22.04 LTS"
+    name: Optional[str] = None
+    is_public: bool = False
+    tags: List[str] = field(default_factory=list)
+    
+    def __post_init__(self):
+        if not self.name and self.vm_id:
+            self.name = f"VM-{self.vm_id[:8]}"
+@dataclass
+class CommandRequest:
+    """Représente une commande à envoyer"""
+    command: str
+    vm_id: Optional[str] = None
+    timeout: int = 30
+    working_dir: Optional[str] = None
+
+@dataclass
+class VMStatus:
+    """Statut de la VM"""
+    vm_id: str
+    status: str
+    uptime: Optional[str] = None
+    ip_address: Optional[str] = None
+@dataclass
+class CommandResult:
+    """Résultat d'exécution de commande"""
+    success: bool
+    stdout: str
+    stderr: str
+    return_code: int
+    vm_id: str
+    command: str
+    duration_ms: int
+    executed_at: str
+    
+    def __str__(self):
+        status = "✅ SUCCESS" if self.success else "❌ FAILED"
+        return f"{status} [{self.duration_ms}ms] {self.command}\n{self.stdout}"
+    
+    @property
+    def output(self):
+        """Retourne la sortie principale"""
+        return self.stdout if self.success else self.stderr
+
+@dataclass
+class AgentConfig:
+    """Configuration de l'agent IA"""
+    api_key: str
+    vm_config: VMConfig
+    timeout: int = 100
+    use_command: bool = True
+    security_level: CommandSecurityLevel = CommandSecurityLevel.AI
+    allowed_commands: List[str] = field(default_factory=list)
+    max_command_length: int = 500
+    
+    def __post_init__(self):
+        # Commandes autorisées par niveau de sécurité
+        self.allowed_commands = self._get_allowed_commands()
+    
+    def _get_allowed_commands(self) -> List[str]:
+        """Retourne les commandes autorisées selon le niveau"""
+        base_commands = ["pwd", "ls", "echo", "cat"]
+        
+        if self.security_level == CommandSecurityLevel.LOW:
+            return base_commands
+        
+        dev_commands = base_commands + [
+            "python3", "python", "pip", "node", "npm", "git",
+            "mkdir", "touch", "find", "grep"
+        ]
+        
+        if self.security_level == CommandSecurityLevel.MEDIUM:
+            return dev_commands
+        
+        admin_commands = dev_commands + [
+            "curl", "wget", "df", "du", "date",
+            "whoami", "uname", "hostname"
+        ]
+        
+        if self.security_level == CommandSecurityLevel.HIGH:
+            return admin_commands
+        
+        # Mode AI - toutes les commandes sécurisées
+        return admin_commands + [
+            "cd", "head", "tail", "wc", "sort", "uniq"
+        ]

golv/setup_golv.py

@@ -0,0 +1,100 @@
+from typing import Optional
+from .client import GoLVClient
+from .models import VMConfig, VMType, AgentConfig
+from .agent import GoLVAgent
+from .exceptions import GoLVError, AuthError, VMNotFoundError, SecurityError
+
+class GoLVSetup:
+    """
+    Point d'entrée principal du SDK GoLV.
+    Permet :
+    - Authentification
+    - Création de VMConfig
+    - Création d'un agent IA
+    - Accès au client API
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://golv.onrender.com",
+    ):
+        self.base_url = base_url
+        self.api_key = api_key
+
+        # Client API interne
+        self.client = GoLVClient(
+            base_url=self.base_url,
+            api_key=self.api_key
+        )
+
+    # ---------- AUTHENTIFICATION ----------
+
+    def login(self, username: str, password: str) -> str:
+        """
+        Authentifie l'utilisateur et stocke la clé API.
+        """
+        token = self.client.authenticate(username, password)
+        self.api_key = token
+        return token
+
+    # ---------- CONFIGURATION VM ----------
+
+    def create_vm_config(
+        self,
+        name: Optional[str] = None,
+        vm_type: VMType = VMType.UBUNTU,
+        version: str = "22.04 LTS",
+        is_public: bool = False,
+    ) -> VMConfig:
+        """
+        Crée une configuration de VM prête à l'emploi.
+        """
+        return VMConfig(
+            name=name,
+            vm_type=vm_type,
+            version=version,
+            is_public=is_public
+        )
+
+    def create_default_vm(self, name: Optional[str] = None) -> VMConfig:
+        """
+        Crée une VM Ubuntu par défaut.
+        """
+        return self.create_vm_config(name=name)
+
+    # ---------- CREATION AGENT ----------
+
+    def create_agent(
+        self,
+        vm_config: Optional[VMConfig] = None,
+        allowed_commands: Optional[list[str]] = None,
+        max_command_length: int = 200,
+        timeout: int = 30,
+        security_level=None,
+        api_key: Optional[str] = None
+    ) -> GoLVAgent:
+        """
+        Crée un agent GoLV sécurisé.
+        """
+        agent_config = AgentConfig(
+            vm_config=vm_config or self.create_default_vm(),
+            allowed_commands=allowed_commands or [],
+            max_command_length=max_command_length,
+            timeout=timeout,
+            security_level=security_level,
+            api_key=api_key or self.api_key
+        )
+        return GoLVAgent(config=agent_config)
+
+    # ---------- ACCÈS AU CLIENT ----------
+
+    def get_client(self) -> GoLVClient:
+        """
+        Retourne le client API configuré.
+        """
+        return self.client
+
+    def __repr__(self) -> str:
+        auth_state = "authenticated" if self.api_key else "unauthenticated"
+        return f"<GoLVSetup base_url={self.base_url!r} state={auth_state}>"

golv-1.1.0.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: golv
+Version: 1.1.0
+Summary: SDK Python pour GoLV - Terminal sécurisé pour IA
+Home-page: https://github.com/gopu-inc/GoLV-VM
+Author: GOPU.inc
+Author-email: ceoseshell@gmail.com
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pydantic<2.0,>=1.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Provides-Extra: ai
+Requires-Dist: openai>=1.0.0; extra == "ai"
+Requires-Dist: langchain>=0.0.300; extra == "ai"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+# 🚀 GoLV-VM
+<div align="center">
+
+![GoLV Platform](https://img.shields.io/badge/>__GoLV_Virtual_Machines-1e3c72?style=for-the-badge&logo=proxmox&logoColor=white&labelColor=0d47a1)
+[![Vercel Deployment](https://img.shields.io/badge/vercel-appGoLV-blue?logo=vercel)](https://vercel.com/mauricio-100s-projects/golvcloud/HUH6zJsuxbyoxNbRkHLFTtjPf8an)
+[![PyPI Version](https://img.shields.io/pypi/v/golv?color=blue&label=PyPI)](https://pypi.org/project/golv/)
+[![Python Version](https://img.shields.io/badge/python-3.12-blue?logo=python&logoColor=white)](https://www.python.org/)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/MauricioKk-ship-it/GoLV-VM/.github/workflows/pypi-package.yml?branch=main&label=build&logo=github)](https://github.com/MauricioKk-ship-it/GoLV-VM/actions)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)]()
+
+GoLV-VM est un **SDK Python pour la gestion de VMs sécurisées** et l'exécution de commandes via un agent intelligent.  
+Il permet de créer, configurer et exécuter des commandes sur des VMs distantes de manière simple et sécurisée, prêt pour l'intégration avec IA et automation.
+
+---
+
+## ⚡ Features
+
+- ✅ Création et gestion de VMs (Ubuntu, Debian, Python-Dev, NodeJS, Docker, Wordpress)  
+- ✅ SDK facile à utiliser (`GoLVSetup`)  
+- ✅ Agent sécurisé pour exécuter des commandes avec filtrage et sécurité  
+- ✅ Support pour exécuter du code Python et des commandes Git  
+- ✅ Commandes prédéfinies pour automatiser vos VMs  
+- ✅ Gestion des erreurs et sécurité avancée (commandes interdites, longueur maximale, etc.)  
+
+---
+
+## 📦 Installation
+
+# Cloner le repo
+```bash
+git clone https://github.com/gopu-inc/GoLV-VM.git
+cd GoLV-VM
+
+# Installer en mode editable
+pip install -e .
+```
+# via python
+```bash
+pip install golv
+```
+
+---
+
+# 🧰 Usage
+
+Initialisation du SDK
+```python
+from golv import GoLVSetup, VMType
+
+# Initialiser le SDK
+setup = GoLVSetup(api_key="votre_clef_api")
+client = setup.get_client()
+
+# Créer une VM Ubuntu par défaut
+vm_config = setup.create_default_vm("ma-vm")
+vm = client.create_vm(vm_config)
+print("VM créée:", vm)
+
+Création d’un agent sécurisé
+
+from golv import GoLVSetup
+
+setup = GoLVSetup(api_key="votre_clef_api")
+
+# Créer un agent avec commandes autorisées
+agent = setup.create_agent(
+    allowed_commands=["echo", "python", "git"]
+)
+
+# Exécuter une commande
+result = agent.execute("echo 'Hello GoLV'")
+print(result.output)
+
+# Exécuter du code Python
+py_result = agent.execute_python("print('Hello from Python')")
+print(py_result.output)
+
+Commandes sécurisées et prédéfinies
+
+# Commande prédéfinie (ex: list_files)
+predef = agent.predefined("list_files")
+print(predef.output)
+
+# Gestion des erreurs de sécurité
+try:
+    agent.execute("rm -rf /")
+except Exception as e:
+    print("Sécurité:", e)
+
+```
+---
+
+# 📊 Structure du SDK
+```bash
+golv/
+├── __init__.py          # Expose GoLVSetup, Client, Agent, Exceptions
+├── client.py            # Client HTTP pour API GoLV
+├── agent.py             # Agent sécurisé pour exécution de commandes
+├── models.py            # Dataclasses VMConfig, CommandResult, VMType...
+├── exceptions.py        # Gestion des erreurs et sécurité
+└── setup_golv.py        # Classe GoLVSetup (point d'entrée SDK)
+
+```
+---
+
+# 🛡️ Sécurité
+
+Commandes interdites détectées automatiquement (rm -rf, shutdown, etc.)
+
+Longueur maximale des commandes configurable
+
+Liste blanche de commandes autorisées
+
+Agent isolé et sécurisé pour exécution IA
+
+
+
+---
+
+# 🧪 Tests
+```bash
+python test_golv_sdk.py
+```
+Ce script teste :
+
+Création de VM
+
+Agent sécurisé
+
+Exécution de commandes (echo, Python, Git)
+
+Sécurité et exceptions
+
+Commandes prédéfinies
+
+
+
+---
+
+# 🔗 Liens
+
+[GitHub Repo](https://github.com/gopu-inc/GoLV-VM)
+
+[PyPI Package](https://pypi.org/project/golv-py/)
+
+
+-
+---
+
+# 📄 License
+
+MIT © GOPU.inc
+
+---

golv-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+golv/__init__.py,sha256=iOULOp1udfTqXB4LF3oysp9Z9gojIoCHIkJLeKD78H8,577
+golv/agent.py,sha256=hufRhrMxHWUnT1o82osVX9UWYncROEAgAEPARHDe8e8,5385
+golv/client.py,sha256=OurQx9TJIHBzHWrvX49Xw0GnPfwzjeWr3uZCBmXJ0QU,6233
+golv/exeptions.py,sha256=C3IFFiZIo4WG1ue2OJ4j6GgBc4hi_d7TfmTH9kUTyfw,370
+golv/models.py,sha256=dgNvAkYCa8pwqyfFXo7pe_Sbzt4f3LEVHySPS9kbGOY,3370
+golv/setup_golv.py,sha256=kSLjsHrpPVPlTOZvn9iHsCZpN5UtVkWuxEfLaGeS-nw,2854
+golv-1.1.0.dist-info/licenses/LICENSE,sha256=1IwxJJBocSzfqZ81NORFCbPvFxycSA_3EDjbbSI2FAM,1065
+golv-1.1.0.dist-info/METADATA,sha256=U7QScbMHViDZBWx5Q35UYAIQIo3TKuQiKsQUrjBNgec,5363
+golv-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+golv-1.1.0.dist-info/entry_points.txt,sha256=-8ULbipT3Yv4LP4mlry0xOs7L-fj4reUfJhZl1KTmRE,40
+golv-1.1.0.dist-info/top_level.txt,sha256=c4_WAPPlpxSRzeHS_wVZFfN9Za_S_gLlEYserQW5_dY,5
+golv-1.1.0.dist-info/RECORD,,

golv-1.1.0.dist-info/WHEEL

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

golv-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+golv = main_golv:main

golv-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gopu.inc
+
+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.

golv-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+golv