shipit-cli 0.3.4__tar.gz → 0.4.1__tar.gz

{shipit_cli-0.3.4 → shipit_cli-0.4.1}/PKG-INFO

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

{shipit_cli-0.3.4 → shipit_cli-0.4.1}/pyproject.toml

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

{shipit_cli-0.3.4 → shipit_cli-0.4.1}/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.4 → shipit_cli-0.4.1}/src/shipit/generator.py

@@ -115,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] = []
@@ -131,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.4.1/src/shipit/providers/python.py

@@ -0,0 +1,310 @@
+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\")",
+                "copy(\"pyproject.toml\", \"pyproject.toml\")",
+                f"run(\"uv add {extra_deps}\", 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\", 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.4.1/src/shipit/version.py

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

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

@@ -1,141 +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 __init__(self, path: Path):
-        self.path = path
-    @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]:
-        if _exists(self.path, ".python-version"):
-            python_version = (self.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) -> 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) -> 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])
-            steps += [
-                "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\")",
-                "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(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 [
-            '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) -> Dict[str, str]:
-        if _exists(self.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(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(\\\"Hello, World!\\\")\'"'
-        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": "\"{}/lib/python{}/site-packages\".format(venv[\"serve\"], python_version)"
-        }

shipit_cli-0.3.4/src/shipit/version.py

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