shipit-cli 0.3.3__tar.gz → 0.4.0__tar.gz

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.3.3
+Version: 0.4.0
 Summary: Add your description here
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.3.3"
+version = "0.4.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/cli.py

@@ -55,6 +55,7 @@ class Serve:
     build: List["Step"]
     deps: List["Package"]
     commands: Dict[str, str]
+    cwd: Optional[str] = None
     assets: Optional[Dict[str, str]] = None
     prepare: Optional[List["PrepareStep"]] = None
     workers: Optional[List[str]] = None
@@ -577,18 +578,33 @@ class LocalBuilder:
             self.create_file(asset_path, assets[asset])
 
     def build_prepare(self, serve: Serve) -> None:
-        app_dir = self.get_build_path()
         self.prepare_bash_script.parent.mkdir(parents=True, exist_ok=True)
         commands: List[str] = []
+        if serve.cwd:
+            commands.append(f"cd {serve.cwd}")
         if serve.prepare:
             for step in serve.prepare:
                 if isinstance(step, RunStep):
                     commands.append(step.command)
                 elif isinstance(step, WorkdirStep):
                     commands.append(f"cd {step.path}")
-        content = "#!/bin/bash\ncd {app_dir}\n{body}".format(
-            app_dir=app_dir, body="\n".join(commands)
+        content = "#!/bin/bash\n{body}".format(
+            body="\n".join(commands)
         )
+        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)
         self.prepare_bash_script.write_text(content)
         self.prepare_bash_script.chmod(0o755)
 
@@ -739,15 +755,35 @@ class WasmerBuilder:
             env_lines = ""
 
         commands: List[str] = []
+        if serve.cwd:
+            commands.append(f"cd {serve.cwd}")
+
         if serve.prepare:
             for step in serve.prepare:
                 if isinstance(step, RunStep):
                     commands.append(step.command)
                 elif isinstance(step, WorkdirStep):
                     commands.append(f"cd {step.path}")
+
         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(
-            f"#!/bin/bash\n\n{body}",
+            content,
         )
         (prepare_dir / "prepare.sh").chmod(0o755)
 
@@ -842,7 +878,8 @@ class WasmerBuilder:
                 command.add("module", program_binary["script"])
                 command.add("runner", "wasi")
                 wasi_args = table()
-                wasi_args.add("cwd", "/app")
+                if serve.cwd:
+                    wasi_args.add("cwd", serve.cwd)
                 wasi_args.add("main-args", parts[1:])
                 env = program_binary.get("env") or {}
                 if serve.env:
@@ -1024,6 +1061,7 @@ class Ctx:
         build: List[str],
         deps: List[str],
         commands: Dict[str, str],
+        cwd: Optional[str] = None,
         assets: Optional[Dict[str, str]] = None,
         prepare: Optional[List[str]] = None,
         workers: Optional[List[str]] = None,
@@ -1043,6 +1081,7 @@ class Ctx:
             name=name,
             provider=provider,
             build=build_refs,
+            cwd=cwd,
             assets=assets,
             deps=dep_refs,
             commands=commands,
@@ -1433,7 +1472,7 @@ def main() -> None:
         app()
     except Exception as e:
         console.print(f"[bold red]{type(e).__name__}[/bold red]: {e}")
-        raise e
+        # raise e
 
 
 if __name__ == "__main__":

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/generator.py

@@ -7,22 +7,19 @@ from shipit.providers.base import DependencySpec, Provider, ProviderPlan, Detect
 from shipit.providers.registry import providers as registry_providers
 
 
-def _providers() -> list[Provider]:
-    # Load providers from modular registry
+def _providers() -> list[type[Provider]]:
+    # Load provider classes from modular registry
     return registry_providers()
 
 
 def detect_provider(path: Path) -> Provider:
-    matches: list[tuple[Provider, DetectResult]] = []
-    for p in _providers():
-        res = p.detect(path)
+    matches: list[tuple[type[Provider], DetectResult]] = []
+    for provider_cls in _providers():
+        res = provider_cls.detect(path)
         if res:
-            matches.append((p, res))
+            matches.append((provider_cls, res))
     if not matches:
-        # Default to static site as the safest fallback
-        from shipit.providers.staticfile import StaticFileProvider
-
-        return StaticFileProvider()
+        raise Exception("Shipit could not detect a provider for this project")
     # Highest score wins; tie-breaker by order
     matches.sort(key=lambda x: x[1].score, reverse=True)
     return matches[0][0]
@@ -80,20 +77,20 @@ def _render_assets(assets: Optional[Dict[str, str]]) -> Optional[str]:
 
 
 def generate_shipit(path: Path) -> str:
-    provider = detect_provider(path)
-    provider.initialize(path)
+    provider_cls = detect_provider(path)
+    provider = provider_cls(path)
 
     # Collect parts
     plan = ProviderPlan(
-        serve_name=provider.serve_name(path),
-        provider=provider.provider_kind(path),
-        mounts=provider.mounts(path),
-        declarations=provider.declarations(path),
-        dependencies=provider.dependencies(path),
-        build_steps=provider.build_steps(path),
-        prepare=provider.prepare_steps(path),
-        commands=provider.commands(path),
-        env=provider.env(path),
+        serve_name=provider.serve_name(),
+        provider=provider.provider_kind(),
+        mounts=provider.mounts(),
+        declarations=provider.declarations(),
+        dependencies=provider.dependencies(),
+        build_steps=provider.build_steps(),
+        prepare=provider.prepare_steps(),
+        commands=provider.commands(),
+        env=provider.env(),
     )
 
     # Declare dependency variables (combined) and collect serve deps
@@ -118,8 +115,10 @@ def generate_shipit(path: Path) -> str:
             env_lines = ",\n".join([f'    "{k}": {v}' for k, v in plan.env.items()])
     assets_block = _render_assets(plan.assets)
     mounts_block = None
+    attach_serve_names: list[str] = []
     if plan.mounts:
-        mounts = filter(lambda m: m.attach_to_serve, plan.mounts)
+        mounts = list(filter(lambda m: m.attach_to_serve, plan.mounts))
+        attach_serve_names = [m.name for m in mounts]
         mounts_block = ",\n".join([f"    {m.name}" for m in mounts])
 
     out: List[str] = []
@@ -134,6 +133,9 @@ def generate_shipit(path: Path) -> str:
     out.append("serve(")
     out.append(f'  name="{plan.serve_name}",')
     out.append(f'  provider="{plan.provider}",')
+    # If app is mounted for serve, set cwd to the app serve path
+    if "app" in attach_serve_names:
+        out.append('  cwd=app["serve"],')
     out.append("  build=[")
     out.append(build_steps_block)
     out.append("  ],")

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/base.py

@@ -12,21 +12,24 @@ class DetectResult:
 
 
 class Provider(Protocol):
-    def name(self) -> str: ...
-    def detect(self, path: Path) -> Optional[DetectResult]: ...
-    def initialize(self, path: Path) -> None: ...
-    # Structured plan steps
-    def serve_name(self, path: Path) -> str: ...
-    def provider_kind(self, path: Path) -> str: ...
-    def dependencies(self, path: Path) -> list["DependencySpec"]: ...
-    def declarations(self, path: Path) -> Optional[str]: ...
-    def build_steps(self, path: Path) -> list[str]: ...
+    def __init__(self, path: Path): ...
+    @classmethod
+    def name(cls) -> str: ...
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]: ...
+    def initialize(self) -> None: ...
+    # Structured plan steps (no path args; use self.path)
+    def serve_name(self) -> str: ...
+    def provider_kind(self) -> str: ...
+    def dependencies(self) -> list["DependencySpec"]: ...
+    def declarations(self) -> Optional[str]: ...
+    def build_steps(self) -> list[str]: ...
     # Prepare: list of Starlark step calls (currently only run(...))
-    def prepare_steps(self, path: Path) -> Optional[List[str]]: ...
-    def commands(self, path: Path) -> Dict[str, str]: ...
-    def assets(self, path: Path) -> Optional[Dict[str, str]]: ...
-    def mounts(self, path: Path) -> List["MountSpec"]: ...
-    def env(self, path: Path) -> Optional[Dict[str, str]]: ...
+    def prepare_steps(self) -> Optional[List[str]]: ...
+    def commands(self) -> Dict[str, str]: ...
+    def assets(self) -> Optional[Dict[str, str]]: ...
+    def mounts(self) -> List["MountSpec"]: ...
+    def env(self) -> Optional[Dict[str, str]]: ...
 
 
 @dataclass

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/gatsby.py

@@ -7,32 +7,36 @@ from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependen
 
 
 class GatsbyProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+    @classmethod
+    def name(cls) -> str:
         return "gatsby"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         pkg = path / "package.json"
         if not pkg.exists():
             return None
         if _exists(path, "gatsby-config.js", "gatsby-config.ts") or _has_dependency(
             pkg, "gatsby"
         ):
-            return DetectResult(self.name(), 90)
+            return DetectResult(cls.name(), 90)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "staticsite"
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return None
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "node",
@@ -44,7 +48,7 @@ class GatsbyProvider:
             DependencySpec("static-web-server", env_var="SHIPIT_SWS_VERSION", use_in_serve=True),
         ]
 
-    def build_steps(self, path: Path) -> list[str]:
+    def build_steps(self) -> list[str]:
         return [
             "run(\"npm install\", inputs=[\"package.json\", \"package-lock.json\"], group=\"install\")",
             "copy(\".\", \".\", ignore=[\"node_modules\", \".git\"])",
@@ -52,17 +56,17 @@ class GatsbyProvider:
             "run(\"cp -R public/* {}/\".format(app[\"build\"]))",
         ]
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return None
 
-    def commands(self, path: Path) -> Dict[str, str]:
+    def commands(self) -> Dict[str, str]:
         return {"start": '"static-web-server --root /app"'}
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return None
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/hugo.py

@@ -7,27 +7,29 @@ from .base import DetectResult, DependencySpec, Provider, _exists
 from .staticfile import StaticFileProvider
 
 class HugoProvider(StaticFileProvider):
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return "hugo"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         if _exists(path, "hugo.toml", "hugo.json", "hugo.yaml", "hugo.yml"):
-            return DetectResult(self.name(), 80)
+            return DetectResult(cls.name(), 80)
         if (
             _exists(path, "config.toml", "config.json", "config.yaml", "config.yml")
             and _exists(path, "content")
             and (_exists(path, "static") or _exists(path, "themes"))
         ):
-            return DetectResult(self.name(), 40)
+            return DetectResult(cls.name(), 40)
         return None
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "staticsite"
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "hugo",
@@ -35,10 +37,10 @@ class HugoProvider(StaticFileProvider):
                 default_version="0.149.0",
                 use_in_build=True,
             ),
-            *super().dependencies(path),
+            *super().dependencies(),
         ]
 
-    def build_steps(self, path: Path) -> list[str]:
+    def build_steps(self) -> list[str]:
         return [
             'copy(".", ".", ignore=[".git"])',
             'run("hugo build --destination={}".format(app["build"]), group="build")',

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/laravel.py

@@ -7,24 +7,28 @@ from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
 
 
 class LaravelProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+    @classmethod
+    def name(cls) -> str:
         return "laravel"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         if _exists(path, "artisan") and _exists(path, "composer.json"):
-            return DetectResult(self.name(), 95)
+            return DetectResult(cls.name(), 95)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "php"
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "php",
@@ -39,10 +43,10 @@ class LaravelProvider:
             DependencySpec("bash", use_in_serve=True),
         ]
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return "HOME = getenv(\"HOME\")"
 
-    def build_steps(self, path: Path) -> list[str]:
+    def build_steps(self) -> list[str]:
         return [
             "env(HOME=HOME, COMPOSER_FUND=\"0\")",
             "workdir(app[\"build\"])",
@@ -53,7 +57,7 @@ class LaravelProvider:
             "run(\"pnpm run build\", outputs=[\".\"], group=\"build\")",
         ]
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return [
             'workdir(app["serve"])',
             'run("mkdir -p storage/framework/{sessions,views,cache,testing} storage/logs bootstrap/cache")',
@@ -63,17 +67,17 @@ class LaravelProvider:
             'run("php artisan view:cache")',
         ]
 
-    def commands(self, path: Path) -> Dict[str, str]:
+    def commands(self) -> Dict[str, str]:
         return {
             "start": '"php -S localhost:8080 -t public"',
             "after_deploy": '"php artisan migrate"',
         }
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return None
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/mkdocs.py

@@ -7,24 +7,28 @@ from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
 
 
 class MkdocsProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+    @classmethod
+    def name(cls) -> str:
         return "mkdocs"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
-            return DetectResult(self.name(), 85)
+            return DetectResult(cls.name(), 85)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "mkdocs-site"
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "python",
@@ -46,11 +50,11 @@ class MkdocsProvider:
             ),
         ]
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return None
 
-    def build_steps(self, path: Path) -> list[str]:
-        has_requirements = _exists(path, "requirements.txt")
+    def build_steps(self) -> list[str]:
+        has_requirements = _exists(self.path, "requirements.txt")
         if has_requirements:
             install_lines = [
                 "run(\"uv init --no-managed-python\", inputs=[], outputs=[\".\"], group=\"install\")",
@@ -68,17 +72,17 @@ class MkdocsProvider:
             "run(\"uv run mkdocs build --site-dir={}\".format(app[\"build\"]), outputs=[\".\"], group=\"build\")",
         ]
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return None
 
-    def commands(self, path: Path) -> Dict[str, str]:
+    def commands(self) -> Dict[str, str]:
         return {"start": '"static-web-server --root /app"'}
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return None
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/node_static.py

@@ -7,28 +7,32 @@ from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependen
 
 
 class NodeStaticProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+    @classmethod
+    def name(cls) -> str:
         return "node-static"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         pkg = path / "package.json"
         if not pkg.exists():
             return None
         static_generators = ["astro", "vite", "next", "nuxt"]
         if any(_has_dependency(pkg, dep) for dep in static_generators):
-            return DetectResult(self.name(), 40)
+            return DetectResult(cls.name(), 40)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "staticsite"
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "node",
@@ -40,11 +44,11 @@ class NodeStaticProvider:
             DependencySpec("static-web-server", use_in_serve=True),
         ]
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return None
 
-    def build_steps(self, path: Path) -> list[str]:
-        output_dir = "dist" if (path / "dist").exists() else "public"
+    def build_steps(self) -> list[str]:
+        output_dir = "dist" if (self.path / "dist").exists() else "public"
         return [
             "run(\"npm install\", inputs=[\"package.json\", \"package-lock.json\"], group=\"install\")",
             "copy(\".\", \".\", ignore=[\"node_modules\", \".git\"])",
@@ -52,18 +56,18 @@ class NodeStaticProvider:
             f"run(\"cp -R {output_dir}/* {{}}/\".format(app[\"build\"]))",
         ]
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return None
 
-    def commands(self, path: Path) -> Dict[str, str]:
-        output_dir = "dist" if (path / "dist").exists() else "public"
+    def commands(self) -> Dict[str, str]:
+        output_dir = "dist" if (self.path / "dist").exists() else "public"
         return {"start": f'"static-web-server --root /app/{output_dir}"'}
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return None
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/php.py

@@ -7,29 +7,33 @@ from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
 
 
 class PhpProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+    @classmethod
+    def name(cls) -> str:
         return "php"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         if _exists(path, "composer.json") and _exists(path, "public/index.php"):
-            return DetectResult(self.name(), 60)
+            return DetectResult(cls.name(), 60)
         if _exists(path, "index.php") and not _exists(path, "composer.json"):
-            return DetectResult(self.name(), 10)
+            return DetectResult(cls.name(), 10)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "php"
 
-    def has_composer(self, path: Path) -> bool:
-        return _exists(path, "composer.json", "composer.lock")
+    def has_composer(self) -> bool:
+        return _exists(self.path, "composer.json", "composer.lock")
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         deps = [
             DependencySpec(
                 "php",
@@ -39,40 +43,40 @@ class PhpProvider:
                 use_in_serve=True,
             ),
         ]
-        if self.has_composer(path):
+        if self.has_composer():
             deps.append(DependencySpec("composer", use_in_build=True))
             deps.append(DependencySpec("bash", use_in_serve=True))
         return deps
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return "HOME = getenv(\"HOME\")"
 
-    def build_steps(self, path: Path) -> list[str]:
+    def build_steps(self) -> list[str]:
         steps = [
             "workdir(app[\"build\"])",
         ]
 
-        if self.has_composer(path):
+        if self.has_composer():
             steps.append("env(HOME=HOME, COMPOSER_FUND=\"0\")")
             steps.append("run(\"composer install --optimize-autoloader --no-scripts --no-interaction\", inputs=[\"composer.json\", \"composer.lock\"], outputs=[\".\"], group=\"install\")")
 
         steps.append("copy(\".\", \".\", ignore=[\".git\"])")
         return steps
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return None
 
-    def commands(self, path: Path) -> Dict[str, str]:
-        if _exists(path, "public/index.php"):
+    def commands(self) -> Dict[str, str]:
+        if _exists(self.path, "public/index.php"):
             return {"start": '"php -S localhost:8080 -t public"'}
-        elif _exists(path, "index.php"):
+        elif _exists(self.path, "index.php"):
             return {"start": '"php -S localhost:8080" -t .'}
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return {"php.ini": "get_asset(\"php/php.ini\")"}
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

shipit_cli-0.4.0/src/shipit/providers/python.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, Optional, Set
+from enum import Enum
+
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+)
+
+
+class PythonFramework(Enum):
+    Django = "django"
+    FastAPI = "fastapi"
+    Flask = "flask"
+    FastHTML = "python-fasthtml"
+
+
+class PythonServer(Enum):
+    Hypercorn = "hypercorn"
+    Uvicorn = "uvicorn"
+    # Gunicorn = "gunicorn"
+    Daphne = "daphne"
+
+class DatabaseType(Enum):
+    MySQL = "mysql"
+    PostgreSQL = "postgresql"
+
+
+class PythonProvider:
+    framework: Optional[PythonFramework] = None
+    server: Optional[PythonServer] = None
+    database: Optional[DatabaseType] = None
+    extra_dependencies: Set[str]
+    asgi_application: Optional[str] = None
+    wsgi_application: Optional[str] = None
+
+    def __init__(self, path: Path):
+        self.path = path
+        if _exists(self.path, ".python-version"):
+            python_version = (self.path / ".python-version").read_text().strip()
+        else:
+            python_version = "3.13"
+        self.default_python_version = python_version
+        self.extra_dependencies = set()
+
+        pg_deps = {
+            "asyncpg",
+            "aiopg",
+            "psycopg",
+            "psycopg2",
+            "psycopg-binary",
+            "psycopg2-binary"}
+        mysql_deps = {"mysqlclient", "pymysql", "mysql-connector-python", "aiomysql"}
+        found_deps = self.check_deps(
+            "django",
+            "fastapi",
+            "flask",
+            "python-fasthtml",
+            "daphne",
+            "hypercorn",
+            "uvicorn",
+            # "gunicorn",
+            *mysql_deps,
+            *pg_deps,
+        )
+
+        # ASGI/WSGI Server
+        if "uvicorn" in found_deps:
+            server = PythonServer.Uvicorn
+        elif "hypercorn" in found_deps:
+            server = PythonServer.Hypercorn
+        # elif "gunicorn" in found_deps:
+        #     server = PythonServer.Gunicorn
+        elif "daphne" in found_deps:
+            server = PythonServer.Daphne
+        else:
+            server = None
+        self.server = server
+
+        # Set framework
+        if _exists(self.path, "manage.py") and ("django" in found_deps):
+            framework = PythonFramework.Django
+            # Find the settings.py file using glob
+            settings_file = next(self.path.glob( "**/settings.py"))
+            if settings_file:
+                asgi_match = re.search(r"ASGI_APPLICATION\s*=\s*['\"](.*)['\"]", settings_file.read_text())
+                if asgi_match:
+                    self.asgi_application = asgi_match.group(1)
+                else:
+                    wsgi_match = re.search(r"WSGI_APPLICATION\s*=\s*['\"](.*)['\"]", settings_file.read_text())
+                    if wsgi_match:
+                        self.wsgi_application = wsgi_match.group(1)
+
+            if not self.server:
+                if self.asgi_application:
+                    self.extra_dependencies = {"uvicorn"}
+                    self.server = PythonServer.Uvicorn
+                elif self.wsgi_application:
+                    # gunicorn can't run with Wasmer atm
+                    self.extra_dependencies = {"uvicorn"}
+                    self.server = PythonServer.Uvicorn
+        elif "fastapi" in found_deps:
+            framework = PythonFramework.FastAPI
+            if not self.server:
+                self.extra_dependencies = {"uvicorn"}
+                self.server = PythonServer.Uvicorn
+        elif "flask" in found_deps:
+            framework = PythonFramework.Flask
+        elif "fastapi" in found_deps:
+            framework = PythonFramework.FastAPI
+        elif "flask" in found_deps:
+            framework = PythonFramework.Flask
+        elif "python-fasthtml" in found_deps:
+            framework = PythonFramework.FastHTML
+        else:
+            framework = None
+        self.framework = framework
+
+        # Database
+        if mysql_deps & found_deps:
+            database = DatabaseType.MySQL
+        elif pg_deps & found_deps:
+            database = DatabaseType.PostgreSQL
+        else:
+            database = None
+        self.database = database
+
+    def check_deps(self, *deps: str) -> Set[str]:
+        deps = set([dep.lower() for dep in deps])
+        initial_deps = set(deps)
+        for file in ["requirements.txt", "pyproject.toml"]:
+            if _exists(self.path, file):
+                for line in (self.path / file).read_text().splitlines():
+                    for dep in set(deps):
+                        if dep in line.lower():
+                            deps.remove(dep)
+                            if not deps:
+                                break
+                    if not deps:
+                        break
+            if not deps:
+                break
+        return initial_deps-deps
+
+    @classmethod
+    def name(cls) -> str:
+        return "python"
+
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "pyproject.toml", "requirements.txt"):
+            if _exists(path, "manage.py"):
+                return DetectResult(cls.name(), 70)
+            return DetectResult(cls.name(), 50)
+        return None
+
+    def initialize(self) -> None:
+        pass
+
+    def serve_name(self) -> str:
+        return self.path.name
+
+    def provider_kind(self) -> str:
+        return "python"
+
+    def dependencies(self) -> list[DependencySpec]:
+        return [
+            DependencySpec(
+                "python",
+                env_var="SHIPIT_PYTHON_VERSION",
+                default_version=self.default_python_version,
+                use_in_build=True,
+                use_in_serve=True,
+            ),
+            DependencySpec(
+                "uv",
+                env_var="SHIPIT_UV_VERSION",
+                default_version="0.8.15",
+                use_in_build=True,
+            ),
+        ]
+
+    def declarations(self) -> Optional[str]:
+        return (
+            "cross_platform = getenv(\"SHIPIT_PYTHON_CROSS_PLATFORM\")\n"
+            "python_extra_index_url = getenv(\"SHIPIT_PYTHON_EXTRA_INDEX_URL\")\n"
+            "precompile_python = getenv(\"SHIPIT_PYTHON_PRECOMPILE\") in [\"true\", \"True\", \"TRUE\", \"1\", \"on\", \"yes\", \"y\", \"Y\", \"YES\", \"On\", \"ON\"]\n"
+            "python_cross_packages_path = venv[\"build\"] + f\"/lib/python{python_version}/site-packages\"\n"
+            "python_serve_path = \"{}/lib/python{}/site-packages\".format(venv[\"serve\"], python_version)\n"
+        )
+
+    def build_steps(self) -> list[str]:
+        steps = [
+            "workdir(app[\"build\"])"
+        ]
+
+        if _exists(self.path, "pyproject.toml"):
+            input_files = ["pyproject.toml"]
+            extra_args = ""
+            if _exists(self.path, "uv.lock"):
+                input_files.append("uv.lock")
+                extra_args = " --locked"
+            inputs = ", ".join([f"\"{input}\"" for input in input_files])
+            extra_deps = ", ".join([f"{dep}" for dep in self.extra_dependencies])
+            steps += list(filter(None, [
+                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
+                "run(f\"uv sync --compile --python python{python_version} --no-managed-python" + extra_args + "\", inputs=[" + inputs + "], group=\"install\")",
+                f"run(\"uv add {extra_deps}\", inputs=[\"pyproject.toml\"], group=\"install\")" if extra_deps else None,
+                "run(f\"uv pip compile pyproject.toml --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --only-binary :all: -o cross-requirements.txt\", inputs=[\"pyproject.toml\"], outputs=[\"cross-requirements.txt\"]) if cross_platform else None",
+                f"run(f\"uvx pip install -r cross-requirements.txt {extra_deps} --target {{python_cross_packages_path}} --platform {{cross_platform}} --only-binary=:all: --python-version={{python_version}} --compile\") if cross_platform else None",
+                "run(\"rm cross-requirements.txt\") if cross_platform else None",
+            ]))
+        if _exists(self.path, "requirements.txt"):
+            steps += [
+                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
+                "run(f\"uv init --no-managed-python --python python{python_version}\", inputs=[], outputs=[\"uv.lock\"], group=\"install\")",
+                "run(f\"uv add -r requirements.txt\", inputs=[\"requirements.txt\"], group=\"install\")",
+                "run(f\"uv pip compile requirements.txt --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --only-binary :all: -o cross-requirements.txt\", inputs=[\"requirements.txt\"], outputs=[\"cross-requirements.txt\"]) if cross_platform else None",
+                "run(f\"uvx pip install -r cross-requirements.txt --target {python_cross_packages_path} --platform {cross_platform} --only-binary=:all: --python-version={python_version} --compile\") if cross_platform else None",
+                "run(\"rm cross-requirements.txt\") if cross_platform else None",
+            ]
+
+        steps += [
+            "path((local_venv[\"build\"] if cross_platform else venv[\"build\"]) + \"/bin\")",
+            "copy(\".\", \".\", ignore=[\".venv\", \".git\", \"__pycache__\"])",
+        ]
+        return steps
+
+    def prepare_steps(self) -> Optional[list[str]]:
+        return [
+            'run("echo \\\"Precompiling Python code...\\\"") if precompile_python else None',
+            'run(f"python -m compileall -o 2 {python_serve_path}") if precompile_python else None',
+            'run("echo \\\"Precompiling package code...\\\"") if precompile_python else None',
+            'run("python -m compileall -o 2 {}".format(app["serve"])) if precompile_python else None',
+        ]
+
+    def commands(self) -> Dict[str, str]:
+        if self.framework == PythonFramework.Django:
+            start_cmd = None
+            if self.server == PythonServer.Daphne and self.asgi_application:
+                asgi_application = format_app_import(self.asgi_application)
+                start_cmd = f'"python -m daphne {asgi_application} --bind 0.0.0.0 --port 8000"'
+            elif self.server == PythonServer.Uvicorn:
+                if self.asgi_application:
+                    asgi_application = format_app_import(self.asgi_application)
+                    start_cmd = f'"python -m uvicorn {asgi_application} --host 0.0.0.0 --port 8000"'
+                elif self.wsgi_application:
+                    wsgi_application = format_app_import(self.wsgi_application)
+                    start_cmd = f'"python -m uvicorn {wsgi_application} --interface=wsgi --host 0.0.0.0 --port 8000"'
+            # elif self.server == PythonServer.Gunicorn:
+            #     start_cmd = f'"python -m gunicorn {self.wsgi_application} --bind 0.0.0.0 --port 8000"'
+            if not start_cmd:
+                # We run the default runserver command if no server is specified
+                start_cmd = '"python manage.py runserver 0.0.0.0:8000"'
+            migrate_cmd = '"python manage.py migrate"'
+            return {"start": start_cmd, "after_deploy": migrate_cmd}
+        elif self.framework == PythonFramework.FastAPI:
+            if _exists(self.path, "main.py"):
+                path = "main:app"
+            elif _exists(self.path, "src/main.py"):
+                path = "src.main:app"
+            
+            if self.server == PythonServer.Uvicorn:
+                start_cmd = f'"python -m uvicorn {path} --host 0.0.0.0 --port 8000"'
+            elif self.server == PythonServer.Hypercorn:
+                start_cmd = f'"python -m hypercorn {path} --bind 0.0.0.0:8000"'
+            else:
+                start_cmd = '"python -c \'print(\\\"No start command detected, please provide a start command manually\\\")\'"'
+            return {"start": start_cmd}
+        elif self.framework == PythonFramework.FastHTML:
+            if _exists(self.path, "main.py"):
+                path = "main:app"
+            elif _exists(self.path, "src/main.py"):
+                path = "src.main:app"
+            start_cmd = f'"python -m uvicorn {path} --host 0.0.0.0 --port 8000"'
+        elif _exists(self.path, "main.py"):
+            start_cmd = '"python main.py"'
+        elif _exists(self.path, "src/main.py"):
+            start_cmd = '"python src/main.py"'
+        else:
+            start_cmd = '"python -c \'print(\\\"No start command detected, please provide a start command manually\\\")\'"'
+        return {"start": start_cmd}
+
+    def assets(self) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self) -> list[MountSpec]:
+        return [
+            MountSpec("app"),
+            MountSpec("venv"),
+            MountSpec("local_venv", attach_to_serve=False),
+        ]
+
+    def env(self) -> Optional[Dict[str, str]]:
+        # For Django projects, generate an empty env dict to surface the field
+        # in the Shipit file. Other Python projects omit it by default.
+        return {
+            "PYTHONPATH": "python_serve_path"
+        }
+
+def format_app_import(asgi_application: str) -> str:
+    # Transform "mysite.asgi.application" to "mysite.asgi:application" using regex
+    return re.sub(r"\.([^.]+)$", r":\1", asgi_application)

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/registry.py

@@ -11,16 +11,15 @@ from .python import PythonProvider
 from .staticfile import StaticFileProvider
 
 
-def providers() -> list[Provider]:
+def providers() -> list[type[Provider]]:
     # Order matters: more specific providers first
     return [
-        LaravelProvider(),
-        GatsbyProvider(),
-        HugoProvider(),
-        MkdocsProvider(),
-        PythonProvider(),
-        PhpProvider(),
-        NodeStaticProvider(),
-        StaticFileProvider(),
+        LaravelProvider,
+        GatsbyProvider,
+        HugoProvider,
+        MkdocsProvider,
+        PythonProvider,
+        PhpProvider,
+        NodeStaticProvider,
+        StaticFileProvider,
     ]
-

{shipit_cli-0.3.3 → shipit_cli-0.4.0}/src/shipit/providers/staticfile.py

@@ -7,28 +7,33 @@ from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
 
 
 class StaticFileProvider:
-    def name(self) -> str:
+    def __init__(self, path: Path):
+        self.path = path
+
+    @classmethod
+    def name(cls) -> str:
         return "staticfile"
 
-    def detect(self, path: Path) -> Optional[DetectResult]:
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
         if _exists(path, "Staticfile"):
-            return DetectResult(self.name(), 50)
+            return DetectResult(cls.name(), 50)
         if _exists(path, "index.html") and not _exists(
             path, "package.json", "pyproject.toml", "composer.json"
         ):
-            return DetectResult(self.name(), 10)
+            return DetectResult(cls.name(), 10)
         return None
 
-    def initialize(self, path: Path) -> None:
+    def initialize(self) -> None:
         pass
 
-    def serve_name(self, path: Path) -> str:
-        return path.name
+    def serve_name(self) -> str:
+        return self.path.name
 
-    def provider_kind(self, path: Path) -> str:
+    def provider_kind(self) -> str:
         return "staticfile"
 
-    def dependencies(self, path: Path) -> list[DependencySpec]:
+    def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "static-web-server",
@@ -38,28 +43,28 @@ class StaticFileProvider:
             )
         ]
 
-    def build_steps(self, path: Path) -> list[str]:
+    def build_steps(self) -> list[str]:
         return [
             'workdir(app["build"])',
             'copy(".", ".", ignore=[".git"])'
         ]
 
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+    def prepare_steps(self) -> Optional[list[str]]:
         return None
 
-    def declarations(self, path: Path) -> Optional[str]:
+    def declarations(self) -> Optional[str]:
         return None
 
-    def commands(self, path: Path) -> Dict[str, str]:
+    def commands(self) -> Dict[str, str]:
         return {
             "start": '"static-web-server --root={} --log-level=info".format(app["serve"])'
         }
 
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+    def assets(self) -> Optional[Dict[str, str]]:
         return None
 
-    def mounts(self, path: Path) -> list[MountSpec]:
+    def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
+    def env(self) -> Optional[Dict[str, str]]:
         return None

shipit_cli-0.4.0/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.4.0"
+version_info = (0, 4, 0, "final", 0)

shipit_cli-0.3.3/src/shipit/providers/python.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Dict, Optional
-
-from .base import (
-    DetectResult,
-    DependencySpec,
-    Provider,
-    _exists,
-    MountSpec,
-)
-
-
-class PythonProvider:
-    def name(self) -> str:
-        return "python"
-
-    def detect(self, path: Path) -> Optional[DetectResult]:
-        if _exists(path, "pyproject.toml", "requirements.txt"):
-            if _exists(path, "manage.py"):
-                return DetectResult(self.name(), 70)
-            return DetectResult(self.name(), 50)
-        return None
-
-    def initialize(self, path: Path) -> None:
-        pass
-
-    def serve_name(self, path: Path) -> str:
-        return path.name
-
-    def provider_kind(self, path: Path) -> str:
-        return "python"
-
-    def dependencies(self, path: Path) -> list[DependencySpec]:
-        if _exists(path, ".python-version"):
-            python_version = (path / ".python-version").read_text().strip()
-        else:
-            python_version = "3.13"
-
-        return [
-            DependencySpec(
-                "python",
-                env_var="SHIPIT_PYTHON_VERSION",
-                default_version=python_version,
-                use_in_build=True,
-                use_in_serve=True,
-            ),
-            DependencySpec(
-                "uv",
-                env_var="SHIPIT_UV_VERSION",
-                default_version="0.8.15",
-                use_in_build=True,
-            ),
-        ]
-
-    def declarations(self, path: Path) -> Optional[str]:
-        return (
-            "cross_platform = getenv(\"SHIPIT_PYTHON_CROSS_PLATFORM\")\n"
-            "python_extra_index_url = getenv(\"SHIPIT_PYTHON_EXTRA_INDEX_URL\")\n"
-            "precompile_python = getenv(\"SHIPIT_PYTHON_PRECOMPILE\") in [\"true\", \"True\", \"TRUE\", \"1\", \"on\", \"yes\", \"y\", \"Y\", \"YES\", \"On\", \"ON\"]\n"
-            "python_cross_packages_path = venv[\"build\"] + f\"/lib/python{python_version}/site-packages\""
-        )
-
-    def build_steps(self, path: Path) -> list[str]:
-        steps = [
-            "workdir(app[\"build\"])"
-        ]
-
-        if _exists(path, "pyproject.toml"):
-            input_files = ["pyproject.toml"]
-            if _exists(path, "uv.lock"):
-                input_files.append("uv.lock")
-            inputs = ", ".join([f"\"{input}\"" for input in input_files])
-            steps += [
-                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
-                "run(f\"uv sync --compile --python python{python_version} --locked --no-managed-python\", inputs=[" + inputs + "], group=\"install\")",
-                "run(f\"uv pip compile pyproject.toml --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --only-binary :all: -o cross-requirements.txt\", inputs=[\"pyproject.toml\"], outputs=[\"cross-requirements.txt\"]) if cross_platform else None",
-                "run(f\"uvx pip install -r cross-requirements.txt --target {python_cross_packages_path} --platform {cross_platform} --only-binary=:all: --python-version={python_version} --compile\") if cross_platform else None",
-                "run(\"rm cross-requirements.txt\") if cross_platform else None",
-            ]
-        if _exists(path, "requirements.txt"):
-            steps += [
-                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
-                "run(f\"uv init --no-managed-python --python python{python_version}\", inputs=[], outputs=[\"uv.lock\"], group=\"install\")",
-                "run(f\"uv add -r requirements.txt\", inputs=[\"requirements.txt\"], group=\"install\")",
-                "run(f\"uv pip compile requirements.txt --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --only-binary :all: -o cross-requirements.txt\", inputs=[\"requirements.txt\"], outputs=[\"cross-requirements.txt\"]) if cross_platform else None",
-                "run(f\"uvx pip install -r cross-requirements.txt --target {python_cross_packages_path} --platform {cross_platform} --only-binary=:all: --python-version={python_version} --compile\") if cross_platform else None",
-                "run(\"rm cross-requirements.txt\") if cross_platform else None",
-            ]
-
-        steps += [
-            "path((local_venv[\"build\"] if cross_platform else venv[\"build\"]) + \"/bin\")",
-            "copy(\".\", \".\", ignore=[\".venv\", \".git\", \"__pycache__\"])",
-        ]
-        return steps
-
-    def prepare_steps(self, path: Path) -> Optional[list[str]]:
-        return [
-            'workdir(app["serve"])',
-            'run("echo \\\"Precompiling Python code...\\\"") if precompile_python else None',
-            'run("python -m compileall -o 2 $PYTHONPATH") if precompile_python else None',
-            'run("echo \\\"Precompiling package code...\\\"") if precompile_python else None',
-            'run("python -m compileall -o 2 .") if precompile_python else None',
-        ]
-
-    def commands(self, path: Path) -> Dict[str, str]:
-        if _exists(path, "manage.py"):
-            start_cmd = '"python manage.py runserver 0.0.0.0:8000"'
-            migrate_cmd = '"python manage.py migrate"'
-            return {"start": start_cmd, "after_deploy": migrate_cmd}
-        elif _exists(path, "main.py"):
-            start_cmd = '"python main.py"'
-        elif _exists(path, "src/main.py"):
-            start_cmd = '"python src/main.py"'
-        else:
-            start_cmd = '"python -c \'print(\\\"Hello, World!\\\")\'"'
-        return {"start": start_cmd}
-
-    def assets(self, path: Path) -> Optional[Dict[str, str]]:
-        return None
-
-    def mounts(self, path: Path) -> list[MountSpec]:
-        return [
-            MountSpec("app"),
-            MountSpec("venv"),
-            MountSpec("local_venv", attach_to_serve=False),
-        ]
-
-    def env(self, path: Path) -> Optional[Dict[str, str]]:
-        # For Django projects, generate an empty env dict to surface the field
-        # in the Shipit file. Other Python projects omit it by default.
-        return {
-            "PYTHONPATH": "\"{}/lib/python{}/site-packages\".format(venv[\"serve\"], python_version)"
-        }

shipit_cli-0.3.3/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.3.3"
-version_info = (0, 3, 3, "final", 0)