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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.5.1
+Version: 0.5.2
 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.5.2}/pyproject.toml

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

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

@@ -594,10 +594,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,
@@ -669,8 +669,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 +679,13 @@ class WasmerBuilder:
                 "PYTHONHOME": "/cpython",
             },
         },
+        "pandoc": {
+            "dependencies": {
+                "latest": "wasmer/pandoc@=0.0.1",
+                "3.5": "wasmer/pandoc@=0.0.1",
+            },
+            "scripts": {"pandoc"},
+        },
         "php": {
             "dependencies": {
                 "latest": "php/php-32@=8.3.2104",
@@ -773,7 +780,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 +849,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 +933,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 = {

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

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec
+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()

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

@@ -29,6 +29,7 @@ class PythonServer(Enum):
     # Gunicorn = "gunicorn"
     Daphne = "daphne"
 
+
 class DatabaseType(Enum):
     MySQL = "mysql"
     PostgreSQL = "postgresql"
@@ -41,8 +42,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 +60,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 +72,11 @@ class PythonProvider:
             "psycopg",
             "psycopg2",
             "psycopg-binary",
-            "psycopg2-binary"}
+            "psycopg2-binary",
+        }
         mysql_deps = {"mysqlclient", "pymysql", "mysql-connector-python", "aiomysql"}
         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 +86,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 +110,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 +190,7 @@ class PythonProvider:
                         break
             if not deps:
                 break
-        return initial_deps-deps
+        return initial_deps - deps
 
     @classmethod
     def name(cls) -> str:
@@ -178,7 +214,7 @@ class PythonProvider:
         return "python"
 
     def dependencies(self) -> list[DependencySpec]:
-        return [
+        deps = [
             DependencySpec(
                 "python",
                 env_var="SHIPIT_PYTHON_VERSION",
@@ -193,73 +229,131 @@ 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,
+                )
+            )
+        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 +368,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 +427,23 @@ 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 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.2/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.5.2"
+version_info = (0, 5, 2, "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)