shipit-cli 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

shipit/runners/wasmer.py

@@ -0,0 +1,470 @@
+import hashlib
+import json
+import os
+import shlex
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, TypedDict, cast
+
+import sh  # type: ignore[import-untyped]
+import yaml
+from rich import box
+from rich.panel import Panel
+from rich.syntax import Syntax
+from tomlkit import array, aot, comment, document, nl, string, table
+
+from shipit.builders.base import BuildBackend
+from shipit.runners.base import Runner
+from shipit.shipit_types import Package, PrepareStep, RunStep, Serve, WorkdirStep
+from shipit.ui import console, write_stderr, write_stdout
+from shipit.version import version as shipit_version
+
+
+class MapperItem(TypedDict, total=False):
+    dependencies: Dict[str, str]
+    scripts: Set[str]
+    env: Dict[str, str]
+    aliases: Dict[str, str]
+    architecture_dependencies: Dict[str, Dict[str, str]]
+
+
+class WasmerRunner:
+    rewrite_binaries: Dict[str, str] = {
+        "python": "python",
+        "python3": "python",
+        "python3.13": "python",
+        "daphne": "python -m daphne",
+        "gunicorn": "python -m gunicorn",
+        "uvicorn": "python -m uvicorn",
+        "hypercorn": "python -m hypercorn",
+        "fastapi": "python -m fastapi",
+        "streamlit": "python -m streamlit",
+        "flask": "python -m flask",
+        "mcp": "python -m mcp",
+    }
+
+    mapper: Dict[str, MapperItem] = {
+        "python": {
+            "dependencies": {
+                "latest": "python/python@=3.13.3",
+                "3.13": "python/python@=3.13.3",
+            },
+            "scripts": {"python"},
+            "aliases": {},
+            "env": {
+                "PYTHONEXECUTABLE": "/bin/python",
+            },
+        },
+        "pandoc": {
+            "dependencies": {
+                "latest": "wasmer/pandoc@=0.0.1",
+                "3.5": "wasmer/pandoc@=0.0.1",
+            },
+            "scripts": {"pandoc"},
+        },
+        "ffmpeg": {
+            "dependencies": {
+                "latest": "wasmer/ffmpeg@=1.0.5",
+                "N-111519": "wasmer/ffmpeg@=1.0.5",
+            },
+            "scripts": {"ffmpeg"},
+        },
+        "php": {
+            "dependencies": {
+                "latest": "php/php-32@=8.3.2102",
+                "8.3": "php/php-32@=8.3.2102",
+                "8.2": "php/php-32@=8.2.2801",
+                "8.1": "php/php-32@=8.1.3201",
+                "7.4": "php/php-32@=7.4.3301",
+            },
+            "architecture_dependencies": {
+                "64-bit": {
+                    "latest": "php/php-64@=8.3.2102",
+                    "8.3": "php/php-64@=8.3.2102",
+                    "8.2": "php/php-64@=8.2.2801",
+                    "8.1": "php/php-64@=8.1.3201",
+                    "7.4": "php/php-64@=7.4.3301",
+                },
+                "32-bit": {
+                    "latest": "php/php-32@=8.3.2102",
+                    "8.3": "php/php-32@=8.3.2102",
+                    "8.2": "php/php-32@=8.2.2801",
+                    "8.1": "php/php-32@=8.1.3201",
+                    "7.4": "php/php-32@=7.4.3301",
+                },
+            },
+            "scripts": {"php"},
+            "aliases": {},
+            "env": {},
+        },
+        "bash": {
+            "dependencies": {
+                "latest": "wasmer/bash@=1.0.24",
+                "8.3": "wasmer/bash@=1.0.24",
+            },
+            "scripts": {"bash", "sh"},
+            "aliases": {},
+            "env": {},
+        },
+        "static-web-server": {
+            "dependencies": {
+                "latest": "wasmer/static-web-server@=1.1.0",
+                "2.38.0": "wasmer/static-web-server@=1.1.0",
+                "0.1": "wasmer/static-web-server@=1.1.0",
+            },
+            "scripts": {"webserver"},
+            "aliases": {"static-web-server": "webserver"},
+            "env": {},
+        },
+    }
+
+    def __init__(
+        self,
+        build_backend: BuildBackend,
+        src_dir: Path,
+        registry: Optional[str] = None,
+        token: Optional[str] = None,
+        bin: Optional[str] = None,
+    ) -> None:
+        self.build_backend = build_backend
+        self.src_dir = src_dir
+        self.wasmer_dir_path = self.src_dir / ".shipit" / "wasmer"
+        self.wasmer_registry = registry
+        self.wasmer_token = token
+        self.bin = bin or "wasmer"
+
+    def get_serve_mount_path(self, name: str) -> Path:
+        if name == "app":
+            return Path("/app")
+        else:
+            return Path("/opt") / name
+
+    def prepare_config(self, provider_config: Any) -> Any:
+        from shipit.providers.python import PythonConfig
+
+        if isinstance(provider_config, PythonConfig):
+            provider_config.python_extra_index_url = (
+                "https://pythonindex.wasix.org/simple"
+            )
+            provider_config.cross_platform = "wasix_wasm32"
+            provider_config.precompile_python = True
+        return provider_config
+
+    def build(self, serve: Serve) -> None:
+        self.build_prepare(serve)
+        self.build_serve(serve)
+
+    def build_prepare(self, serve: Serve) -> None:
+        if not serve.prepare:
+            return
+        prepare_dir = self.wasmer_dir_path / "prepare"
+        prepare_dir.mkdir(parents=True, exist_ok=True)
+        env = serve.env or {}
+        for dep in serve.deps:
+            if dep.name in self.mapper:
+                dep_env = self.mapper[dep.name].get("env")
+                if dep_env is not None:
+                    env.update(dep_env)
+        if env:
+            env_lines = [f"export {k}={v}" for k, v in env.items()]
+            env_lines = "\n".join(env_lines)
+        else:
+            env_lines = ""
+
+        commands: List[str] = []
+        if serve.cwd:
+            commands.append(f"cd {serve.cwd}")
+
+        if serve.prepare:
+            for step in serve.prepare:
+                commands.append(step.command)
+
+        body = "\n".join(filter(None, [env_lines, *commands]))
+        content = f"#!/bin/bash\n\n{body}"
+        console.print(
+            f"\n[bold]Created prepare.sh script to run before packaging ✅[/bold]"
+        )
+        manifest_panel = Panel(
+            Syntax(
+                content,
+                "bash",
+                theme="monokai",
+                background_color="default",
+                line_numbers=True,
+            ),
+            box=box.SQUARE,
+            border_style="bright_black",
+            expand=False,
+        )
+        console.print(manifest_panel, markup=False, highlight=True)
+
+        (prepare_dir / "prepare.sh").write_text(content)
+        (prepare_dir / "prepare.sh").chmod(0o755)
+
+    def prepare(self, env: Dict[str, str], prepare: List[PrepareStep]) -> None:
+        prepare_dir = self.wasmer_dir_path / "prepare"
+        self.run_serve_command(
+            "bash",
+            extra_args=[
+                f"--mapdir=/prepare:{prepare_dir}",
+                "--",
+                "/prepare/prepare.sh",
+            ],
+        )
+
+    def build_serve(self, serve: Serve) -> None:
+        doc = document()
+        doc.add(comment(f"Wasmer manifest generated with Shipit v{shipit_version}"))
+        package = table()
+        doc.add("package", package)
+        package.add("entrypoint", "start")
+        dependencies = table()
+        doc.add("dependencies", dependencies)
+
+        binaries: Dict[str, Dict[str, Optional[Dict[str, str]]]] = {}
+
+        deps = serve.deps or []
+        if serve.prepare and not any(dep.name == "bash" for dep in deps):
+            deps.append(Package("bash"))
+
+        if deps:
+            console.print(f"[bold]Mapping dependencies to Wasmer packages:[/bold]")
+        for dep in deps:
+            if dep.name in self.mapper:
+                version = dep.version or "latest"
+                mapped_dependencies = self.mapper[dep.name]["dependencies"]
+                if dep.architecture:
+                    architecture_dependencies = (
+                        self.mapper[dep.name]
+                        .get("architecture_dependencies", {})
+                        .get(dep.architecture, {})
+                    )
+                    if architecture_dependencies:
+                        mapped_dependencies = architecture_dependencies
+                if version in mapped_dependencies:
+                    console.print(
+                        f"* {dep.name}@{version} mapped to {self.mapper[dep.name]['dependencies'][version]}"
+                    )
+                    package_name, version = mapped_dependencies[version].split("@")
+                    dependencies.add(package_name, version)
+                    scripts = self.mapper[dep.name].get("scripts") or []
+                    for script in scripts:
+                        binaries[script] = {
+                            "script": f"{package_name}:{script}",
+                            "env": self.mapper[dep.name].get("env"),
+                        }
+                    aliases = self.mapper[dep.name].get("aliases") or {}
+                    for alias, script in aliases.items():
+                        binaries[alias] = {
+                            "script": f"{package_name}:{script}",
+                            "env": self.mapper[dep.name].get("env"),
+                        }
+                else:
+                    raise Exception(
+                        f"Dependency {dep.name}@{version} not found in Wasmer"
+                    )
+            else:
+                raise Exception(f"Dependency {dep.name} not found in Wasmer")
+
+        fs = table()
+        doc.add("fs", fs)
+        if serve.mounts:
+            for mount in serve.mounts:
+                fs.add(
+                    str(mount.serve_path.absolute()),
+                    str(
+                        self.build_backend.get_artifact_mount_path(
+                            mount.name
+                        ).absolute()
+                    ),
+                )
+
+        doc.add(nl())
+        if serve.commands:
+            commands = aot()
+            doc.add("command", commands)
+            for command_name, command_line in serve.commands.items():
+                command = table()
+                commands.append(command)
+                parts = shlex.split(command_line)
+                program = parts[0]
+                if program in self.rewrite_binaries:
+                    rewritten_program = shlex.split(self.rewrite_binaries[program])
+                    program = rewritten_program[0]
+                    parts[:1] = rewritten_program
+                elif program not in binaries:
+                    raise Exception(f"Binary {program} not runable in Wasmer yet")
+                command.add("name", command_name)
+                program_binary = binaries.get(program)
+                if not program_binary:
+                    raise Exception(f"Command {command_name} is trying to run {program} but it is not available (dependencies: {', '.join(dependencies.keys())}, programs: {', '.join(binaries.keys())})")
+                command.add("module", program_binary["script"])
+                command.add("runner", "wasi")
+                wasi_args = table()
+                if serve.cwd:
+                    wasi_args.add("cwd", serve.cwd)
+                wasi_args.add("main-args", array(parts[1:]).multiline(True))
+                env = program_binary.get("env") or {}
+                if serve.env:
+                    env.update(serve.env)
+                if env:
+                    arr = array([f"{k}={v}" for k, v in env.items()]).multiline(True)
+                    wasi_args.add("env", arr)
+                title = string("annotations.wasi", literal=False)
+                command.add(title, wasi_args)
+
+        self.wasmer_dir_path.mkdir(parents=True, exist_ok=True)
+
+        manifest = doc.as_string().replace(
+            '[command."annotations.wasi"]', "[command.annotations.wasi]"
+        )
+        console.print(f"\n[bold]Created wasmer.toml manifest ✅[/bold]")
+        manifest_panel = Panel(
+            Syntax(
+                manifest.strip(),
+                "toml",
+                theme="monokai",
+                background_color="default",
+                line_numbers=True,
+            ),
+            box=box.SQUARE,
+            border_style="bright_black",
+            expand=False,
+        )
+        console.print(manifest_panel, markup=False, highlight=True)
+        (self.wasmer_dir_path / "wasmer.toml").write_text(manifest)
+
+        original_app_yaml_path = self.src_dir / "app.yaml"
+        if original_app_yaml_path.exists():
+            console.print(
+                f"[bold]Using original app.yaml found in source directory[/bold]"
+            )
+            yaml_config = yaml.safe_load(original_app_yaml_path.read_text())
+        else:
+            yaml_config = {
+                "kind": "wasmer.io/App.v0",
+            }
+        yaml_config["package"] = "."
+        if serve.services:
+            capabilities = yaml_config.get("capabilities", {})
+            has_mysql = any(service.provider == "mysql" for service in serve.services)
+            if has_mysql:
+                capabilities["database"] = {"engine": "mysql"}
+            yaml_config["capabilities"] = capabilities
+
+        if serve.volumes:
+            volumes_yaml = yaml_config.get("volumes", [])
+            for vol in serve.volumes:
+                volumes_yaml.append(
+                    {
+                        "name": vol.name,
+                        "mount": str(vol.serve_path),
+                    }
+                )
+            yaml_config["volumes"] = volumes_yaml
+
+        has_php = any(dep.name == "php" for dep in serve.deps)
+        if has_php:
+            scaling = yaml_config.get("scaling", {})
+            scaling["mode"] = "single_concurrency"
+            yaml_config["scaling"] = scaling
+
+        if "after_deploy" in serve.commands:
+            jobs = yaml_config.get("jobs", [])
+            jobs.append(
+                {
+                    "name": "after_deploy",
+                    "trigger": "post-deployment",
+                    "action": {"execute": {"command": "after_deploy"}},
+                }
+            )
+            yaml_config["jobs"] = jobs
+
+        app_yaml = yaml.dump(yaml_config)
+
+        console.print(f"\n[bold]Created app.yaml manifest ✅[/bold]")
+        app_yaml_panel = Panel(
+            Syntax(
+                app_yaml.strip(),
+                "yaml",
+                theme="monokai",
+                background_color="default",
+                line_numbers=True,
+            ),
+            box=box.SQUARE,
+            border_style="bright_black",
+            expand=False,
+        )
+        console.print(app_yaml_panel, markup=False, highlight=True)
+        (self.wasmer_dir_path / "app.yaml").write_text(app_yaml)
+
+    def run_serve_command(
+        self, command: str, extra_args: Optional[List[str]] = None
+    ) -> None:
+        console.print(f"\n[bold]Serving site[/bold]: running {command} command")
+        extra_args = extra_args or []
+
+        if self.wasmer_registry:
+            extra_args = [f"--registry={self.wasmer_registry}"] + extra_args
+        self.run_command(
+            self.bin,
+            [
+                "run",
+                str(self.wasmer_dir_path.absolute()),
+                "--net",
+                f"--command={command}",
+                *extra_args,
+            ],
+        )
+
+    def run_command(
+        self, command: str, extra_args: Optional[List[str]] | None = None
+    ) -> Any:
+        sh.Command(command)(
+            *(extra_args or []), _out=write_stdout, _err=write_stderr, _env=os.environ
+        )
+
+    def deploy_config(self, config_path: Path) -> None:
+        package_webc_path = self.wasmer_dir_path / "package.webc"
+        app_yaml_path = self.wasmer_dir_path / "app.yaml"
+        package_webc_path.parent.mkdir(parents=True, exist_ok=True)
+        self.run_command(
+            self.bin,
+            ["package", "build", self.wasmer_dir_path, "--out", package_webc_path],
+        )
+        config_path.write_text(
+            json.dumps(
+                {
+                    "app_yaml_path": str(app_yaml_path.absolute()),
+                    "package_webc_path": str(package_webc_path.absolute()),
+                    "package_webc_size": package_webc_path.stat().st_size,
+                    "package_webc_sha256": hashlib.sha256(
+                        package_webc_path.read_bytes()
+                    ).hexdigest(),
+                }
+            )
+        )
+        console.print(f"\n[bold]Saved deploy config to {config_path}[/bold]")
+
+    def deploy(
+        self, app_owner: Optional[str] = None, app_name: Optional[str] = None
+    ) -> None:
+        extra_args: List[str] = []
+        if self.wasmer_registry:
+            extra_args += ["--registry", self.wasmer_registry]
+        if self.wasmer_token:
+            extra_args += ["--token", self.wasmer_token]
+        if app_owner:
+            extra_args += ["--owner", app_owner]
+        if app_name:
+            extra_args += ["--app-name", app_name]
+        self.run_command(
+            self.bin,
+            [
+                "deploy",
+                "--publish-package",
+                "--dir",
+                self.wasmer_dir_path,
+                "--non-interactive",
+                *extra_args,
+            ],
+        )

shipit/shipit_types.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Union
+
+
+@dataclass
+class Mount:
+    name: str
+    build_path: Path
+    serve_path: Path
+
+
+@dataclass
+class Volume:
+    name: str
+    serve_path: Path
+
+
+@dataclass
+class Service:
+    name: str
+    provider: Literal["postgres", "mysql", "redis"]
+
+
+@dataclass
+class Serve:
+    name: str
+    provider: str
+    build: List["Step"]
+    deps: List["Package"]
+    commands: Dict[str, str]
+    cwd: Optional[str] = None
+    prepare: Optional[List["PrepareStep"]] = None
+    workers: Optional[List[str]] = None
+    mounts: Optional[List[Mount]] = None
+    volumes: Optional[List[Volume]] = None
+    env: Optional[Dict[str, str]] = None
+    services: Optional[List[Service]] = None
+
+
+@dataclass
+class Package:
+    name: str
+    version: Optional[str] = None
+    architecture: Optional[Literal["64-bit", "32-bit"]] = None
+
+    def __str__(self) -> str:
+        name = f"{self.name}({self.architecture})" if self.architecture else self.name
+        if self.version is None:
+            return name
+        return f"{name}@{self.version}"
+
+
+@dataclass
+class RunStep:
+    command: str
+    inputs: Optional[List[str]] = None
+    outputs: Optional[List[str]] = None
+    group: Optional[str] = None
+
+
+@dataclass
+class WorkdirStep:
+    path: Path
+
+
+@dataclass
+class CopyStep:
+    source: str
+    target: str
+    ignore: Optional[List[str]] = None
+    base: Literal["source", "assets"] = "source"
+
+    def is_download(self) -> bool:
+        return self.source.startswith("http://") or self.source.startswith("https://")
+
+
+@dataclass
+class EnvStep:
+    variables: Dict[str, str]
+
+    def __str__(self) -> str:
+        return " ".join([f"{key}={value}" for key, value in self.variables.items()])
+
+
+@dataclass
+class UseStep:
+    dependencies: List[Package]
+
+
+@dataclass
+class PathStep:
+    path: str
+
+
+Step = Union[RunStep, CopyStep, EnvStep, PathStep, UseStep, WorkdirStep]
+PrepareStep = Union[RunStep]
+
+
+@dataclass
+class Build:
+    deps: List[Package]
+    steps: List[Step]

shipit/ui.py

@@ -0,0 +1,14 @@
+import sys
+from rich.console import Console
+
+console = Console()
+
+
+def write_stdout(line: str) -> None:
+    sys.stdout.write(line)
+    sys.stdout.flush()
+
+
+def write_stderr(line: str) -> None:
+    sys.stderr.write(line)
+    sys.stderr.flush()

shipit/utils.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+import requests
+
+
+def download_file(url: str, path: Path) -> None:
+    response = requests.get(url)
+    response.raise_for_status()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(response.content)

shipit/version.py

@@ -1,5 +1,5 @@
 __all__ = ["version", "version_info"]
 
 
-version = "0.14.0"
-version_info = (0, 14, 0, "final", 0)
+version = "0.15.0"
+version_info = (0, 15, 0, "final", 0)

{shipit_cli-0.14.0.dist-info → shipit_cli-0.15.0.dist-info}/METADATA

@@ -1,20 +1,23 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.14.0
+Version: 0.15.0
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit
 Project-URL: Changelog, https://github.com/wasmerio/shipit/changelog
 Requires-Python: >=3.10
 Requires-Dist: dotenv>=0.9.9
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=14.1.0
 Requires-Dist: semantic-version>=2.10.0
 Requires-Dist: sh>=2.2.2
-Requires-Dist: starlark-pyo3>=2025.1
+Requires-Dist: toml>=0.10.2
 Requires-Dist: tomlkit>=0.13.3
 Requires-Dist: typer>=0.16.1
+Requires-Dist: xingque>=0.2.1
 Description-Content-Type: text/markdown
 
 # Shipit
@@ -71,7 +74,7 @@ with `--use-provider`.
 uvx shipit-cli plan --out plan.json
 ```
 
-Evaluate the project and emit metadata, derived commands, and required
+ Evaluate the project and emit config, derived commands, and required
 services without building. Helpful for CI checks or debugging configuration.
 
 ### `build`

shipit_cli-0.15.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+shipit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shipit/cli.py,sha256=YPEyl6yjk2CH2YnjB1wmF3m_ZbJ0_Ktr2mmpFFLrsS4,33825
+shipit/generator.py,sha256=CyAwWmwcd0JrRSlcux9X1ZWuAnzJK3QBjN5yKgmKVqQ,7526
+shipit/procfile.py,sha256=bjsdG8aSbRhKvrN96OiSOh0xjJHnlZg42eadtlsLc0M,1129
+shipit/shipit_types.py,sha256=wQzuYOIJMlovOq56ropf2T3j_Ye6Y8BYYdAuXfEGHbM,2062
+shipit/ui.py,sha256=vqtuAYXwB_PqlcOchrPFTQ3yoCXRBqV_GnB5R2u-1-k,243
+shipit/utils.py,sha256=XaiuaT_5mnzlXD9i1PAkaVc162y5Y_wj_oo1z2gUQBI,248
+shipit/version.py,sha256=QJqEGC_YsFig0b6PsnwwJQh_zE-YL49JPlItpKrgL-U,97
+shipit/assets/php/php.ini,sha256=SaR3wvssSROtxTY_CQ5-BspM_47_I971V5X2dsqe8sU,2579
+shipit/assets/wordpress/install.sh,sha256=8sNe4w9F9y97JR-w5Q0ZHVgZvNm_vnd1CacY5fQjewI,3087
+shipit/assets/wordpress/wp-config.php,sha256=q7KHB_TyLrodXzbg8EEPm42XWDIevtwL6wk3L0kbVrs,4809
+shipit/builders/__init__.py,sha256=n1g3bZ_VaXVQIhwTlJnRWzDMCymVUjolykopnypyyyE,193
+shipit/builders/base.py,sha256=mP8WdPs53oLiTQkYT1r7xpyNW5D_2gcTUFwOPkpPsHc,477
+shipit/builders/docker.py,sha256=wnCJdOK-PR7TV3QpHTapDkOYx3G4P47YJeLihgifJ88,9613
+shipit/builders/local.py,sha256=xWN-YevtXp63igycJU-lnIkZQHhhrX176RX6kFNfxKE,6014
+shipit/providers/base.py,sha256=qKEarV37t7Zi2T8Mg0utjvVJN4gkiRCkOPG4w4NqFo4,4163
+shipit/providers/hugo.py,sha256=OIjfRMY6BbEM5uhtVlHlMDZH0uxbrtEEIoMMqDZlX5U,3515
+shipit/providers/jekyll.py,sha256=6XjTIklYfK_iez90j7YL1UDCreReGAaT3zH8fSYMguI,3968
+shipit/providers/laravel.py,sha256=UjfG-CDLihxuWkvZ6Q8KfXOi1Fx71Vcy1NfdjW1Nwgo,3412
+shipit/providers/mkdocs.py,sha256=PDg8gV8OVmlU89B8Fa2AfEgdC9c0x3JkpMUPFaBd0Ts,2662
+shipit/providers/node_static.py,sha256=XCmWIV7OtKE0vg4lIba0Y3IvHuNMaFmJ4OCj3fev5kY,15463
+shipit/providers/php.py,sha256=YL9bFVlTkQ3HgSQ7Vi9YJlkEWXl1M4dbeBMXP2G-EHc,4483
+shipit/providers/python.py,sha256=gj4tfL4ewAU4mhzOrpcdVYx19JNFNBx3pRYE0IixTPM,22754
+shipit/providers/registry.py,sha256=MSaKc3Eqs1vM04njGUyTtOeL8ffmmWyB3kSpvirqHfg,693
+shipit/providers/staticfile.py,sha256=hpZVFBATiIUOD0miSE1aHtJurqCaPusRuj5MdJV2JU8,3447
+shipit/providers/wordpress.py,sha256=e4GmelnW04F2_tChATnophAnQbchNOCKw0xaCm3bF30,3235
+shipit/runners/__init__.py,sha256=s1kICs9W8Z5buF0dalgNNx2AzGAsiTw8OzCIgYiN_ps,157
+shipit/runners/base.py,sha256=edXGW_4lngQS_Q110yy_6UnyOSKLbxxJm5vDIu8ge7Y,582
+shipit/runners/local.py,sha256=OFWyI_IO_7q_QZrbEnXFRUVbNCwNYuxZTdA1PI2Icp4,4138
+shipit/runners/wasmer.py,sha256=d2oL7x74yU6_q1cMYuu3M19XyGzDKnJZHirf1SBuF_k,17202
+shipit_cli-0.15.0.dist-info/METADATA,sha256=RJ0Om2Z_PBlwYa7O6jG4F2aIFaEQK2xXPAs6NQ9hPkk,3773
+shipit_cli-0.15.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+shipit_cli-0.15.0.dist-info/entry_points.txt,sha256=7AE1NjSrHaSDfbfsRRO50KKnHFTbB0Imsccd1WynzAQ,72
+shipit_cli-0.15.0.dist-info/RECORD,,

{shipit_cli-0.14.0.dist-info → shipit_cli-0.15.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any