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

shipit/providers/python.py

@@ -1,11 +1,10 @@
-from __future__ import annotations
-
-import json
 import re
 from pathlib import Path
 from typing import Dict, Optional, Set
 from enum import Enum
-from functools import cached_property
+
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
 
 from .base import (
     DetectResult,
@@ -15,7 +14,7 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
 
 
@@ -40,39 +39,61 @@ class DatabaseType(Enum):
     PostgreSQL = "postgresql"
 
 
-class PythonProvider:
+class PythonConfig(Config):
+    model_config = SettingsConfigDict(
+        extra="ignore", env_prefix="SHIPIT_"
+    )
+
     framework: Optional[PythonFramework] = None
     server: Optional[PythonServer] = None
     database: Optional[DatabaseType] = None
-    extra_dependencies: Set[str]
+    extra_dependencies: Set[str] = Field(default_factory=set)
     asgi_application: Optional[str] = None
     wsgi_application: Optional[str] = None
     uses_ffmpeg: bool = False
     uses_pandoc: bool = False
-    only_build: bool = False
     install_requires_all_files: bool = False
-    custom_commands: CustomCommands
+    main_file: Optional[str] = None
+    python_version: Optional[str] = "3.13"
+    uv_version: Optional[str] = "0.8.15"
+    precompile_python: bool = True
+    cross_platform: Optional[str] = None
+    python_extra_index_url: Optional[str] = None
+    pandoc_version: Optional[str] = None
+    ffmpeg_version: Optional[str] = None
+
+
+class PythonProvider:
+    only_build: bool = False
 
     def __init__(
         self,
         path: Path,
-        custom_commands: CustomCommands,
+        config: PythonConfig,
         only_build: bool = False,
-        extra_dependencies: Optional[Set[str]] = None,
     ):
         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()
+        self.config = config
         self.only_build = only_build
-        self.custom_commands = custom_commands
-        self.extra_dependencies = extra_dependencies or set()
 
-        if self.only_build:
-            return
+    @classmethod
+    def load_config(
+        cls,
+        path: Path,
+        base_config: Config,
+        must_have_deps: Optional[Set[str]] = None,
+    ) -> PythonConfig:
+        config = PythonConfig(**base_config.model_dump())
+
+        if not config.main_file:
+            config.main_file = cls.detect_main_file(path)
+
+        if not config.python_version:
+            if _exists(path, ".python-version"):
+                python_version = (path / ".python-version").read_text().strip()
+            else:
+                python_version = "3.13"
+            config.python_version = python_version
 
         pg_deps = {
             "asyncpg",
@@ -82,12 +103,21 @@ class PythonProvider:
             "psycopg-binary",
             "psycopg2-binary",
         }
-        mysql_deps = {"mysqlclient", "pymysql", "mysql-connector-python", "aiomysql", "asyncmy"}
-        found_deps = self.check_deps(
+        mysql_deps = {
+            "mysqlclient",
+            "pymysql",
+            "mysql-connector-python",
+            "aiomysql",
+            "asyncmy",
+        }
+        must_have_deps = must_have_deps or set()
+        found_deps = cls.check_deps(
+            path,
             "file://",  # This is not really a dependency, but as a way to check if the install script requires all files
             "streamlit",
             "django",
             "mcp",
+            "mcp[cli]",
             "fastapi",
             "flask",
             "python-fasthtml",
@@ -100,100 +130,135 @@ class PythonProvider:
             # "gunicorn",
             *mysql_deps,
             *pg_deps,
+            *must_have_deps,
         )
 
         if "file://" in found_deps:
-            self.install_requires_all_files = True
-
-        # 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
+            config.install_requires_all_files = True
+
+        if not config.server:
+            # 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
+            config.server = server
 
         if "ffmpeg" in found_deps:
-            self.uses_ffmpeg = True
+            config.uses_ffmpeg = True
         if "pandoc" in found_deps:
-            self.uses_pandoc = True
-
-        if self.custom_commands.start and self.custom_commands.start.startswith("uvicorn "):
-            self.server = PythonServer.Uvicorn
-            self.custom_commands.start = self.custom_commands.start.replace("uvicorn ", "python -m uvicorn ")
-            self.extra_dependencies = {"uvicorn"}
-
-        # Set framework
-        if _exists(self.path, "manage.py") and ("django" in found_deps):
-            framework = PythonFramework.Django
-            # Find the settings.py file using glob
-            try:
-                settings_file = next(self.path.glob("**/settings.py"))
-            except StopIteration:
-                settings_file = None
-            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*['\"](.*)['\"]",
+            config.uses_pandoc = True
+
+        if not config.framework:
+            # Set framework
+            if _exists(path, "manage.py") and ("django" in found_deps):
+                framework = PythonFramework.Django
+            elif "streamlit" in found_deps:
+                framework = PythonFramework.Streamlit
+            elif "mcp" in found_deps:
+                framework = PythonFramework.MCP
+            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
+            config.framework = framework
+
+        if not config.server and config.framework:
+            if config.framework == PythonFramework.Django:
+                config.server = PythonServer.Uvicorn
+            elif config.framework == PythonFramework.FastAPI:
+                config.server = PythonServer.Uvicorn
+            elif config.framework == PythonFramework.Flask:
+                config.server = PythonServer.Uvicorn
+            elif config.framework == PythonFramework.FastHTML:
+                config.server = PythonServer.Uvicorn
+
+            if config.server == PythonServer.Uvicorn:
+                must_have_deps.add("uvicorn")
+
+        if not config.asgi_application and not config.wsgi_application:
+            if config.framework == PythonFramework.Django:
+                # Find the settings.py file using glob
+                try:
+                    settings_file = next(path.glob("**/settings.py"))
+                except StopIteration:
+                    settings_file = None
+                if settings_file:
+                    asgi_match = re.search(
+                        r"ASGI_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 "streamlit" in found_deps:
-            framework = PythonFramework.Streamlit
-        elif "mcp" in found_deps:
-            framework = PythonFramework.MCP
-            self.extra_dependencies = {"mcp[cli]"}
-        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
-            if not self.server:
-                self.extra_dependencies = {"uvicorn"}
-                self.server = PythonServer.Uvicorn
-        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
+                    if asgi_match:
+                        config.asgi_application = format_app_import(
+                            asgi_match.group(1)
+                        )
+                    else:
+                        wsgi_match = re.search(
+                            r"WSGI_APPLICATION\s*=\s*['\"](.*)['\"]",
+                            settings_file.read_text(),
+                        )
+                        if wsgi_match:
+                            config.wsgi_application = format_app_import(
+                                wsgi_match.group(1)
+                            )
+
+            python_path = file_to_python_path(config.main_file)
+            if config.framework == PythonFramework.FastAPI:
+                config.asgi_application = python_path
+            elif config.framework == PythonFramework.Flask:
+                config.wsgi_application = python_path
+            elif config.framework == PythonFramework.MCP:
+                config.asgi_application = python_path
+            elif config.framework == PythonFramework.FastHTML:
+                config.asgi_application = python_path
+
+        is_uvicorn_start = config.commands.start and config.commands.start.startswith(
+            "uvicorn "
+        )
+        framework_should_use_uvicorn = config.framework in [
+            PythonFramework.Django,
+            PythonFramework.FastAPI,
+            PythonFramework.Flask,
+        ]
+        if is_uvicorn_start or (framework_should_use_uvicorn and not config.server):
+            must_have_deps.add("uvicorn")
+            config.server = PythonServer.Uvicorn
+        if config.framework == PythonFramework.MCP:
+            must_have_deps.add("mcp[cli]")
+
+        for dep in must_have_deps:
+            if dep not in found_deps:
+                config.extra_dependencies.add(dep)
+
+        if not config.database:
+            # Database
+            if mysql_deps & found_deps:
+                database = DatabaseType.MySQL
+            elif pg_deps & found_deps:
+                database = DatabaseType.PostgreSQL
+            else:
+                database = None
+            config.database = database
+
+        return config
 
-    def check_deps(self, *deps: str) -> Set[str]:
+    @classmethod
+    def check_deps(cls, path: Path, *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():
+            if _exists(path, file):
+                for line in (path / file).read_text().splitlines():
                     for dep in set(deps):
                         if dep in line.lower():
                             deps.remove(dep)
@@ -210,57 +275,56 @@ class PythonProvider:
         return "python"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(
+        cls, path: Path, config: Config
+    ) -> Optional[DetectResult]:
         if _exists(path, "pyproject.toml", "requirements.txt"):
             if _exists(path, "manage.py"):
                 return DetectResult(cls.name(), 70)
             return DetectResult(cls.name(), 50)
-        if custom_commands.start:
-            if custom_commands.start.startswith("python ") or custom_commands.start.startswith("uv ") or custom_commands.start.startswith("uvicorn ") or custom_commands.start.startswith("gunicorn "):
+        if config.commands.start:
+            if (
+                config.commands.start.startswith("python ")
+                or config.commands.start.startswith("uv ")
+                or config.commands.start.startswith("uvicorn ")
+                or config.commands.start.startswith("gunicorn ")
+            ):
                 return DetectResult(cls.name(), 80)
         if cls.detect_main_file(path):
             return DetectResult(cls.name(), 10)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return self.framework.value if self.framework else None
-
     def dependencies(self) -> list[DependencySpec]:
         deps = [
             DependencySpec(
                 "python",
-                env_var="SHIPIT_PYTHON_VERSION",
-                default_version=self.default_python_version,
+                var_name="config.python_version",
                 use_in_build=True,
                 use_in_serve=True,
             ),
             DependencySpec(
                 "uv",
-                env_var="SHIPIT_UV_VERSION",
-                default_version="0.8.15",
+                var_name="config.uv_version",
                 use_in_build=True,
             ),
         ]
-        if self.uses_pandoc:
+        if self.config.uses_pandoc:
             deps.append(
                 DependencySpec(
                     "pandoc",
-                    env_var="SHIPIT_PANDOC_VERSION",
+                    var_name="config.pandoc_version",
                     use_in_build=False,
                     use_in_serve=True,
                 )
             )
-        if self.uses_ffmpeg:
+        if self.config.uses_ffmpeg:
             deps.append(
                 DependencySpec(
                     "ffmpeg",
-                    env_var="SHIPIT_FFMPEG_VERSION",
+                    var_name="config.ffmpeg_version",
                     use_in_build=False,
                     use_in_serve=True,
                 )
@@ -270,25 +334,27 @@ class PythonProvider:
     def declarations(self) -> Optional[str]:
         if self.only_build:
             return (
-                'cross_platform = getenv("SHIPIT_PYTHON_CROSS_PLATFORM")\n'
+                "python_version = config.python_version\n"
+                "cross_platform = config.cross_platform\n"
                 "venv = local_venv\n"
             )
         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_site_packages_path = "{}/lib/python{}/site-packages".format(venv["serve"], python_version)\n'
-            'app_serve_path = app["serve"]\n'
+            "python_version = config.python_version\n"
+            "cross_platform = config.cross_platform\n"
+            "python_extra_index_url = config.python_extra_index_url\n"
+            "precompile_python = config.precompile_python\n"
+            'python_cross_packages_path = venv.path + f"/lib/python{python_version}/site-packages"\n'
+            'python_serve_site_packages_path = "{}/lib/python{}/site-packages".format(venv.serve_path, python_version)\n'
+            'app_serve_path = app.serve_path\n'
         )
 
     def build_steps(self) -> list[str]:
         if not self.only_build:
-            steps = ['workdir(app["build"])']
+            steps = ['workdir(app.path)']
         else:
-            steps = ['workdir(temp["build"])']
+            steps = ['workdir(temp.path)']
 
-        extra_deps = ", ".join([f"{dep}" for dep in self.extra_dependencies])
+        extra_deps = ", ".join([f"{dep}" for dep in self.config.extra_dependencies])
         has_requirements = _exists(self.path, "requirements.txt")
         if _exists(self.path, "pyproject.toml"):
             input_files = ["pyproject.toml"]
@@ -309,11 +375,11 @@ class PythonProvider:
             # Join inputs
             inputs = ", ".join([f'"{input}"' for input in input_files])
             steps += [
-                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"], UV_PYTHON_PREFERENCE="only-system", UV_PYTHON=f"python{python_version}")',
-                'copy(".", ".")' if self.install_requires_all_files else None,
+                'env(UV_PROJECT_ENVIRONMENT=local_venv.path if cross_platform else venv.path, UV_PYTHON_PREFERENCE="only-system", UV_PYTHON=f"python{python_version}")',
+                'copy(".", ".")' if self.config.install_requires_all_files else None,
                 f'run(f"uv sync{extra_args}", inputs=[{inputs}], group="install")',
                 'copy("pyproject.toml", "pyproject.toml")'
-                if not self.install_requires_all_files
+                if not self.config.install_requires_all_files
                 else None,
                 f'run("uv add {extra_deps}", group="install")' if extra_deps else None,
             ]
@@ -325,9 +391,11 @@ class PythonProvider:
                 ]
         elif has_requirements or extra_deps:
             steps += [
-                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"])',
+                'env(UV_PROJECT_ENVIRONMENT=local_venv.path if cross_platform else venv.path)',
                 'run(f"uv init", inputs=[], outputs=["uv.lock"], group="install")',
-                'copy(".", ".", ignore=[".venv", ".git", "__pycache__"])' if self.install_requires_all_files else None,
+                'copy(".", ".", ignore=[".venv", ".git", "__pycache__"])'
+                if self.config.install_requires_all_files
+                else None,
             ]
             if has_requirements:
                 steps += [
@@ -345,15 +413,17 @@ class PythonProvider:
                 ]
 
         steps += [
-            'path((local_venv["build"] if cross_platform else venv["build"]) + "/bin")',
-            'copy(".", ".", ignore=[".venv", ".git", "__pycache__"])' if not self.install_requires_all_files else None,
+            'path((local_venv.path if cross_platform else venv.path) + "/bin")',
+            'copy(".", ".", ignore=[".venv", ".git", "__pycache__"])'
+            if not self.config.install_requires_all_files
+            else None,
         ]
-        if self.framework == PythonFramework.MCP:
+        if self.config.framework == PythonFramework.MCP:
             steps += [
-                'run("mkdir -p {}/bin".format(venv["build"])) if cross_platform else None',
-                'run("cp {}/bin/mcp {}/bin/mcp".format(local_venv["build"], venv["build"])) if cross_platform else None',
+                'run("mkdir -p {}/bin".format(venv.path)) if cross_platform else None',
+                'run("cp {}/bin/mcp {}/bin/mcp".format(local_venv.path, venv.path)) if cross_platform else None',
             ]
-        if self.framework == PythonFramework.Django:
+        if self.config.framework == PythonFramework.Django:
             steps += [
                 'run("python manage.py collectstatic --noinput", group="build")',
             ]
@@ -364,9 +434,9 @@ class PythonProvider:
             return []
         return [
             'run("echo \\"Precompiling Python code...\\"") if precompile_python else None',
-            'run(f"python -m compileall -o 2 {python_serve_site_packages_path}") if precompile_python else None',
+            'run(f"python -m compileall -o 2 {python_serve_site_packages_path} || true") if precompile_python else None',
             'run("echo \\"Precompiling package code...\\"") if precompile_python else None',
-            'run(f"python -m compileall -o 2 {app_serve_path}") if precompile_python else None',
+            'run(f"python -m compileall -o 2 {app_serve_path} || true") if precompile_python else None',
         ]
 
     @classmethod
@@ -380,91 +450,74 @@ class PythonProvider:
             if _exists(root_path, f"src/{path}"):
                 return f"src/{path}"
         for path in paths_to_try:
-            try:
-                found_path = next(root_path.glob(f"**/{path}"))
-            except StopIteration:
-                found_path = None
+            found_path = next(root_path.glob(f"*/{path}"), None)
+            if not found_path:
+                found_path = next(root_path.glob(f"*/*/{path}"), None)
             if found_path:
                 return str(found_path.relative_to(root_path))
         return None
 
-    @cached_property
-    def main_file(self) -> Optional[str]:
-        return self.detect_main_file(self.path)
-
     def commands(self) -> Dict[str, str]:
-        commands = self.base_commands()
-        if self.custom_commands.start:
-            commands["start"] = json.dumps(self.custom_commands.start)
-        return commands
+        return self.base_commands()
 
     def base_commands(self) -> Dict[str, str]:
         if self.only_build:
             return {}
-        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'f"python -m daphne {asgi_application} --bind 0.0.0.0 --port {{PORT}}"'
-                )
-            elif self.server == PythonServer.Uvicorn:
-                if self.asgi_application:
-                    asgi_application = format_app_import(self.asgi_application)
-                    start_cmd = f'f"python -m uvicorn {asgi_application} --host 0.0.0.0 --port {{PORT}}"'
-                elif self.wsgi_application:
-                    wsgi_application = format_app_import(self.wsgi_application)
-                    start_cmd = f'f"python -m uvicorn {wsgi_application} --interface=wsgi --host 0.0.0.0 --port {{PORT}}"'
-            # elif self.server == PythonServer.Gunicorn:
-            #     start_cmd = f'"fpython -m gunicorn {self.wsgi_application} --bind 0.0.0.0 --port {{PORT}}"'
-            if not start_cmd:
-                # We run the default runserver command if no server is specified
-                start_cmd = 'f"python manage.py runserver 0.0.0.0:{PORT}"'
-            migrate_cmd = '"python manage.py migrate"'
-            return {"start": start_cmd, "after_deploy": migrate_cmd}
-
-        main_file = self.main_file
-
-        if not main_file:
-            start_cmd = '"python -c \'print(\\"No start command detected, please provide a start command manually\\")\'"'
-            return {"start": start_cmd}
-
-        if self.framework == PythonFramework.FastAPI:
-            python_path = file_to_python_path(main_file)
-            path = f"{python_path}:app"
-            if self.server == PythonServer.Uvicorn:
-                start_cmd = f'f"python -m uvicorn {path} --host 0.0.0.0 --port {{PORT}}"'
-            elif self.server == PythonServer.Hypercorn:
-                start_cmd = f'f"python -m hypercorn {path} --bind 0.0.0.0:{{PORT}}"'
-            else:
-                start_cmd = '"python -c \'print(\\"No start command detected, please provide a start command manually\\")\'"'
-            return {"start": start_cmd}
-
-        elif self.framework == PythonFramework.Streamlit:
-            start_cmd = f'f"python -m streamlit run {main_file} --server.port {{PORT}} --server.address 0.0.0.0 --server.headless true"'
-
-        elif self.framework == PythonFramework.Flask:
-            python_path = file_to_python_path(main_file)
-            path = f"{python_path}:app"
-            # start_cmd = f'f"python -m flask --app {path} run --debug --host 0.0.0.0 --port {{PORT}}"'
-            start_cmd = f'f"python -m uvicorn {path} --interface=wsgi --host 0.0.0.0 --port {{PORT}}"'
 
-        elif self.framework == PythonFramework.MCP:
+        start_cmd = None
+        if self.config.server == PythonServer.Daphne:
+            assert self.config.asgi_application, (
+                "No ASGI application found for Daphne"
+            )
+            start_cmd = f'f"daphne {self.config.asgi_application} --bind 0.0.0.0 --port {{PORT}}"'
+        # elif self.config.server == PythonServer.Gunicorn:
+        #     assert self.config.wsgi_application, "No WSGI application found"
+        #     start_cmd = f'f"gunicorn {self.config.wsgi_application} --bind 0.0.0.0 --port {{PORT}}"'
+        elif self.config.server == PythonServer.Uvicorn:
+            if not self.config.main_file:
+                assert (
+                    self.config.asgi_application or self.config.wsgi_application
+                ), (
+                    "No ASGI or WSGI application found for Uvicorn and no main file found"
+                )
+            if self.config.asgi_application:
+                start_cmd = f'f"uvicorn {self.config.asgi_application} --host 0.0.0.0 --port {{PORT}}"'
+            elif self.config.wsgi_application:
+                start_cmd = f'f"uvicorn {self.config.wsgi_application} --interface=wsgi --host 0.0.0.0 --port {{PORT}}"'
+        elif self.config.server == PythonServer.Hypercorn:
+            assert self.config.asgi_application, (
+                "No ASGI application found for Hypercorn"
+            )
+            start_cmd = (
+                f'f"hypercorn {self.config.asgi_application} --bind 0.0.0.0:{{PORT}}"'
+            )
+        elif self.config.framework == PythonFramework.Streamlit:
+            assert self.config.main_file, "No main file found for Streamlit"
+            main_file = self.config.main_file
+            start_cmd = f'f"streamlit run {main_file} --server.port {{PORT}} --server.address 0.0.0.0 --server.headless true"'
+        elif self.config.framework == PythonFramework.MCP:
+            main_file = self.config.main_file
+            assert main_file, "No main file found for MCP"
             contents = (self.path / main_file).read_text()
             if 'if __name__ == "__main__"' in contents or "mcp.run" in contents:
                 start_cmd = f'"python {main_file}"'
             else:
-                start_cmd = f'"python {{}}/bin/mcp run {main_file} --transport=streamable-http".format(venv["serve"])'
+                start_cmd = f'"python {{}}/bin/mcp run {main_file} --transport=streamable-http".format(venv.serve_path)'
 
-        elif self.framework == PythonFramework.FastHTML:
-            python_path = file_to_python_path(main_file)
-            path = f"{python_path}:app"
-            start_cmd = f'f"python -m uvicorn {path} --host 0.0.0.0 --port {{PORT}}"'
+        if not start_cmd:
+            if self.config.main_file:
+                start_cmd = f'"python {self.config.main_file}"'
 
-        else:
-            start_cmd = f'"python {main_file}"'
+        if self.config.framework == PythonFramework.Django:
+            if not start_cmd:
+                start_cmd = 'f"python manage.py runserver 0.0.0.0:{PORT}"'
+            migrate_cmd = '"python manage.py migrate"'
+            return {"start": start_cmd, "after_deploy": migrate_cmd}
 
-        return {"start": start_cmd}
+        if start_cmd:
+            return {"start": start_cmd}
+        else:
+            return {}
 
     def mounts(self) -> list[MountSpec]:
         if self.only_build:
@@ -486,24 +539,24 @@ class PythonProvider:
             return {}
         # For Django projects, generate an empty env dict to surface the field
         # in the Shipit file. Other Python projects omit it by default.
-        python_path = "f\"{app_serve_path}:{python_serve_site_packages_path}\""
-        main_file = self.main_file
+        python_path = 'f"{app_serve_path}:{python_serve_site_packages_path}"'
+        main_file = self.config.main_file
         if main_file and main_file.startswith("src/"):
-            python_path = "f\"{app_serve_path}:{app_serve_path}/src:{python_serve_site_packages_path}\""
+            python_path = 'f"{app_serve_path}:{app_serve_path}/src:{python_serve_site_packages_path}"'
         else:
-            python_path =  "f\"{app_serve_path}:{python_serve_site_packages_path}\""
-        env_vars = {"PYTHONPATH": python_path, "HOME": 'app["serve"]'}
-        if self.framework == PythonFramework.Streamlit:
+            python_path = 'f"{app_serve_path}:{python_serve_site_packages_path}"'
+        env_vars = {"PYTHONPATH": python_path, "HOME": 'app.serve_path'}
+        if self.config.framework == PythonFramework.Streamlit:
             env_vars["STREAMLIT_SERVER_HEADLESS"] = '"true"'
-        elif self.framework == PythonFramework.MCP:
+        elif self.config.framework == PythonFramework.MCP:
             env_vars["FASTMCP_HOST"] = '"0.0.0.0"'
-            env_vars["FASTMCP_PORT"] = 'PORT'
+            env_vars["FASTMCP_PORT"] = "PORT"
         return env_vars
-    
+
     def services(self) -> list[ServiceSpec]:
-        if self.database == DatabaseType.MySQL:
+        if self.config.database == DatabaseType.MySQL:
             return [ServiceSpec(name="database", provider="mysql")]
-        elif self.database == DatabaseType.PostgreSQL:
+        elif self.config.database == DatabaseType.PostgreSQL:
             return [ServiceSpec(name="database", provider="postgres")]
         return []
 
@@ -513,5 +566,8 @@ def format_app_import(asgi_application: str) -> str:
     return re.sub(r"\.([^.]+)$", r":\1", asgi_application)
 
 
-def file_to_python_path(path: str) -> str:
-    return path.rstrip(".py").replace("/", ".").replace("\\", ".")
+def file_to_python_path(path: Optional[str]) -> Optional[str]:
+    if not path:
+        return None
+    file = path.rstrip(".py").replace("/", ".").replace("\\", ".")
+    return f"{file}:app"