CapsuleCore-shellback 0.1.1__py3-none-any.whl

capsulecore_shellback-0.1.1.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: CapsuleCore-shellback
+Version: 0.1.1
+Summary: Add your description here
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown

capsulecore_shellback-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+shellback/__init__.py,sha256=lXvWZ9aM0TMy1F9_62fwNMPpKrEg9Lk495TIYUQKYkI,244
+shellback/capsule/ArgumentBuilder.py,sha256=ydNk9eJaQGomPfAomLwg-gNM4M-YL3h0C4oJ9ZtLJi0,552
+shellback/capsule/Bash.py,sha256=ahzUuS3kh_32IbtOHF0I-3QizH8AUEZcGuW8qY4M2ik,853
+shellback/capsule/Command.py,sha256=3h5HPao_e6sMMRyStVNhA2OHvNiDCt3F7eLKlh-osM0,370
+shellback/capsule/ConsoleLogger.py,sha256=eAbgzxNMQXK-owvnAkY7Iqp0ejlUO1YCrWkItXSmLBU,1126
+shellback/capsule/NullLogger.py,sha256=Y2s5vlVXnIyT_LzHirl1I85flt0UbMIirsWc-lH6m2k,413
+shellback/capsule/__init__.py,sha256=xo7wDQoOJuNemJQQPZOJg-qd6zlFMpt4hch-hRAx1O0,253
+shellback/core/CommandResult.py,sha256=Gi6nCSPJxjFWHZnJrQ_vBJaz7MPeSITyT5Ev-7X8d8s,803
+shellback/core/Logger.py,sha256=6VuuMjuNqsTrPZQ6t4b4d3VIm8nW2o6C7k9eGbBl5Y0,1240
+shellback/core/SessionContext.py,sha256=ZMoxeQfTskb_FCV2T7gJSZOPiQd5QUL8__ePRF_F1jQ,338
+shellback/core/Shell.py,sha256=oAzRLlv6M3dhTH4IHlRw9pNpWF_VbcWG0Sx9ezR4MPY,3301
+shellback/core/__init__.py,sha256=5l6y_Los6he2QMtdCkNzjBG_X8dw1-xW2VouWPJ-9nQ,202
+capsulecore_shellback-0.1.1.dist-info/METADATA,sha256=7t3NbM5mMFgnTRtnpePhuWIB0_54mOya4mSbb2phbmE,164
+capsulecore_shellback-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+capsulecore_shellback-0.1.1.dist-info/top_level.txt,sha256=UMqhtAp7UJ7yuTXc49iqnumkbxyR1HcokQ7W0IFrJtQ,10
+capsulecore_shellback-0.1.1.dist-info/RECORD,,

capsulecore_shellback-0.1.1.dist-info/WHEEL

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

capsulecore_shellback-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+shellback

shellback/__init__.py

@@ -0,0 +1,4 @@
+from .capsule import ArgumentBuilder, Command, NullLogger, Bash, ConsoleLogger
+from .core import Shell, SessionContext, Logger
+
+__all__ = ["ArgumentBuilder", "Command", "NullLogger", "Bash", "ConsoleLogger", "Shell", "SessionContext", "Logger"]

shellback/capsule/ArgumentBuilder.py

@@ -0,0 +1,17 @@
+from typing import Any, Optional
+
+class ArgumentBuilder:
+    def __init__(self, style: str = "unix"):
+        self._args = []
+        self.style = style # "unix" para --flag o "ms" para /flag
+
+    def add_flag(self, name: str, value: Optional[Any] = None):
+        prefix = "--" if self.style == "unix" else "/"
+        if value is None:
+            self._args.append(f"{prefix}{name}")
+        else:
+            self._args.extend([f"{prefix}{name}", str(value)])
+        return self
+        
+    def build(self) -> list[str]:
+        return self._args

shellback/capsule/Bash.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from ..core import Shell,SessionContext
+
+
+class Bash(Shell):
+    def _format_command(self, executable: str, args: list[str]) -> list[str]:
+        # En Bash, usualmente es directo, pero aquí podríamos manejar
+        # escapes específicos si fuera necesario.
+        return [executable] + args
+
+    def cd(self, path: str | Path):
+        """Actualiza el contexto virtualmente."""
+        new_path = (self.context.cwd / path).resolve()
+        if new_path.exists() and new_path.is_dir():
+            # Re-instanciar el contexto (es inmutable por el dataclass frozen)
+            self.context = SessionContext(
+                cwd=new_path, 
+                env=self.context.env, 
+                encoding=self.context.encoding
+            )
+        else:
+            raise FileNotFoundError(f"Directory {new_path} not found")

shellback/capsule/Command.py

@@ -0,0 +1,15 @@
+from .ArgumentBuilder import ArgumentBuilder
+
+class Command:
+    def __init__(self, executable: str):
+        self.executable = executable
+        self.builder = ArgumentBuilder()
+
+    def add_args(self, *args):
+        for arg in args:
+            self.builder._args.append(arg)
+        return self
+
+    @property
+    def args(self):
+        return self.builder.build()

shellback/capsule/ConsoleLogger.py

@@ -0,0 +1,37 @@
+import sys
+from datetime import datetime
+from ..core import Logger
+
+class ConsoleLogger(Logger):
+    """
+    Implementación que imprime en la salida estándar con colores y timestamps.
+    Ideal para desarrollo y scripts interactivos.
+    """
+    # Códigos ANSI para colores
+    COLORS = {
+        "DEBUG": "\033[94m",    # Azul
+        "INFO": "\033[92m",     # Verde
+        "WARNING": "\033[93m",  # Amarillo
+        "ERROR": "\033[91m",    # Rojo
+        "RESET": "\033[0m"      # Reset
+    }
+
+    def _log(self, level: str, message: str):
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        color = self.COLORS.get(level, self.COLORS["RESET"])
+        reset = self.COLORS["RESET"]
+        
+        # Formato: [14:30:05] [INFO] Mensaje
+        print(f"[{timestamp}] {color}[{level}]{reset} {message}", file=sys.stderr)
+
+    def info(self, message: str):
+        self._log("INFO", message)
+
+    def debug(self, message: str):
+        self._log("DEBUG", message)
+
+    def warning(self, message: str):
+        self._log("WARNING", message)
+
+    def error(self, message: str):
+        self._log("ERROR", message)

shellback/capsule/NullLogger.py

@@ -0,0 +1,19 @@
+from ..core import Logger
+
+class NullLogger(Logger):
+    """
+    Implementación 'Null Object'. 
+    No realiza ninguna acción, permitiendo que la Shell funcione 
+    sin comprobaciones de nulidad constantes.
+    """
+    def info(self, message: str):
+        pass
+
+    def debug(self, message: str):
+        pass
+
+    def warning(self, message: str):
+        pass
+
+    def error(self, message: str):
+        pass

shellback/capsule/__init__.py

@@ -0,0 +1,7 @@
+from .ArgumentBuilder import ArgumentBuilder
+from .Command import Command
+from .NullLogger import NullLogger
+from .Bash import Bash
+from .ConsoleLogger import ConsoleLogger
+
+__all__ = ["ArgumentBuilder", "Command", "NullLogger", "Bash", "ConsoleLogger"]

shellback/core/CommandResult.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Any
+import json
+
+
+@dataclass
+class CommandResult:
+    """Encapsulates the output of an executed command."""
+    standand_output: str
+    standand_error: str
+    return_code: int
+    execution_time: float
+    command_sent: list[str]
+
+    def is_success(self) -> bool:
+        """Returns True if the command executed successfully (return code 0)."""
+        return self.return_code == 0
+
+    def json(self) -> Any:
+        """Parses the standard output as JSON and returns the deserialized object."""
+        return json.loads(self.standand_output)
+    
+    def __or__(self, next_command):
+        """Enables pipe syntax (sh.run(cmd1) | sh.run(cmd2)) for chaining command results by returning the standard output."""
+        return self.standand_output

shellback/core/Logger.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+
+class Logger(ABC):
+    """Defines the interface for any logger that the application can use.
+
+    This abstract base class establishes the contract that all logger
+    implementations must follow, enabling dependency inversion and
+    allowing different logging backends to be swapped without affecting
+    application code.
+    """
+
+    @abstractmethod
+    def info(self, message: str):
+        """Log an informational message.
+
+        Args:
+            message: The string content to log at INFO level
+        """
+        pass
+
+    @abstractmethod
+    def debug(self, message: str):
+        """Log a debug message for detailed diagnostic information.
+
+        Args:
+            message: The string content to log at DEBUG level
+        """
+        pass
+
+    @abstractmethod
+    def warning(self, message: str):
+        """Log a warning message indicating potential issues.
+
+        Args:
+            message: The string content to log at WARNING level
+        """
+        pass
+
+    @abstractmethod
+    def error(self, message: str):
+        """Log an error message for runtime errors or exceptions.
+
+        Args:
+            message: The string content to log at ERROR level
+        """
+        pass

shellback/core/SessionContext.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict
+
+@dataclass(frozen=True)
+class SessionContext:
+    """Mantiene el estado persistente entre ejecuciones de la Shell."""
+    cwd: Path = field(default_factory=Path.cwd)
+    env: Dict[str, str] = field(default_factory=dict)
+    encoding: str = "utf-8"

shellback/core/Shell.py

@@ -0,0 +1,88 @@
+from abc import ABC, abstractmethod
+import shutil
+import time
+import subprocess
+from .Logger import Logger # Asumiendo que usas tu interfaz de Logger
+from ..capsule import NullLogger
+from .SessionContext import SessionContext
+from .CommandResult import CommandResult
+from typing import Optional
+
+class CommandNotFoundError(Exception):
+    """Lanzada cuando el binario no existe en el PATH."""
+    pass
+
+class Shell(ABC):
+    def __init__(self, context: Optional[SessionContext] = None, 
+                 logger: Optional[Logger] = None, 
+                 default_timeout: float = 30.0):
+        self.context = context or SessionContext()
+        self.logger = logger or NullLogger()
+        self.default_timeout = default_timeout
+
+    @abstractmethod
+    def _format_command(self, executable: str, args: list[str]) -> list[str]:
+        """Cada shell hija decide cómo formatear la lista final (Strategy)."""
+        pass
+
+    def __enter__(self):
+        self.logger.info(f"Iniciando sesión de {self.__class__.__name__}")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type:
+            self.logger.error(f"Sesión finalizada con error: {exc_val}")
+        else:
+            self.logger.info(f"Sesión de {self.__class__.__name__} finalizada correctamente")
+        # No retornamos True para que las excepciones sigan propagándose si ocurren
+
+    def run(self, command, timeout: Optional[float] = None) -> CommandResult:
+        """
+        Método 'Template' que coordina la ejecución.
+        """
+        executable = command.executable
+        args = command.args # El ArgumentBuilder ya devuelve una lista
+        
+        # 1. Lazy Check de binario
+        if not shutil.which(executable):
+            self.logger.error(f"Command not found: {executable}")
+            raise CommandNotFoundError(f"The executable '{executable}' was not found in PATH.")
+
+        # 2. Preparación según la Shell específica
+        final_args = self._format_command(executable, args)
+        
+        self.logger.debug(f"Executing: {' '.join(final_args)} in {self.context.cwd}")
+        
+        start_time = time.perf_counter()
+        
+        try:
+            process = subprocess.run(
+                final_args,
+                cwd=self.context.cwd,
+                env={**self.context.env}, # Merge de env actual
+                capture_output=True,
+                text=True,
+                encoding=self.context.encoding,
+                timeout=timeout or self.default_timeout
+            )
+            
+            execution_time = time.perf_counter() - start_time
+            
+            result = CommandResult(
+                standand_output=process.stdout,
+                standand_error=process.stderr,
+                return_code=process.returncode,
+                execution_time=execution_time,
+                command_sent=final_args
+            )
+            
+            if result.is_success():
+                self.logger.info(f"Success: {executable}")
+            else:
+                self.logger.warning(f"Failed: {executable} with code {result.return_code}")
+                
+            return result
+
+        except subprocess.TimeoutExpired as e:
+            self.logger.error(f"Timeout after {self.default_timeout}s")
+            raise e

shellback/core/__init__.py

@@ -0,0 +1,6 @@
+from .CommandResult import CommandResult
+from .Logger import Logger
+from .SessionContext import SessionContext
+from .Shell import Shell 
+
+__all__ = ["CommandResult", "Logger", "SessionContext", "Shell"]