cc.shellback-kit 0.3.0__py3-none-any.whl

cc_shellback_kit/__init__.py

@@ -0,0 +1,34 @@
+from .capsule import (
+    Bash,
+    ConsoleLogObserver,
+    FileLogObserver,
+    SilentObserver,
+    JSONFileObserver,
+    MultiObserver,
+)
+from .core import (
+    Shell,
+    ArgumentBuilder,
+    Command,
+    SessionContext,
+    CommandResult,
+    CommandNotFoundError,
+    ShellObserver,
+)
+
+
+__all__ = [
+    "ArgumentBuilder",
+    "Command",
+    "Bash",
+    "Shell",
+    "SessionContext",
+    "CommandResult",
+    "JSONFileObserver",
+    "CommandNotFoundError",
+    "ShellObserver",
+    "ConsoleLogObserver",
+    "FileLogObserver",
+    "SilentObserver",
+    "MultiObserver",
+]

cc_shellback_kit/capsule/Bash.py

@@ -0,0 +1,8 @@
+from ..core import Shell
+
+
+class Bash(Shell):
+    def _format_command(self, executable: str, args: list[str]) -> list[str]:
+        # Ya no concatenamos [executable] + args aquí.
+        # Solo devolvemos los args tal cual, la Shell base hará el resto.
+        return args

cc_shellback_kit/capsule/ConsoleLogObserver.py

@@ -0,0 +1,16 @@
+from ..core import CommandResult, ShellObserver
+
+
+class ConsoleLogObserver(ShellObserver):
+    """Muestra en consola lo que está pasando en tiempo real."""
+
+    def on_command_start(self, executable, final_args):
+        print(f"🛠️  Ejecutando: {' '.join(final_args)}")
+
+    def on_command_result(self, result: CommandResult):
+        if result.is_success():
+            print(f"✅ OK ({result.execution_time:.3f}s)")
+        else:
+            print(f"❌ FALLO (Código: {result.return_code})")
+            if result.standard_error:
+                print(f"   Error: {result.standard_error.strip()}")

cc_shellback_kit/capsule/FileLogObserver.py

@@ -0,0 +1,49 @@
+import logging
+from pathlib import Path
+from ..core import ShellObserver, CommandResult
+
+
+class FileLogObserver(ShellObserver):
+    """Guarda toda la actividad de la Shell en un archivo físico."""
+
+    def __init__(self, log_path: str = "shell_activity.log"):
+            self.log_path = Path(log_path)
+
+            self.logger = logging.getLogger("ShellFileLogger")
+            self.logger.setLevel(logging.INFO)
+            self.logger.propagate = False  # Evita que los logs salgan por consola en los tests
+
+            if self.logger.handlers:
+                for h in self.logger.handlers[:]:
+                    h.close()
+                    self.logger.removeHandler(h)
+
+            # Ahora creamos el nuevo handler con la ruta correcta
+            handler = logging.FileHandler(self.log_path, encoding="utf-8")
+            formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+            handler.setFormatter(formatter) 
+            self.logger.addHandler(handler)
+
+    def on_session_start(self, shell_name: str):
+        self.logger.info(f"=== INICIO DE SESIÓN: {shell_name} ===")
+
+    def on_session_end(self, shell_name: str, error: Exception = None):
+        if error:
+            self.logger.error(f"=== FIN DE SESIÓN CON ERROR: {error} ===")
+        else:
+            self.logger.info("=== FIN DE SESIÓN EXITOSO ===")
+
+    def on_command_start(self, executable: str, final_args: list[str]):
+        cmd_str = " ".join(final_args)
+        self.logger.info(f"EJECUTANDO: {cmd_str}")
+
+    def on_command_result(self, result: CommandResult):
+        status = "SUCCESS" if result.is_success() else f"FAILED({result.return_code})"
+        self.logger.info(
+            f"RESULTADO: {status} | "
+            f"DURACIÓN: {result.execution_time:.4f}s | "
+            f"STDOUT: {result.standard_output.strip()[:100]}..."
+        )
+
+    def on_error(self, message: str, error: Exception = None):
+        self.logger.error(f"ERROR DEL SISTEMA: {message} | Detalle: {error}")

cc_shellback_kit/capsule/JSONFileObserver.py

@@ -0,0 +1,63 @@
+import json
+import time
+from pathlib import Path
+from typing import Any, List, Optional, Dict
+from ..core import ShellObserver, CommandResult
+
+class JSONFileObserver(ShellObserver):
+    """
+    Registra toda la actividad de la Shell en un archivo JSON.
+    Ideal para auditoría técnica y análisis de datos posterior.
+    """
+
+    def __init__(self, log_path: str = "shell_audit.json"):
+        self.log_path = Path(log_path)
+        # Inicializamos el archivo si no existe
+        if not self.log_path.exists():
+            self._write_logs([])
+
+    def _read_logs(self) -> List[Dict[str, Any]]:
+        try:
+            with open(self.log_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return []
+
+    def _write_logs(self, logs: List[Dict[str, Any]]):
+        with open(self.log_path, "w", encoding="utf-8") as f:
+            json.dump(logs, f, indent=4, ensure_ascii=False)
+
+    def _append_entry(self, entry: Dict[str, Any]):
+        logs = self._read_logs()
+        logs.append(entry)
+        self._write_logs(logs)
+
+    def on_command_result(self, result: CommandResult):
+        entry = {
+            "timestamp": time.time(),
+            "event": "command_executed",
+            "command": result.command_sent,
+            "success": result.is_success(),
+            "exit_code": result.return_code,
+            "duration": round(result.execution_time, 4),
+            "stdout_len": len(result.standard_output),
+            "stderr": result.standard_error.strip() if result.standard_error else None
+        }
+        self._append_entry(entry)
+
+    def on_context_change(self, key: str, value: Any):
+        entry = {
+            "timestamp": time.time(),
+            "event": "context_mutation",
+            "change": {key: str(value)}
+        }
+        self._append_entry(entry)
+
+    def on_error(self, message: str, error: Optional[Exception] = None):
+        entry = {
+            "timestamp": time.time(),
+            "event": "internal_error",
+            "message": message,
+            "exception": str(error) if error else None
+        }
+        self._append_entry(entry)

cc_shellback_kit/capsule/MultiObserver.py

@@ -0,0 +1,39 @@
+from typing import List, Any
+from ..core import ShellObserver, CommandResult
+
+
+class MultiObserver(ShellObserver):
+    """
+    Patrón Composite: Permite registrar múltiples observadores y
+    notificar a todos ellos de cada evento de la Shell.
+    """
+
+    def __init__(self, observers: List[ShellObserver] = None):
+        self.observers = observers or []
+
+    def add_observer(self, observer: ShellObserver):
+        self.observers.append(observer)
+
+    def on_session_start(self, shell_name: str):
+        for o in self.observers:
+            o.on_session_start(shell_name)
+
+    def on_session_end(self, shell_name: str, error: Exception = None):
+        for o in self.observers:
+            o.on_session_end(shell_name, error)
+
+    def on_context_change(self, key: str, value: Any):
+        for o in self.observers:
+            o.on_context_change(key, value)
+
+    def on_command_start(self, executable: str, final_args: List[str]):
+        for o in self.observers:
+            o.on_command_start(executable, final_args)
+
+    def on_command_result(self, result: CommandResult):
+        for o in self.observers:
+            o.on_command_result(result)
+
+    def on_error(self, message: str, error: Exception = None):
+        for o in self.observers:
+            o.on_error(message, error)

cc_shellback_kit/capsule/SilentObserver.py

@@ -0,0 +1,7 @@
+from ..core import ShellObserver
+
+
+class SilentObserver(ShellObserver):
+    """No hace nada. Ideal para scripts de producción donde no quieres ruido."""
+
+    pass

cc_shellback_kit/capsule/__init__.py

@@ -0,0 +1,16 @@
+from .Bash import Bash
+from .ConsoleLogObserver import ConsoleLogObserver
+from .FileLogObserver import FileLogObserver
+from .MultiObserver import MultiObserver
+from .JSONFileObserver import JSONFileObserver
+from .SilentObserver import SilentObserver
+
+
+__all__ = [
+    "Bash",
+    "ConsoleLogObserver",
+    "FileLogObserver",
+    "JSONFileObserver",
+    "MultiObserver",
+    "SilentObserver",
+]

cc_shellback_kit/core/ArgumentBuilder.py

@@ -0,0 +1,30 @@
+from typing import Any, List
+
+class ArgumentBuilder:
+    """Garantiza la consistencia de los argumentos para el Sistema Operativo."""
+
+    def __init__(self, style: str = "unix"):
+        self._args: List[str] = []
+        self.style = style
+
+    def add_arg(self, value: Any) -> "ArgumentBuilder":
+        """Aplana listas/tuplas y convierte todo a string, ignorando vacíos."""
+        if isinstance(value, (list, tuple)):
+            for item in value:
+                self.add_arg(item)
+        elif value is not None:
+            val_str = str(value).strip()
+            if val_str:
+                self._args.append(val_str)
+        return self
+
+    def add_flag(self, name: str, value: Any = None) -> "ArgumentBuilder":
+        prefix = "--" if self.style == "unix" else "/"
+        clean_name = name.strip().replace(" ", "_")
+        self.add_arg(f"{prefix}{clean_name}")
+        if value is not None:
+            self.add_arg(value)
+        return self
+
+    def build(self) -> List[str]:
+        return self._args

cc_shellback_kit/core/Command.py

@@ -0,0 +1,22 @@
+from .ArgumentBuilder import ArgumentBuilder
+
+class Command:
+    """Representa un comando ejecutable con sus argumentos."""
+
+    def __init__(self, executable: str):
+        self.executable = executable
+        self.builder = ArgumentBuilder()
+
+    def add_args(self, *args) -> "Command":
+        """
+        Añade argumentos posicionales. 
+        Soporta elementos sueltos o listas gracias al nuevo builder.
+        """
+        for arg in args:
+            self.builder.add_arg(arg)
+        return self
+
+    @property
+    def args(self) -> list[str]:
+        """Obtiene la lista de argumentos construida y validada."""
+        return self.builder.build()

cc_shellback_kit/core/CommandResult.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+import json
+from typing import Any
+
+
+@dataclass
+class CommandResult:
+    """Encapsulates the output of an executed command."""
+
+    standard_output: str = ""
+    standard_error: str = ""
+    return_code: int = 0
+    execution_time: float = 0.0
+    command_sent: list[str] = field(default_factory=list)
+
+    def is_success(self) -> bool:
+        """Returns True if the command executed successfully."""
+        return self.return_code == 0
+
+    def json(self) -> Any:
+        """Parses the standard output as JSON."""
+        return json.loads(self.standard_output)
+
+    def __or__(self, next_command: Any) -> str:
+        """Enables pipe syntax."""
+        return self.standard_output

cc_shellback_kit/core/SessionContext.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict
+
+
+@dataclass(frozen=True)
+class SessionContext:
+    """Maintains persistent state across Shell executions."""
+
+    cwd: Path = field(default_factory=Path.cwd)
+    env: Dict[str, str] = field(default_factory=dict)
+    encoding: str = "utf-8"

cc_shellback_kit/core/Shell.py

@@ -0,0 +1,174 @@
+from abc import ABC, abstractmethod
+import shutil
+import time
+import subprocess
+from pathlib import Path
+from dataclasses import replace
+from typing import Optional, Dict, Callable
+
+# Importaciones del Core
+from .SessionContext import SessionContext
+from .CommandResult import CommandResult
+from .ShellObserver import ShellObserver
+from .ArgumentBuilder import ArgumentBuilder
+
+
+class CommandNotFoundError(Exception):
+    """Lanzada cuando el binario no existe en el PATH."""
+    pass
+
+
+class Shell(ABC):
+    def __init__(
+        self,
+        context: Optional[SessionContext] = None,
+        observer: Optional[ShellObserver] = None,
+        default_timeout: float = 30.0,
+    ):
+        self.context = context or SessionContext()
+        self.observer = observer or ShellObserver()
+        self.default_timeout = default_timeout
+
+        # Mapa de comandos virtuales (Manejo de Estado)
+        self._virtual_builtins: Dict[str, Callable] = {
+            "cd": self._handle_cd,
+            "export": self._handle_export,
+        }
+
+    @abstractmethod
+    def _format_command(self, executable: str, args: list[str]) -> list[str]:
+        """Cada shell hija decide la sintaxis técnica (Bash, PowerShell, etc)."""
+        pass
+
+    def run(self, command, timeout: Optional[float] = None) -> CommandResult:
+        """Dispatcher principal: decide si el comando es de Estado o de Ejecución."""
+        executable = command.executable
+
+        # 1. ¿Es un comando de Estado (Virtual)?
+        if executable in self._virtual_builtins:
+            return self._virtual_builtins[executable](command)
+
+        # 2. Ejecución externa (De Efecto)
+        return self._run_external(command, timeout)
+
+    def __enter__(self):
+        self.observer.on_session_start(self.__class__.__name__)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.observer.on_session_end(self.__class__.__name__, exc_val)
+
+    # --- Manejadores de Estado (Comandos Virtuales) ---
+
+    def _handle_cd(self, command) -> CommandResult:
+        try:
+            new_path = self._resolve_path(command.args)
+
+            if not new_path.exists() or not new_path.is_dir():
+                return self._notify_error(f"Directorio no encontrado: {new_path}")
+
+            self.context = replace(self.context, cwd=new_path)
+            self.observer.on_context_change("cwd", new_path)
+
+            return CommandResult(standard_output=f"Cambiado a: {new_path}", return_code=0)
+        except Exception as e:
+            return self._notify_error("Error crítico en cd", e)
+
+    def _handle_export(self, command) -> CommandResult:
+        if not command.args:
+            return CommandResult(standard_output=str(self.context.env), return_code=0)
+
+        try:
+            updates = self._parse_env_vars(command.args)
+            new_env = {**self.context.env, **updates}
+
+            for key, value in updates.items():
+                self.observer.on_context_change(f"env.{key}", value)
+
+            self.context = replace(self.context, env=new_env)
+            return CommandResult(
+                standard_output=f"Variables actualizadas: {len(updates)}", 
+                return_code=0
+            )
+        except Exception as e:
+            return self._notify_error("Fallo al exportar variables", e)
+
+    # --- Lógica de Ejecución Externa ---
+
+    def _run_external(self, command, timeout: Optional[float]) -> CommandResult:
+        """Prepara y ejecuta un proceso en el Sistema Operativo."""
+        try:
+            # 1. Preparación y validación del ejecutable
+            full_path = self._validate_executable(command.executable)
+            
+            # 2. HELPER: Garantizamos consistencia de argumentos finales
+            # Usamos el ArgumentBuilder para aplanar cualquier lista residual
+            builder = ArgumentBuilder()
+            builder.add_arg(full_path)
+            builder.add_arg(self._format_command(command.executable, command.args))
+            final_args = builder.build()
+
+            # 3. Notificación previa a la ejecución
+            self.observer.on_command_start(command.executable, final_args)
+
+            start_time = time.perf_counter()
+            
+            process = subprocess.run(
+                final_args,
+                cwd=self.context.cwd,
+                env=self.context.env,
+                capture_output=True,
+                text=True,
+                encoding=self.context.encoding,
+                timeout=timeout or self.default_timeout,
+            )
+
+            result = CommandResult(
+                standard_output=process.stdout,
+                standard_error=process.stderr,
+                return_code=process.returncode,
+                execution_time=time.perf_counter() - start_time,
+                command_sent=final_args,
+            )
+            
+            self.observer.on_command_result(result)
+            return result
+
+        except CommandNotFoundError as e:
+            return self._notify_error(str(e), return_code=127)
+        except subprocess.TimeoutExpired:
+            return self._notify_error(f"Tiempo de espera agotado tras {timeout}s")
+        except Exception as e:
+            # Error no controlado se notifica y se relanza si es necesario
+            self.observer.on_error("Error de ejecución inesperado", e)
+            raise e
+
+    # --- Helpers de Soporte ---
+
+    def _validate_executable(self, executable: str) -> str:
+        """Verifica si el binario existe en el sistema."""
+        full_path = shutil.which(executable)
+        if not full_path:
+            raise CommandNotFoundError(f"Comando no encontrado: {executable}")
+        return full_path
+
+    def _resolve_path(self, args: list[str]) -> Path:
+        path_str = args[0] if args else str(Path.home())
+        target = Path(path_str).expanduser()
+
+        if not target.is_absolute():
+            return (self.context.cwd / target).resolve()
+        return target.resolve()
+    
+    def _parse_env_vars(self, args: list[str]) -> Dict[str, str]:
+        updates = {}
+        for arg in args:
+            if "=" in arg:
+                key, value = arg.split("=", 1)
+                updates[key] = value
+        return updates
+
+    def _notify_error(self, message: str, error: Exception = None, return_code: int = 1) -> CommandResult:
+        """Estandariza la notificación de errores y la respuesta."""
+        self.observer.on_error(message, error)
+        return CommandResult(standard_error=message, return_code=return_code)

cc_shellback_kit/core/ShellObserver.py

@@ -0,0 +1,56 @@
+from abc import ABC
+from typing import Any
+
+from .CommandResult import CommandResult
+
+
+class ShellObserver(ABC):  # Puede heredar de ABC si quieres marcarla como base
+    """
+    Interfaz base para la observación de eventos del ciclo de vida de la Shell.
+
+    Esta clase actúa como una 'caja de herramientas' de hooks. Los métodos
+    tienen una implementación vacía por defecto para permitir que las
+    clases hijas solo sobrescriban los eventos que les interesa capturar.
+    """
+
+    def on_session_start(self, shell_name: str):
+        """
+        Se dispara al entrar en el contexto de la Shell (bloque 'with').
+        Útil para inicializar recursos de logging o telemetría.
+        """
+        pass
+
+    def on_session_end(self, shell_name: str, error: Exception = None):
+        """
+        Se dispara al salir del contexto de la Shell.
+        Permite registrar si la sesión terminó de forma limpia o por una excepción.
+        """
+        pass
+
+    def on_context_change(self, key: str, value: Any):
+        """
+        Se dispara cuando un comando de estado (Virtual Builtin) muta el contexto.
+        Ejemplo: cambios en el CWD (Directorio de trabajo) o variables de entorno.
+        """
+        pass
+
+    def on_command_start(self, executable: str, final_args: list[str]):
+        """
+        Se dispara justo antes de enviar un comando de efecto al sistema operativo.
+        Proporciona los argumentos finales tal cual serán ejecutados por el adaptador.
+        """
+        pass
+
+    def on_command_result(self, result: "CommandResult"):
+        """
+        Se dispara tras recibir la respuesta de un comando de efecto.
+        Permite reaccionar al código de retorno, stdout y stderr.
+        """
+        pass
+
+    def on_error(self, message: str, error: Exception = None):
+        """
+        Se dispara cuando ocurre un error controlado o inesperado dentro del Core.
+        Funciona como un sumidero de errores para evitar que la lógica de negocio se ensucie.
+        """
+        pass

cc_shellback_kit/core/__init__.py

@@ -0,0 +1,16 @@
+from .Shell import Shell, CommandNotFoundError
+from .Command import Command
+from .CommandResult import CommandResult
+from .ArgumentBuilder import ArgumentBuilder
+from .SessionContext import SessionContext
+from .ShellObserver import ShellObserver
+
+__all__ = [
+    "Shell",
+    "Command",
+    "CommandResult",
+    "ArgumentBuilder",
+    "SessionContext",
+    "ShellObserver",
+    "CommandNotFoundError",
+]

cc_shellback_kit-0.3.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: cc.shellback-kit
+Version: 0.3.0
+Summary: Add your description here
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: capsulecore-logger==0.3.0
+Requires-Dist: gitchangelog>=3.0.4
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: pytest-timeout>=2.4.0
+Requires-Dist: ruff>=0.15.6
+
+# CapsuleCore shellback
+
+Shellback is a robust, architecturally-agnostic Python library designed to bridge terminal environments (Bash, CMD, PowerShell) with Python scripts. It provides a clean, decoupled abstraction layer to execute system commands while maintaining persistent session state and cross-platform compatibility.
+
+Built with Hexagonal Architecture (Ports and Adapters) principles, Shellback ensures that your domain logic remains independent of the specific shell or operating system being used.
+
+## Usage
+
+```python
+from cc_shellback_kit.capsule import Bash
+from cc_shellback_kit.core import Command, SessionContext
+from cc_shellback_kit.observers import ConsoleLogObserver
+
+# 1. Configuramos el observador para ver la actividad en consola
+observer = ConsoleLogObserver()
+
+# 2. Iniciamos la Shell usando el manejador de contexto (with)
+with Bash(observer=observer) as shell:
+    
+    # --- EJECUCIÓN DE COMANDOS EXTERNOS ---
+    # Creamos un comando simple: 'ls -la'
+    cmd_list = Command("ls").add_args("-la")
+    result = shell.run(cmd_list)
+    
+    if result.is_success():
+        print(f"Archivos encontrados:\n{result.standard_output}")
+
+    # --- MANEJO DE ESTADO (VIRTUAL BUILT-INS) ---
+    # Cambiamos de directorio (esto afecta al SessionContext, no solo al proceso)
+    shell.run(Command("cd").add_args("/tmp"))
+    
+    # Verificamos el cambio ejecutando un 'pwd'
+    shell.run(Command("pwd"))
+
+    # --- VARIABLES DE ENTORNO ---
+    # Exportamos una variable que persistirá durante este bloque 'with'
+    shell.run(Command("export").add_args("APP_STAGE=development", "DEBUG=true"))
+```
+
+

cc_shellback_kit-0.3.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+cc_shellback_kit/__init__.py,sha256=gWHRTg3cNy5jlFVt0F4uEImAe9VZOF40qNX-b1naK6A,579
+cc_shellback_kit/capsule/Bash.py,sha256=rjYbDyXdv2TtfYf5fEPiNpfxdtKRghVpPm5iqB5Za74,275
+cc_shellback_kit/capsule/ConsoleLogObserver.py,sha256=-FId8dUn5W4orw0MkcY5Gl0tO7ADUrxWXX6PelPpeJA,609
+cc_shellback_kit/capsule/FileLogObserver.py,sha256=Sf5vWb240Bie1lluXWh3XzKvUNAXkAJhWzIbD1n2FMY,2005
+cc_shellback_kit/capsule/JSONFileObserver.py,sha256=nwCpxkQ9bpUzovmR1aqrspfcIfxbQR5FOR_6i0Is3v4,2183
+cc_shellback_kit/capsule/MultiObserver.py,sha256=bjUHF14ZHbLJs2G7U6bB3T8SBk9xo6UdQXkdUs5eI3E,1293
+cc_shellback_kit/capsule/SilentObserver.py,sha256=YOeejIlMP5jpZCeoqTl6IrTKwKdBPZ9hqd8ceMNeXm0,164
+cc_shellback_kit/capsule/__init__.py,sha256=0iGazGbvKDK83yzyG_mJ4u2VP4CkOfA8wizhoRzMtwY,394
+cc_shellback_kit/core/ArgumentBuilder.py,sha256=votIpoIrSKXq4zDUvLs_P46kGROo0iaTdaShtpuK4co,1022
+cc_shellback_kit/core/Command.py,sha256=AF4T6KBqRbkTmaiXBkce_kmDaJYApY9rasSsFsiZpkc,657
+cc_shellback_kit/core/CommandResult.py,sha256=L4Y2vPwnB34-mrn3e_NBBQgaLfw74MKQQe5MKYXDcQM,726
+cc_shellback_kit/core/SessionContext.py,sha256=X4nmlFaWmpjDDmtCQ8VcDSMZjO-F9m9LPQ84anDzXQs,331
+cc_shellback_kit/core/Shell.py,sha256=WSR8nKg6zl_L9OhMFXtGTxkL5RnJCUmvoaVf6ZOjZpk,6508
+cc_shellback_kit/core/ShellObserver.py,sha256=pbLRJIT_skRW1vekKyt-trUp1zr5-U7GH5o8_S3pNaI,2018
+cc_shellback_kit/core/__init__.py,sha256=AsULp7Qv4Q6Gq9aZFoHx77c9j2yka83ard-dCK34hc8,404
+cc_shellback_kit-0.3.0.dist-info/METADATA,sha256=70Hx90o-UsjKcv_1IIS2Wwj83wIeZ31gMM0C6GWwh8Y,1949
+cc_shellback_kit-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cc_shellback_kit-0.3.0.dist-info/top_level.txt,sha256=tPz20IiH1w8K89AFkA7gntYscT9eAVocowIFpuFHCeI,17
+cc_shellback_kit-0.3.0.dist-info/RECORD,,

cc_shellback_kit-0.3.0.dist-info/WHEEL

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

cc_shellback_kit-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cc_shellback_kit