clonebox 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

clonebox/cloner.py

@@ -668,7 +668,7 @@ fi
                 tag = f"mount{idx}"
                 # Use uid=1000,gid=1000 to give ubuntu user access to mounts
                 # mmap allows proper file mapping
-                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
+                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000,users"
                 mount_commands.append(f"  - mkdir -p {guest_path}")
                 mount_commands.append(f"  - chown 1000:1000 {guest_path}")
                 mount_commands.append(
@@ -679,34 +679,30 @@ fi
 
         # User-data
         # Add desktop environment if GUI is enabled
-        base_packages = []
+        runcmd_lines = []
+        base_packages = ["qemu-guest-agent"]
         if config.gui:
-            base_packages.extend([
-                "ubuntu-desktop-minimal",
-                "firefox",
-            ])
+            base_packages.extend(
+                [
+                    "ubuntu-desktop-minimal",
+                    "firefox",
+                ]
+            )
         
         all_packages = base_packages + list(config.packages)
-        packages_yaml = (
-            "\n".join(f"  - {pkg}" for pkg in all_packages) if all_packages else ""
-        )
-        
-        # Build runcmd - services, mounts, snaps, post_commands
-        runcmd_lines = []
-        
-        # Add service enablement
-        for svc in config.services:
-            runcmd_lines.append(f"  - systemctl enable --now {svc} || true")
-        
+        packages_yaml = "\n".join([f"  - {pkg}" for pkg in all_packages])
+
         # Add fstab entries for persistent mounts after reboot
         if fstab_entries:
-            runcmd_lines.append("  - echo '# CloneBox 9p mounts' >> /etc/fstab")
+            runcmd_lines.append("  - grep -q '^# CloneBox 9p mounts' /etc/fstab || echo '# CloneBox 9p mounts' >> /etc/fstab")
             for entry in fstab_entries:
-                runcmd_lines.append(f"  - echo '{entry}' >> /etc/fstab")
+                runcmd_lines.append(f"  - grep -qF \"{entry}\" /etc/fstab || echo '{entry}' >> /etc/fstab")
+            runcmd_lines.append("  - mount -a || true")
         
-        # Add mounts (immediate, before reboot)
-        for cmd in mount_commands:
-            runcmd_lines.append(cmd)
+        # Install APT packages
+        runcmd_lines.append("  - echo 'Installing APT packages...'")
+        for pkg in config.packages:
+            runcmd_lines.append(f"  - apt-get install -y {pkg} || true")
         
         # Install snap packages
         if config.snap_packages:
@@ -740,6 +736,8 @@ fi
             runcmd_lines.append("  - sleep 10 && reboot")
         
         runcmd_yaml = "\n".join(runcmd_lines) if runcmd_lines else ""
+        bootcmd_yaml = "\n".join(mount_commands) if mount_commands else ""
+        bootcmd_block = f"\nbootcmd:\n{bootcmd_yaml}\n" if bootcmd_yaml else ""
 
         # Remove power_state - using shutdown -r instead
         power_state_yaml = ""
@@ -765,6 +763,7 @@ chpasswd:
 # Update package cache and upgrade
 package_update: true
 package_upgrade: false
+{bootcmd_block}
 
 # Install packages (cloud-init waits for completion before runcmd)
 packages:
@@ -811,8 +810,6 @@ final_message: "CloneBox VM is ready after $UPTIME seconds"
         try:
             vm = self.conn.lookupByName(vm_name)
         except libvirt.libvirtError:
-            if ignore_not_found:
-                return False
             log(f"[red]❌ VM '{vm_name}' not found[/]")
             return False
 

clonebox/container.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+
+import json
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from clonebox.models import ContainerConfig
+
+
+class ContainerCloner:
+    def __init__(self, engine: str = "auto"):
+        self.engine = self._resolve_engine(engine)
+
+    def _resolve_engine(self, engine: str) -> str:
+        if engine == "auto":
+            return self.detect_engine()
+        if engine not in {"podman", "docker"}:
+            raise ValueError("engine must be one of: auto, podman, docker")
+        if shutil.which(engine) is None:
+            raise RuntimeError(f"Container engine not found: {engine}")
+        self._run([engine, "--version"], check=True)
+        return engine
+
+    def detect_engine(self) -> str:
+        if shutil.which("podman") is not None:
+            try:
+                self._run(["podman", "--version"], check=True)
+                return "podman"
+            except Exception:
+                pass
+
+        if shutil.which("docker") is not None:
+            try:
+                self._run(["docker", "--version"], check=True)
+                return "docker"
+            except Exception:
+                pass
+
+        raise RuntimeError("No container engine found (podman/docker)")
+
+    def _run(
+        self,
+        cmd: List[str],
+        check: bool = True,
+        capture_output: bool = True,
+        text: bool = True,
+    ) -> subprocess.CompletedProcess:
+        return subprocess.run(cmd, check=check, capture_output=capture_output, text=text)
+
+    def build_dockerfile(self, config: ContainerConfig) -> str:
+        lines: List[str] = [f"FROM {config.image}"]
+
+        if config.packages:
+            pkgs = " ".join(config.packages)
+            lines.append(
+                "RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y "
+                + pkgs
+                + " && rm -rf /var/lib/apt/lists/*"
+            )
+
+        lines.append("WORKDIR /workspace")
+        lines.append('CMD ["bash"]')
+        return "\n".join(lines) + "\n"
+
+    def build_image(self, config: ContainerConfig, tag: Optional[str] = None) -> str:
+        if tag is None:
+            tag = f"{config.name}:latest"
+
+        dockerfile = self.build_dockerfile(config)
+        workspace = Path(config.workspace).resolve()
+
+        with tempfile.NamedTemporaryFile(prefix="clonebox-dockerfile-", delete=False) as f:
+            dockerfile_path = Path(f.name)
+            f.write(dockerfile.encode())
+
+        try:
+            self._run(
+                [
+                    self.engine,
+                    "build",
+                    "-f",
+                    str(dockerfile_path),
+                    "-t",
+                    tag,
+                    str(workspace),
+                ],
+                check=True,
+            )
+        finally:
+            try:
+                dockerfile_path.unlink()
+            except Exception:
+                pass
+
+        return tag
+
+    def up(self, config: ContainerConfig, detach: bool = False, remove: bool = True) -> None:
+        engine = self._resolve_engine(config.engine if config.engine != "auto" else self.engine)
+
+        image = config.image
+        if config.packages:
+            image = self.build_image(config)
+
+        cmd: List[str] = [engine, "run"]
+        cmd.append("-d" if detach else "-it")
+
+        if remove:
+            cmd.append("--rm")
+
+        cmd.extend(["--name", config.name])
+        cmd.extend(["-w", "/workspace"])
+
+        env_file = Path(config.workspace) / ".env"
+        if config.env_from_dotenv and env_file.exists():
+            cmd.extend(["--env-file", str(env_file)])
+
+        for src, dst in config.mounts.items():
+            cmd.extend(["-v", f"{src}:{dst}"])
+
+        for p in config.ports:
+            cmd.extend(["-p", p])
+
+        cmd.append(image)
+
+        if detach:
+            cmd.extend(["sleep", "infinity"])
+        else:
+            cmd.append("bash")
+
+        subprocess.run(cmd, check=True)
+
+    def stop(self, name: str) -> None:
+        subprocess.run([self.engine, "stop", name], check=True)
+
+    def rm(self, name: str, force: bool = False) -> None:
+        cmd = [self.engine, "rm"]
+        if force:
+            cmd.append("-f")
+        cmd.append(name)
+        subprocess.run(cmd, check=True)
+
+    def ps(self, all: bool = False) -> List[Dict[str, Any]]:
+        if self.engine == "podman":
+            cmd = ["podman", "ps", "--format", "json"]
+            if all:
+                cmd.append("-a")
+            result = self._run(cmd, check=True)
+            try:
+                parsed = json.loads(result.stdout or "[]")
+            except json.JSONDecodeError:
+                return []
+
+            items: List[Dict[str, Any]] = []
+            for c in parsed:
+                name = ""
+                names = c.get("Names")
+                if isinstance(names, list) and names:
+                    name = str(names[0])
+                elif isinstance(names, str):
+                    name = names
+
+                items.append(
+                    {
+                        "name": name,
+                        "image": c.get("Image") or c.get("ImageName") or "",
+                        "status": c.get("State") or c.get("Status") or "",
+                        "ports": c.get("Ports") or [],
+                    }
+                )
+            return items
+
+        cmd = ["docker", "ps", "--format", "{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"]
+        if all:
+            cmd.insert(2, "-a")
+
+        result = self._run(cmd, check=True)
+        items: List[Dict[str, Any]] = []
+        for line in (result.stdout or "").splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("\t")
+            name = parts[0] if len(parts) > 0 else ""
+            image = parts[1] if len(parts) > 1 else ""
+            status = parts[2] if len(parts) > 2 else ""
+            ports = parts[3] if len(parts) > 3 else ""
+            items.append({"name": name, "image": image, "status": status, "ports": ports})
+        return items

clonebox/models.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Pydantic models for CloneBox configuration validation.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+from uuid import uuid4
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+
+class VMSettings(BaseModel):
+    """VM-specific settings."""
+
+    name: str = Field(default="clonebox-vm", description="VM name")
+    ram_mb: int = Field(default=4096, ge=512, le=131072, description="RAM in MB")
+    vcpus: int = Field(default=4, ge=1, le=128, description="Number of vCPUs")
+    disk_size_gb: int = Field(default=10, ge=1, le=2048, description="Disk size in GB")
+    gui: bool = Field(default=True, description="Enable SPICE graphics")
+    base_image: Optional[str] = Field(default=None, description="Path to base qcow2 image")
+    network_mode: str = Field(default="auto", description="Network mode: auto|default|user")
+    username: str = Field(default="ubuntu", description="VM default username")
+    password: str = Field(default="ubuntu", description="VM default password")
+
+    @field_validator("name")
+    @classmethod
+    def name_must_be_valid(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("VM name cannot be empty")
+        if len(v) > 64:
+            raise ValueError("VM name must be <= 64 characters")
+        return v.strip()
+
+    @field_validator("network_mode")
+    @classmethod
+    def network_mode_must_be_valid(cls, v: str) -> str:
+        valid_modes = {"auto", "default", "user"}
+        if v not in valid_modes:
+            raise ValueError(f"network_mode must be one of: {valid_modes}")
+        return v
+
+
+class CloneBoxConfig(BaseModel):
+    """Complete CloneBox configuration with validation."""
+
+    version: str = Field(default="1", description="Config version")
+    generated: Optional[str] = Field(default=None, description="Generation timestamp")
+    vm: VMSettings = Field(default_factory=VMSettings, description="VM settings")
+    paths: Dict[str, str] = Field(default_factory=dict, description="Host:Guest path mappings")
+    app_data_paths: Dict[str, str] = Field(
+        default_factory=dict, description="Application data paths"
+    )
+    packages: List[str] = Field(default_factory=list, description="APT packages to install")
+    snap_packages: List[str] = Field(default_factory=list, description="Snap packages to install")
+    services: List[str] = Field(default_factory=list, description="Services to enable")
+    post_commands: List[str] = Field(default_factory=list, description="Post-setup commands")
+    detected: Optional[Dict[str, Any]] = Field(
+        default=None, description="Auto-detected system info"
+    )
+
+    @field_validator("paths", "app_data_paths")
+    @classmethod
+    def paths_must_be_absolute(cls, v: Dict[str, str]) -> Dict[str, str]:
+        for host_path, guest_path in v.items():
+            if not host_path.startswith("/"):
+                raise ValueError(f"Host path must be absolute: {host_path}")
+            if not guest_path.startswith("/"):
+                raise ValueError(f"Guest path must be absolute: {guest_path}")
+        return v
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_nested_vm(cls, data: Any) -> Any:
+        """Handle both dict and nested vm structures."""
+        if isinstance(data, dict):
+            if "vm" in data and isinstance(data["vm"], dict):
+                return data
+            vm_fields = {"name", "ram_mb", "vcpus", "disk_size_gb", "gui", "base_image", 
+                        "network_mode", "username", "password"}
+            vm_data = {k: v for k, v in data.items() if k in vm_fields}
+            if vm_data:
+                data = {k: v for k, v in data.items() if k not in vm_fields}
+                data["vm"] = vm_data
+        return data
+
+    def save(self, path: Path) -> None:
+        """Save configuration to YAML file."""
+        import yaml
+
+        config_dict = self.model_dump(exclude_none=True)
+        path.write_text(yaml.dump(config_dict, default_flow_style=False, sort_keys=False))
+
+    @classmethod
+    def load(cls, path: Path) -> "CloneBoxConfig":
+        """Load configuration from YAML file."""
+        import yaml
+
+        if path.is_dir():
+            path = path / ".clonebox.yaml"
+        if not path.exists():
+            raise FileNotFoundError(f"Config file not found: {path}")
+        data = yaml.safe_load(path.read_text())
+        return cls.model_validate(data)
+
+    def to_vm_config(self) -> "VMConfigDataclass":
+        """Convert to legacy VMConfig dataclass for compatibility."""
+        from clonebox.cloner import VMConfig as VMConfigDataclass
+
+        return VMConfigDataclass(
+            name=self.vm.name,
+            ram_mb=self.vm.ram_mb,
+            vcpus=self.vm.vcpus,
+            disk_size_gb=self.vm.disk_size_gb,
+            gui=self.vm.gui,
+            base_image=self.vm.base_image,
+            paths=self.paths,
+            packages=self.packages,
+            snap_packages=self.snap_packages,
+            services=self.services,
+            post_commands=self.post_commands,
+            network_mode=self.vm.network_mode,
+            username=self.vm.username,
+            password=self.vm.password,
+        )
+
+
+class ContainerConfig(BaseModel):
+    name: str = Field(default_factory=lambda: f"clonebox-{uuid4().hex[:8]}")
+    engine: Literal["auto", "podman", "docker"] = "auto"
+    image: str = "ubuntu:22.04"
+    workspace: Path = Path(".")
+    extra_mounts: Dict[str, str] = Field(default_factory=dict)
+    env_from_dotenv: bool = True
+    packages: List[str] = Field(default_factory=list)
+    ports: List[str] = Field(default_factory=list)
+
+    @field_validator("name")
+    @classmethod
+    def name_must_be_valid(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Container name cannot be empty")
+        if len(v) > 64:
+            raise ValueError("Container name must be <= 64 characters")
+        return v.strip()
+
+    @field_validator("extra_mounts")
+    @classmethod
+    def extra_mounts_must_be_absolute(cls, v: Dict[str, str]) -> Dict[str, str]:
+        for host_path, container_path in v.items():
+            if not str(host_path).startswith("/"):
+                raise ValueError(f"Host path must be absolute: {host_path}")
+            if not str(container_path).startswith("/"):
+                raise ValueError(f"Container path must be absolute: {container_path}")
+        return v
+
+    @field_validator("ports")
+    @classmethod
+    def ports_must_be_valid(cls, v: List[str]) -> List[str]:
+        for p in v:
+            if not isinstance(p, str) or not p.strip():
+                raise ValueError("Port mapping cannot be empty")
+            if ":" in p:
+                host, container = p.split(":", 1)
+                if not host.isdigit() or not container.isdigit():
+                    raise ValueError(f"Invalid port mapping: {p}")
+            else:
+                if not p.isdigit():
+                    raise ValueError(f"Invalid port value: {p}")
+        return v
+
+    @property
+    def mounts(self) -> Dict[str, str]:
+        mounts: Dict[str, str] = {
+            str(self.workspace.resolve()): "/workspace",
+        }
+        mounts.update(self.extra_mounts)
+        return mounts
+
+    def to_docker_run_cmd(self) -> List[str]:
+        if self.engine == "auto":
+            raise ValueError("engine must be resolved before generating run command")
+
+        cmd: List[str] = [self.engine, "run", "-it", "--rm", "--name", self.name]
+
+        for src, dst in self.mounts.items():
+            cmd.extend(["-v", f"{src}:{dst}"])
+
+        for p in self.ports:
+            cmd.extend(["-p", p])
+
+        cmd.append(self.image)
+        return cmd
+
+
+# Backwards compatibility alias
+VMConfigModel = CloneBoxConfig

{clonebox-0.1.14.dist-info → clonebox-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.14
+Version: 0.1.16
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -30,14 +30,26 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.0.0; extra == "test"
 Dynamic: license-file
 
 # CloneBox 📦
+
+[![CI](https://github.com/wronai/clonebox/workflows/CI/badge.svg)](https://github.com/wronai/clonebox/actions)
+[![PyPI version](https://badge.fury.io/py/clonebox.svg)](https://pypi.org/project/clonebox/)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
+
 ![img.png](img.png)
 
 ```commandline
@@ -51,7 +63,8 @@ Dynamic: license-file
 ║      Clone your workstation to an isolated VM         ║
 ╚═══════════════════════════════════════════════════════╝
 ```
-**Clone your workstation environment to an isolated VM with selective apps, paths and services.**
+
+> **Clone your workstation environment to an isolated VM in 60 seconds using bind mounts instead of disk cloning.**
 
 CloneBox lets you create isolated virtual machines with only the applications, directories and services you need - using bind mounts instead of full disk cloning. Perfect for development, testing, or creating reproducible environments.
 
@@ -168,6 +181,61 @@ clonebox stop <name>         # Zatrzymaj VM
 clonebox delete <name>       # Usuń VM
 ```
 
+## Development and Testing
+
+### Running Tests
+
+CloneBox has comprehensive test coverage with unit tests and end-to-end tests:
+
+```bash
+# Run unit tests only (fast, no libvirt required)
+make test
+
+# Run fast unit tests (excludes slow tests)
+make test-unit
+
+# Run end-to-end tests (requires libvirt/KVM)
+make test-e2e
+
+# Run all tests including e2e
+make test-all
+
+# Run tests with coverage
+make test-cov
+
+# Run tests with verbose output
+make test-verbose
+```
+
+### Test Categories
+
+Tests are organized with pytest markers:
+
+- **Unit tests**: Fast tests that mock libvirt/system calls (default)
+- **E2E tests**: End-to-end tests requiring actual VM creation (marked with `@pytest.mark.e2e`)
+- **Slow tests**: Tests that take longer to run (marked with `@pytest.mark.slow`)
+
+E2E tests are automatically skipped when:
+- libvirt is not installed
+- `/dev/kvm` is not available
+- Running in CI environment (`CI=true` or `GITHUB_ACTIONS=true`)
+
+### Manual Test Execution
+
+```bash
+# Run only unit tests (exclude e2e)
+pytest tests/ -m "not e2e"
+
+# Run only e2e tests
+pytest tests/e2e/ -m "e2e" -v
+
+# Run specific test file
+pytest tests/test_cloner.py -v
+
+# Run with coverage
+pytest tests/ -m "not e2e" --cov=clonebox --cov-report=html
+```
+
 ## Quick Start
 
 ### Interactive Mode (Recommended)
@@ -258,22 +326,53 @@ ls ~/.mozilla/firefox       # Firefox profile
 ls ~/.config/JetBrains      # PyCharm settings
 ```
 
-### Testing VM Configuration
+### Testing and Validating VM Configuration
 
 ```bash
 # Quick test - basic checks
 clonebox test . --user --quick
 
-# Full test with verbose output
-clonebox test . --user --verbose
-
-# Test output shows:
-# ✅ VM is defined in libvirt
-# ✅ VM is running
-# ✅ VM has network access (IP: 192.168.122.89)
-# ✅ Cloud-init completed
-# ✅ All mount points accessible
-# ✅ Health check triggered
+# Full validation - checks EVERYTHING against YAML config
+clonebox test . --user --validate
+
+# Validation checks:
+# ✅ All mount points (paths + app_data_paths) are mounted and accessible
+# ✅ All APT packages are installed
+# ✅ All snap packages are installed
+# ✅ All services are enabled and running
+# ✅ Reports file counts for each mount
+# ✅ Shows package versions
+# ✅ Comprehensive summary table
+
+# Example output:
+# 💾 Validating Mount Points...
+# ┌─────────────────────────┬─────────┬────────────┬────────┐
+# │ Guest Path              │ Mounted │ Accessible │ Files  │
+# ├─────────────────────────┼─────────┼────────────┼────────┤
+# │ /home/ubuntu/Downloads  │ ✅      │ ✅         │ 199    │
+# │ ~/.config/JetBrains     │ ✅      │ ✅         │ 45     │
+# └─────────────────────────┴─────────┴────────────┴────────┘
+# 12/14 mounts working
+#
+# 📦 Validating APT Packages...
+# ┌─────────────────┬──────────────┬────────────┐
+# │ Package         │ Status       │ Version    │
+# ├─────────────────┼──────────────┼────────────┤
+# │ firefox         │ ✅ Installed │ 122.0+b... │
+# │ docker.io       │ ✅ Installed │ 24.0.7-... │
+# └─────────────────┴──────────────┴────────────┘
+# 8/8 packages installed
+#
+# 📊 Validation Summary
+# ┌────────────────┬────────┬────────┬───────┐
+# │ Category       │ Passed │ Failed │ Total │
+# ├────────────────┼────────┼────────┼───────┤
+# │ Mounts         │ 12     │ 2      │ 14    │
+# │ APT Packages   │ 8      │ 0      │ 8     │
+# │ Snap Packages  │ 2      │ 0      │ 2     │
+# │ Services       │ 5      │ 1      │ 6     │
+# │ TOTAL          │ 27     │ 3      │ 30    │
+# └────────────────┴────────┴────────┴───────┘
 ```
 
 ### VM Health Monitoring and Mount Validation
@@ -601,7 +700,8 @@ clonebox clone . --network auto
 | `clonebox detect --json` | Output as JSON |
 | `clonebox status . --user` | Check VM health, cloud-init, IP, and mount status |
 | `clonebox status . --user --health` | Check VM status and run full health check |
-| `clonebox test . --user` | Test VM configuration and validate all settings |
+| `clonebox test . --user` | Test VM configuration (basic checks) |
+| `clonebox test . --user --validate` | Full validation: mounts, packages, services vs YAML |
 | `clonebox export . --user` | Export VM for migration to another workstation |
 | `clonebox export . --user --include-data` | Export VM with browser profiles and configs |
 | `clonebox import archive.tar.gz --user` | Import VM from export archive |

clonebox-0.1.16.dist-info/RECORD

@@ -0,0 +1,14 @@
+clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=CwJ78Em2bma6jKNjrJYmM7B3rhzNDKDMLQ-3AEx00G4,98101
+clonebox/cloner.py,sha256=bSOOkfqvF1PaUhVke0GaFYz29-eA9CigiAILP-WDhjs,32221
+clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
+clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
+clonebox/models.py,sha256=Uxz9eHov2epJpNYbl0ejaOX91iMSjqdHskGdC8-smVk,7789
+clonebox/validator.py,sha256=8HV3ahfiLkFDOH4UOmZr7-fGfhKep1Jlw1joJeWSaQE,15858
+clonebox-0.1.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.16.dist-info/METADATA,sha256=ZT06tRqwiEyYiqnrkHchd30VZgwWo0Cb6NhRrMu00_g,35220
+clonebox-0.1.16.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.16.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.16.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.16.dist-info/RECORD,,

clonebox-0.1.14.dist-info/RECORD

@@ -1,12 +0,0 @@
-clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=IWTJjC5o3GPDZqQVnWNa8SHq1zKaK-fLGRASTehGe3Y,84733
-clonebox/cloner.py,sha256=fVfphsPbsqW4ASnv4bkrDIL8Ks9aPUvxx-IOO_d2FTw,32102
-clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
-clonebox/validator.py,sha256=8HV3ahfiLkFDOH4UOmZr7-fGfhKep1Jlw1joJeWSaQE,15858
-clonebox-0.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.14.dist-info/METADATA,sha256=RGcUEs9xELSw6zii3s6qGqoYsiaOQNVo-CB5xK9N7Vw,30824
-clonebox-0.1.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.14.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.14.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.14.dist-info/RECORD,,