shipit-cli 0.5.1__tar.gz → 0.6.0__tar.gz

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/PKG-INFO

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

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/pyproject.toml

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

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/cli.py

@@ -16,6 +16,7 @@ from typing import (
     Set,
     TypedDict,
     Union,
+    Literal,
     cast,
 )
 from shutil import copy, copytree, ignore_patterns
@@ -48,6 +49,12 @@ class Mount:
     serve_path: Path
 
 
+@dataclass
+class Service:
+    name: str
+    provider: Literal["postgres", "mysql", "redis"] # Right now we only support postgres and mysql
+
+
 @dataclass
 class Serve:
     name: str
@@ -61,6 +68,7 @@ class Serve:
     workers: Optional[List[str]] = None
     mounts: Optional[List[Mount]] = None
     env: Optional[Dict[str, str]] = None
+    services: Optional[List[Service]] = None
 
 
 @dataclass
@@ -594,10 +602,10 @@ class LocalBuilder:
                     commands.append(step.command)
                 elif isinstance(step, WorkdirStep):
                     commands.append(f"cd {step.path}")
-        content = "#!/bin/bash\n{body}".format(
-            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]"
         )
-        console.print(f"\n[bold]Created prepare.sh script to run before packaging ✅[/bold]")
         manifest_panel = Panel(
             Syntax(
                 content,
@@ -624,20 +632,31 @@ class LocalBuilder:
 
     def build_serve(self, serve: Serve) -> None:
         console.print("\n[bold]Building serve[/bold]")
-        build_path = self.get_build_path()
         serve_command_path = self.get_serve_path() / "bin"
         serve_command_path.mkdir(parents=True, exist_ok=False)
         path = self.get_path() / ".path"
-        # path_resolved = [str((build_path/path).resolve()) for path in path.read_text().split(os.pathsep) if path]
-        # path_text = os.pathsep.join(path_resolved)
         path_text = path.read_text()
         console.print(f"[bold]Serve Commands:[/bold]")
         for command in serve.commands:
             console.print(f"* {command}")
             command_path = serve_command_path / command
+            content = f"#!/bin/bash\ncd {serve.cwd}\nPATH={path_text}:$PATH {serve.commands[command]}"
             command_path.write_text(
-                f"#!/bin/bash\ncd {build_path}\nPATH={path_text}:$PATH {serve.commands[command]}"
+                content
+            )
+            manifest_panel = Panel(
+                Syntax(
+                    content.strip(),
+                    "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)
             command_path.chmod(0o755)
 
     def run_serve_command(self, command: str) -> None:
@@ -669,8 +688,8 @@ class WasmerBuilder:
     mapper: Dict[str, MapperItem] = {
         "python": {
             "dependencies": {
-                "latest": "wasmer/python-native@=0.1.11",
-                "3.13": "wasmer/python-native@=0.1.11",
+                "latest": "python/python@=3.13.1",
+                "3.13": "python/python@=3.13.1",
             },
             "scripts": {"python"},
             "aliases": {},
@@ -679,6 +698,20 @@ class WasmerBuilder:
                 "PYTHONHOME": "/cpython",
             },
         },
+        "pandoc": {
+            "dependencies": {
+                "latest": "wasmer/pandoc@=0.0.1",
+                "3.5": "wasmer/pandoc@=0.0.1",
+            },
+            "scripts": {"pandoc"},
+        },
+        "ffmpeg": {
+            "dependencies": {
+                "latest": "wasmer/ffmpeg@=1.0.5",
+                "N-111519": "wasmer/ffmpeg@=1.0.5",
+            },
+            "scripts": {"ffmpeg"},
+        },
         "php": {
             "dependencies": {
                 "latest": "php/php-32@=8.3.2104",
@@ -773,7 +806,9 @@ class WasmerBuilder:
 
         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]")
+        console.print(
+            f"\n[bold]Created prepare.sh script to run before packaging ✅[/bold]"
+        )
         manifest_panel = Panel(
             Syntax(
                 content,
@@ -840,12 +875,14 @@ class WasmerBuilder:
                         version
                     ].split("@")
                     dependencies.add(package_name, version)
-                    for script in self.mapper[dep.name]["scripts"]:
+                    scripts = self.mapper[dep.name].get("scripts") or []
+                    for script in scripts:
                         binaries[script] = {
                             "script": f"{package_name}:{script}",
                             "env": self.mapper[dep.name].get("env"),
                         }
-                    for alias, script in self.mapper[dep.name]["aliases"].items():
+                    aliases = self.mapper[dep.name].get("aliases") or {}
+                    for alias, script in aliases.items():
                         binaries[alias] = {
                             "script": f"{package_name}:{script}",
                             "env": self.mapper[dep.name].get("env"),
@@ -922,7 +959,9 @@ class WasmerBuilder:
 
         original_app_yaml_path = self.src_dir / "app.yaml"
         if original_app_yaml_path.exists():
-            console.print(f"[bold]Using original app.yaml found in source directory[/bold]")
+            console.print(
+                f"[bold]Using original app.yaml found in source directory[/bold]"
+            )
             yaml_config = yaml.safe_load(original_app_yaml_path.read_text())
         else:
             yaml_config = {
@@ -930,8 +969,46 @@ class WasmerBuilder:
             }
         # Update the app to use the new package
         yaml_config["package"] = "."
+        if serve.services:
+            capabilities = yaml_config.get("capabilities", {})
+            has_mysql = any(service.provider == "mysql" for service in serve.services)
+            # has_postgres = any(service.provider == "postgres" for service in serve.services)
+            # has_redis = any(service.provider == "redis" for service in serve.services)
+            if has_mysql:
+                capabilities["database"] = {
+                    "engine": "mysql"
+                }
+            yaml_config["capabilities"] = capabilities
+
+        if "after_deploy" in serve.commands:
+            jobs = yaml_config.get("jobs", [])
+            jobs.append({
+                "name": "after_deploy",
+                "trigger": "post-deployment",
+                "action": {
+                    "execute": {
+                        "command": "after_deploy"
+                    }
+                }
+            })
+            yaml_config["jobs"] = jobs
 
         app_yaml = yaml.dump(yaml_config)
+
+        console.print(f"\n[bold]Created app.yaml manifest ✅[/bold]")
+        app_yaml_panel = Panel(
+            Syntax(
+                app_yaml.strip(),
+                "yaml",
+                theme="monokai",
+                background_color="default",
+                line_numbers=True,
+            ),
+            box=box.SQUARE,
+            border_style="bright_black",
+            expand=False,
+        )
+        console.print(app_yaml_panel, markup=False, highlight=True)
         (self.wasmer_dir_path / "app.yaml").write_text(app_yaml)
 
         # self.inner_builder.build_serve(serve)
@@ -1013,12 +1090,17 @@ class Ctx:
         self.steps: List[Step] = []
         self.serves: Dict[str, Serve] = {}
         self.mounts: List[Mount] = []
+        self.services: Dict[str, Service] = {}
 
     def add_package(self, package: Package) -> str:
         index = f"{package.name}@{package.version}" if package.version else package.name
         self.packages[index] = package
         return f"ref:package:{index}"
 
+    def add_service(self, service: Service) -> str:
+        self.services[service.name] = service
+        return f"ref:service:{service.name}"
+
     def get_ref(self, index: str) -> Any:
         if index.startswith("ref:package:"):
             return self.packages[index[len("ref:package:") :]]
@@ -1030,6 +1112,8 @@ class Ctx:
             return self.steps[int(index[len("ref:step:") :])]
         elif index.startswith("ref:mount:"):
             return self.mounts[int(index[len("ref:mount:") :])]
+        elif index.startswith("ref:service:"):
+            return self.services[index[len("ref:service:") :]]
         else:
             raise Exception(f"Invalid reference: {index}")
 
@@ -1059,6 +1143,10 @@ class Ctx:
     def dep(self, name: str, version: Optional[str] = None) -> str:
         package = Package(name, version)
         return self.add_package(package)
+    
+    def service(self, name: str, provider: Literal["postgres", "mysql", "redis"]) -> str:
+        service = Service(name, provider)
+        return self.add_service(service)
 
     def serve(
         self,
@@ -1073,6 +1161,7 @@ class Ctx:
         workers: Optional[List[str]] = None,
         mounts: Optional[List[Mount]] = None,
         env: Optional[Dict[str, str]] = None,
+        services: Optional[List[str]] = None,
     ) -> str:
         build_refs = [cast(Step, r) for r in self.get_refs(build)]
         prepare_steps: Optional[List[PrepareStep]] = None
@@ -1097,6 +1186,7 @@ class Ctx:
             if mounts
             else None,
             env=env,
+            services=self.get_refs(services) if services else None,
         )
         return self.add_serve(serve)
 
@@ -1422,6 +1512,7 @@ def build(
     glb = sl.Globals.standard()
     mod = sl.Module()
 
+    mod.add_callable("service", ctx.service)
     mod.add_callable("getenv", ctx.getenv)
     mod.add_callable("dep", ctx.dep)
     mod.add_callable("serve", ctx.serve)

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/generator.py

@@ -89,6 +89,7 @@ def generate_shipit(path: Path) -> str:
         dependencies=provider.dependencies(),
         build_steps=provider.build_steps(),
         prepare=provider.prepare_steps(),
+        services=provider.services(),
         commands=provider.commands(),
         env=provider.env(),
     )
@@ -127,6 +128,10 @@ def generate_shipit(path: Path) -> str:
         out.append("")
     for m in plan.mounts:
         out.append(f"{m.name} = mount(\"{m.name}\")")
+    if plan.services:
+        for s in plan.services:
+            out.append(f"{s.name} = service(\n  name=\"{s.name}\",\n  provider=\"{s.provider}\"\n)")
+
     if plan.declarations:
         out.append(plan.declarations)
         out.append("")
@@ -157,6 +162,11 @@ def generate_shipit(path: Path) -> str:
     out.append("  commands = {")
     out.append(commands_lines)
     out.append("  },")
+    if plan.services:
+        out.append("  services=[")
+        for s in plan.services:
+            out.append(f"    {s.name},")
+        out.append("  ],")
     if mounts_block:
         out.append("  mounts=[")
         out.append(mounts_block)

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/base.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Dict, List, Optional, Protocol
+from typing import Dict, List, Optional, Protocol, Literal
 
 
 @dataclass
@@ -28,6 +28,7 @@ class Provider(Protocol):
     def prepare_steps(self) -> Optional[List[str]]: ...
     def commands(self) -> Dict[str, str]: ...
     def assets(self) -> Optional[Dict[str, str]]: ...
+    def services(self) -> List["ServiceSpec"]: ...
     def mounts(self) -> List["MountSpec"]: ...
     def env(self) -> Optional[Dict[str, str]]: ...
 
@@ -49,6 +50,12 @@ class MountSpec:
     attach_to_serve: bool = True
 
 
+@dataclass
+class ServiceSpec:
+    name: str
+    provider: Literal["postgres", "mysql", "redis"]
+
+
 @dataclass
 class ProviderPlan:
     serve_name: str
@@ -58,6 +65,7 @@ class ProviderPlan:
     dependencies: List[DependencySpec] = field(default_factory=list)
     build_steps: List[str] = field(default_factory=list)
     prepare: Optional[List[str]] = None
+    services: List[ServiceSpec] = field(default_factory=list)
     commands: Dict[str, str] = field(default_factory=dict)
     assets: Optional[Dict[str, str]] = None
     env: Optional[Dict[str, str]] = None

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/gatsby.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec, ServiceSpec
 
 
 class GatsbyProvider:
@@ -70,3 +70,6 @@ class GatsbyProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/hugo.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists
+from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec
 from .staticfile import StaticFileProvider
 
 class HugoProvider(StaticFileProvider):
@@ -45,3 +45,6 @@ class HugoProvider(StaticFileProvider):
             'copy(".", ".", ignore=[".git"])',
             'run("hugo build --destination={}".format(app["build"]), group="build")',
         ]
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/laravel.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
 
 
 class LaravelProvider:
@@ -81,3 +81,6 @@ class LaravelProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

shipit_cli-0.6.0/src/shipit/providers/mkdocs.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
+from .staticfile import StaticFileProvider
+from .python import PythonProvider
+
+
+class MkdocsProvider(StaticFileProvider):
+    def __init__(self, path: Path):
+        self.path = path
+        self.python_provider = PythonProvider(path, only_build=True, extra_dependencies={"mkdocs"})
+
+    @classmethod
+    def name(cls) -> str:
+        return "mkdocs"
+
+    @classmethod
+    def detect(cls, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
+            return DetectResult(cls.name(), 85)
+        return None
+
+    def initialize(self) -> None:
+        pass
+
+    def serve_name(self) -> str:
+        return self.path.name
+
+    def provider_kind(self) -> str:
+        return "mkdocs-site"
+
+    def dependencies(self) -> list[DependencySpec]:
+        return [
+            *self.python_provider.dependencies(),
+            *super().dependencies(),
+        ]
+
+    def declarations(self) -> Optional[str]:
+        return "mkdocs_version = getenv(\"SHIPIT_MKDOCS_VERSION\") or \"1.6.1\"\n" + (self.python_provider.declarations() or "")
+
+    def build_steps(self) -> list[str]:
+        return [
+            *self.python_provider.build_steps(),
+            "run(\"uv run mkdocs build --site-dir={}\".format(app[\"build\"]), outputs=[\".\"], group=\"build\")",
+        ]
+
+    def prepare_steps(self) -> Optional[list[str]]:
+        return self.python_provider.prepare_steps()
+
+    def assets(self) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self) -> list[MountSpec]:
+        return [MountSpec("app"), *self.python_provider.mounts()]
+
+    def env(self) -> Optional[Dict[str, str]]:
+        return self.python_provider.env()
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/node_static.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec, ServiceSpec
 
 
 class NodeStaticProvider:
@@ -71,3 +71,6 @@ class NodeStaticProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/php.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
 
 
 class PhpProvider:
@@ -80,3 +80,6 @@ class PhpProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/python.py

@@ -11,6 +11,7 @@ from .base import (
     Provider,
     _exists,
     MountSpec,
+    ServiceSpec,
 )
 
 
@@ -29,6 +30,7 @@ class PythonServer(Enum):
     # Gunicorn = "gunicorn"
     Daphne = "daphne"
 
+
 class DatabaseType(Enum):
     MySQL = "mysql"
     PostgreSQL = "postgresql"
@@ -41,8 +43,17 @@ class PythonProvider:
     extra_dependencies: Set[str]
     asgi_application: Optional[str] = None
     wsgi_application: Optional[str] = None
-
-    def __init__(self, path: Path):
+    uses_ffmpeg: bool = False
+    uses_pandoc: bool = False
+    only_build: bool = False
+    install_requires_all_files: bool = False
+
+    def __init__(
+        self,
+        path: Path,
+        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()
@@ -50,6 +61,11 @@ class PythonProvider:
             python_version = "3.13"
         self.default_python_version = python_version
         self.extra_dependencies = set()
+        self.only_build = only_build
+        self.extra_dependencies = extra_dependencies or set()
+
+        if self.only_build:
+            return
 
         pg_deps = {
             "asyncpg",
@@ -57,9 +73,11 @@ class PythonProvider:
             "psycopg",
             "psycopg2",
             "psycopg-binary",
-            "psycopg2-binary"}
-        mysql_deps = {"mysqlclient", "pymysql", "mysql-connector-python", "aiomysql"}
+            "psycopg2-binary",
+        }
+        mysql_deps = {"mysqlclient", "pymysql", "mysql-connector-python", "aiomysql", "asyncmy"}
         found_deps = self.check_deps(
+            "file://",  # This is not really a dependency, but as a way to check if the install script requires all files
             "streamlit",
             "django",
             "mcp",
@@ -69,11 +87,17 @@ class PythonProvider:
             "daphne",
             "hypercorn",
             "uvicorn",
+            # Other
+            "ffmpeg",
+            "pandoc",
             # "gunicorn",
             *mysql_deps,
             *pg_deps,
         )
 
+        if "file://" in found_deps:
+            self.install_requires_all_files = True
+
         # ASGI/WSGI Server
         if "uvicorn" in found_deps:
             server = PythonServer.Uvicorn
@@ -87,17 +111,30 @@ class PythonProvider:
             server = None
         self.server = server
 
+        if "ffmpeg" in found_deps:
+            self.uses_ffmpeg = True
+        if "pandoc" in found_deps:
+            self.uses_pandoc = True
+
         # 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"))
+            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())
+                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())
+                    wsgi_match = re.search(
+                        r"WSGI_APPLICATION\s*=\s*['\"](.*)['\"]",
+                        settings_file.read_text(),
+                    )
                     if wsgi_match:
                         self.wsgi_application = wsgi_match.group(1)
 
@@ -154,7 +191,7 @@ class PythonProvider:
                         break
             if not deps:
                 break
-        return initial_deps-deps
+        return initial_deps - deps
 
     @classmethod
     def name(cls) -> str:
@@ -178,7 +215,7 @@ class PythonProvider:
         return "python"
 
     def dependencies(self) -> list[DependencySpec]:
-        return [
+        deps = [
             DependencySpec(
                 "python",
                 env_var="SHIPIT_PYTHON_VERSION",
@@ -193,73 +230,140 @@ class PythonProvider:
                 use_in_build=True,
             ),
         ]
+        if self.uses_pandoc:
+            deps.append(
+                DependencySpec(
+                    "pandoc",
+                    env_var="SHIPIT_PANDOC_VERSION",
+                    use_in_build=False,
+                    use_in_serve=True,
+                )
+            )
+        if self.uses_ffmpeg:
+            deps.append(
+                DependencySpec(
+                    "ffmpeg",
+                    env_var="SHIPIT_FFMPEG_VERSION",
+                    use_in_build=False,
+                    use_in_serve=True,
+                )
+            )
+        return deps
 
     def declarations(self) -> Optional[str]:
+        if self.only_build:
+            return (
+                'cross_platform = getenv("SHIPIT_PYTHON_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_path = \"{}/lib/python{}/site-packages\".format(venv[\"serve\"], python_version)\n"
+            '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 not self.only_build:
+            steps = ['workdir(app["build"])']
+        else:
+            steps = []
 
         extra_deps = ", ".join([f"{dep}" for dep in self.extra_dependencies])
+        has_requirements = _exists(self.path, "requirements.txt")
         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])
+            inputs = ", ".join([f'"{input}"' for input in input_files])
             steps += [
-                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
-                f"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",
+                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"])',
+                'copy(".", ".")' if self.install_requires_all_files else None,
+                f'run(f"uv sync --compile --python python{{python_version}} --no-managed-python{extra_args}", inputs=[{inputs}], group="install")',
+                'copy("pyproject.toml", "pyproject.toml")'
+                if not self.install_requires_all_files
+                else None,
+                f'run("uv add {extra_deps}", group="install")' if extra_deps else None,
             ]
-        if _exists(self.path, "requirements.txt"):
+            if not self.only_build:
+                steps += [
+                    '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',
+                ]
+        elif has_requirements or extra_deps:
             steps += [
-                "env(UV_PROJECT_ENVIRONMENT=local_venv[\"build\"] if cross_platform else venv[\"build\"])",
-                "run(f\"uv init --no-workspace --no-managed-python --python python{python_version}\", inputs=[], outputs=[\"uv.lock\"], group=\"install\")",
-                f"run(\"uv add -r requirements.txt {extra_deps}\", 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",
-                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",
+                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"])',
+                'run(f"uv init --no-workspace --no-managed-python --python python{python_version}", inputs=[], outputs=["uv.lock"], group="install")',
+                'copy(".", ".")' if self.install_requires_all_files else None,
             ]
+            if has_requirements:
+                steps += [
+                    f'run("uv add -r requirements.txt {extra_deps}", inputs=["requirements.txt"], group="install")',
+                ]
+            else:
+                steps += [
+                    f'run("uv add {extra_deps}", group="install")',
+                ]
+            if not self.only_build:
+                steps += [
+                    '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',
+                    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',
+                ]
 
         steps += [
-            "path((local_venv[\"build\"] if cross_platform else venv[\"build\"]) + \"/bin\")",
-            "copy(\".\", \".\", ignore=[\".venv\", \".git\", \"__pycache__\"])",
+            'path((local_venv["build"] if cross_platform else venv["build"]) + "/bin")',
+            'copy(".", ".", ignore=[".venv", ".git", "__pycache__"])',
         ]
         if self.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["build"])) if cross_platform else None',
+                'run("cp {}/bin/mcp {}/bin/mcp".format(local_venv["build"], venv["build"])) if cross_platform else None',
             ]
         return list(filter(None, steps))
 
     def prepare_steps(self) -> Optional[list[str]]:
+        if self.only_build:
+            return []
         return [
-            'run("echo \\\"Precompiling Python code...\\\"") if precompile_python else None',
+            '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("echo \\"Precompiling package code...\\"") if precompile_python else None',
             'run("python -m compileall -o 2 {}".format(app["serve"])) if precompile_python else None',
         ]
 
+    def get_main_file(self) -> Optional[str]:
+        paths_to_try = ["main.py", "app.py", "streamlit_app.py", "Home.py", "*_app.py"]
+        for path in paths_to_try:
+            if "*" in path:
+                continue  # This is for the glob finder
+            if _exists(self.path, path):
+                return path
+            if _exists(self.path, f"src/{path}"):
+                return f"src/{path}"
+        for path in paths_to_try:
+            try:
+                found_path = next(self.path.glob(f"**/{path}.py"))
+            except StopIteration:
+                found_path = None
+            if found_path:
+                return found_path.relative_to(self.path)
+        return None
+
     def 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'"python -m daphne {asgi_application} --bind 0.0.0.0 --port 8000"'
+                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)
@@ -274,73 +378,58 @@ class PythonProvider:
                 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"
-            
+
+        main_file = self.get_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'"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\\\")\'"'
+                start_cmd = '"python -c \'print(\\"No start command detected, please provide a start command manually\\")\'"'
             return {"start": start_cmd}
+
         elif self.framework == PythonFramework.Streamlit:
-            if _exists(self.path, "main.py"):
-                path = "main.py"
-            elif _exists(self.path, "src/main.py"):
-                path = "src/main.py"
-            if _exists(self.path, "app.py"):
-                path = "app.py"
-            elif _exists(self.path, "src/app.py"):
-                path = "src/app.py"
-            elif _exists(self.path, "src/streamlit_app.py"):
-                path = "src/streamlit_app.py"
-            elif _exists(self.path, "streamlit_app.py"):
-                path = "streamlit_app.py"
-            elif _exists(self.path, "Home.py"):
-                path = "Home.py"
-
-            start_cmd = f'"python -m streamlit run {path} --server.port 8000 --server.address 0.0.0.0 --server.headless true"'
+            start_cmd = f'"python -m streamlit run {main_file} --server.port 8000 --server.address 0.0.0.0 --server.headless true"'
+
         elif self.framework == PythonFramework.Flask:
-            if _exists(self.path, "main.py"):
-                path = "main:app"
-            if _exists(self.path, "app.py"):
-                path = "app:app"
-            elif _exists(self.path, "src/main.py"):
-                path = "src.main:app"
+            python_path = file_to_python_path(main_file)
+            path = f"{python_path}:app"
             # start_cmd = f'"python -m flask --app {path} run --debug --host 0.0.0.0 --port 8000"'
             start_cmd = f'"python -m uvicorn {path} --interface=wsgi --host 0.0.0.0 --port 8000"'
+
         elif self.framework == PythonFramework.MCP:
-            if _exists(self.path, "main.py"):
-                path = "main.py"
+            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:
-                path = next(self.path.glob( "**/main.py"))
-                if path:
-                    path = path.relative_to(self.path)
-                else:
-                    path = "main.py"
-            start_cmd = f'"python {{}}/bin/mcp run {path} --transport=streamable-http".format(venv[\"serve\"])'
+                start_cmd = f'"python {{}}/bin/mcp run {main_file} --transport=streamable-http".format(venv["serve"])'
+
         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"
+            python_path = file_to_python_path(main_file)
+            path = f"{python_path}: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\\\")\'"'
+            start_cmd = f'"python {main_file}"'
+
         return {"start": start_cmd}
 
     def assets(self) -> Optional[Dict[str, str]]:
         return None
 
     def mounts(self) -> list[MountSpec]:
+        if self.only_build:
+            return [
+                MountSpec("local_venv", attach_to_serve=False),
+            ]
         return [
             MountSpec("app"),
             MountSpec("venv"),
@@ -348,19 +437,30 @@ class PythonProvider:
         ]
 
     def env(self) -> Optional[Dict[str, str]]:
+        if self.only_build:
+            return {}
         # For Django projects, generate an empty env dict to surface the field
         # in the Shipit file. Other Python projects omit it by default.
-        env_vars = {
-            "PYTHONPATH": "python_serve_path",
-            "HOME": "app[\"serve\"]"
-        }
+        env_vars = {"PYTHONPATH": "python_serve_path", "HOME": 'app["serve"]'}
         if self.framework == PythonFramework.Streamlit:
             env_vars["STREAMLIT_SERVER_HEADLESS"] = '"true"'
         elif self.framework == PythonFramework.MCP:
-            env_vars["FASTMCP_HOST"] = "\"0.0.0.0\""
-            env_vars["FASTMCP_PORT"] = "\"8000\""
+            env_vars["FASTMCP_HOST"] = '"0.0.0.0"'
+            env_vars["FASTMCP_PORT"] = '"8000"'
         return env_vars
+    
+    def services(self) -> list[ServiceSpec]:
+        if self.database == DatabaseType.MySQL:
+            return [ServiceSpec(name="database", provider="mysql")]
+        elif self.database == DatabaseType.PostgreSQL:
+            return [ServiceSpec(name="database", provider="postgres")]
+        return []
+
 
 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)
+
+
+def file_to_python_path(path: str) -> str:
+    return path.rstrip(".py").replace("/", ".").replace("\\", ".")

{shipit_cli-0.5.1 → shipit_cli-0.6.0}/src/shipit/providers/staticfile.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
 
 
 class StaticFileProvider:
@@ -68,3 +68,6 @@ class StaticFileProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
+    
+    def services(self) -> list[ServiceSpec]:
+        return []

shipit_cli-0.6.0/src/shipit/version.py

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

shipit_cli-0.5.1/src/shipit/providers/mkdocs.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Dict, Optional
-
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
-
-
-class MkdocsProvider:
-    def __init__(self, path: Path):
-        self.path = path
-    @classmethod
-    def name(cls) -> str:
-        return "mkdocs"
-
-    @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
-        if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
-            return DetectResult(cls.name(), 85)
-        return None
-
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def provider_kind(self) -> str:
-        return "mkdocs-site"
-
-    def dependencies(self) -> list[DependencySpec]:
-        return [
-            DependencySpec(
-                "python",
-                env_var="SHIPIT_PYTHON_VERSION",
-                default_version="3.13",
-                use_in_build=True,
-            ),
-            DependencySpec(
-                "uv",
-                env_var="SHIPIT_UV_VERSION",
-                default_version="0.8.15",
-                use_in_build=True,
-            ),
-            DependencySpec(
-                "static-web-server",
-                env_var="SHIPIT_SWS_VERSION",
-                default_version="2.38.0",
-                use_in_serve=True,
-            ),
-        ]
-
-    def declarations(self) -> Optional[str]:
-        return None
-
-    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\")",
-                "run(f\"uv add -r requirements.txt\", inputs=[\"requirements.txt\"], outputs=[\".venv\"], group=\"install\")",
-            ]
-        else:
-            install_lines = [
-                "mkdocs_version = getenv(\"SHIPIT_MKDOCS_VERSION\") or \"1.6.1\"",
-                "run(\"uv init --no-managed-python\", inputs=[], outputs=[\".venv\"], group=\"install\")",
-                "run(f\"uv add mkdocs=={mkdocs_version}\", group=\"install\")",
-            ]
-        return [
-            *install_lines,
-            "copy(\".\", \".\", ignore=[\".venv\", \".git\", \"__pycache__\"])",
-            "run(\"uv run mkdocs build --site-dir={}\".format(app[\"build\"]), outputs=[\".\"], group=\"build\")",
-        ]
-
-    def prepare_steps(self) -> Optional[list[str]]:
-        return None
-
-    def commands(self) -> Dict[str, str]:
-        return {"start": '"static-web-server --root /app"'}
-
-    def assets(self) -> Optional[Dict[str, str]]:
-        return None
-
-    def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
-
-    def env(self) -> Optional[Dict[str, str]]:
-        return None

shipit_cli-0.5.1/src/shipit/version.py

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