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

shipit/generator.py

@@ -1,16 +1,13 @@
-from __future__ import annotations
-
+import json
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import List, Optional, Union
 
 from shipit.providers.base import (
     DependencySpec,
     Provider,
     ProviderPlan,
     DetectResult,
-    MountSpec,
-    VolumeSpec,
-    CustomCommands,
+    Config,
 )
 from shipit.providers.registry import providers as registry_providers
 
@@ -20,10 +17,10 @@ def _providers() -> list[type[Provider]]:
     return registry_providers()
 
 
-def detect_provider(path: Path, custom_commands: CustomCommands) -> Provider:
+def detect_provider(path: Path, base_config: Config) -> Provider:
     matches: list[tuple[type[Provider], DetectResult]] = []
     for provider_cls in _providers():
-        res = provider_cls.detect(path, custom_commands)
+        res = provider_cls.detect(path, base_config)
         if res:
             matches.append((provider_cls, res))
     if not matches:
@@ -64,41 +61,56 @@ def _emit_dependencies_declarations(
         declared.add(alias)
 
         version_var = None
-        architecture_var = None
-        if dep.env_var:
-            default = f' or "{dep.default_version}"' if dep.default_version else ""
-            version_key = alias + "_version"
-            lines.append(f'{version_key} = getenv("{dep.env_var}"){default}')
-            version_var = version_key
-        if dep.architecture_var:
-            architecture_key = alias + "_architecture"
-            lines.append(f'{architecture_key} = getenv("{dep.architecture_var}")')
-            architecture_var = architecture_key
+        architecture_env_var = None
+        if dep.var_name:
+            version_var = dep.var_name
+        if dep.architecture_var_name:
+            architecture_env_var = dep.architecture_var_name
         vars = [f'"{dep.name}"']
         if version_var:
             vars.append(version_var)
-        if architecture_var:
-            vars.append(f"architecture={architecture_var}")
+        if architecture_env_var:
+            vars.append(f"architecture={architecture_env_var}")
         lines.append(f"{alias} = dep({', '.join(vars)})")
 
     return "\n".join(lines), serve_vars, build_vars
 
 
-def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: Optional[str] = None) -> str:
+def load_provider(
+    path: Path, base_config: Config, use_provider: Optional[str] = None
+) -> type[Provider]:
     provider_cls = None
     if use_provider:
-        provider_cls = next((p for p in _providers() if p.name().lower() == use_provider.lower()), None)
+        provider_cls = next(
+            (p for p in _providers() if p.name().lower() == use_provider.lower()), None
+        )
     if not provider_cls:
-        provider_cls = detect_provider(path, custom_commands)
-    provider = provider_cls(path, custom_commands)
-
+        provider_cls = detect_provider(path, base_config)
+    return provider_cls
+
+
+def load_provider_config(
+    provider_cls: type[Provider],
+    path: Path,
+    base_config: Config,
+    config: Optional[Union[dict, str]] = None,
+) -> dict:
+    provider_config = provider_cls.load_config(path, base_config)
+    if config:
+        if isinstance(config, str):
+            config = json.loads(config)
+        assert isinstance(config, dict), "Config must be a dictionary, got %s" % type(config)
+        provider_config = provider_config.__class__.model_validate({**(provider_config.model_dump() | config)})
+    return provider_config
+
+
+def generate_shipit(path: Path, provider: Provider) -> str:
     default_serve_name = path.absolute().name
 
     # Collect parts
     plan = ProviderPlan(
         serve_name=provider.serve_name() or default_serve_name,
         provider=provider.name(),
-        platform=provider.platform(),
         mounts=provider.mounts(),
         volumes=provider.volumes(),
         declarations=provider.declarations(),
@@ -123,8 +135,12 @@ def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: O
 
     build_steps_block = ",\n".join([f"    {s}" for s in build_steps])
     deps_array = ", ".join(serve_dep_vars)
+
+    def format_command(k: str, v: str) -> str:
+        return f'    "{k}": {v}'
+
     commands_lines = ",\n".join(
-        [f'    "{k}": {v}.replace("$PORT", PORT)' for k, v in plan.commands.items()]
+        [format_command(k, v) for k, v in plan.commands.items()]
     )
     env_lines = None
     if plan.env is not None:
@@ -152,8 +168,9 @@ def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: O
         out.append(dep_block)
         out.append("")
 
-    for m in plan.mounts:
-        out.append(f'{m.name} = mount("{m.name}")')
+    if plan.mounts:
+        for m in plan.mounts:
+            out.append(f'{m.name} = mount("{m.name}")')
         out.append("")
 
     if plan.volumes:
@@ -168,18 +185,16 @@ def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: O
             )
         out.append("")
 
-    out.append('PORT = getenv("PORT") or "8080"')
-
     if plan.declarations:
         out.append(plan.declarations)
+        out.append("")
 
-    out.append("")
     out.append("serve(")
     out.append(f'  name="{plan.serve_name}",')
     out.append(f'  provider="{plan.provider}",')
     # If app is mounted for serve, set cwd to the app serve path
     if "app" in attach_serve_names:
-        out.append('  cwd=app["serve"],')
+        out.append('  cwd=app.serve_path,')
     out.append("  build=[")
     out.append(build_steps_block)
     out.append("  ],")
@@ -196,9 +211,12 @@ def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: O
             out.append("  env = {")
             out.append(env_lines)
             out.append("  },")
-    out.append("  commands = {")
-    out.append(commands_lines)
-    out.append("  },")
+    if commands_lines:
+        out.append("  commands = {")
+        out.append(commands_lines)
+        out.append("  },")
+    else:
+        out.append("  commands = {},")
     if plan.services:
         out.append("  services=[")
         for s in plan.services:

shipit/procfile.py

@@ -1,33 +1,8 @@
 # File forked from https://github.com/nickstenning/honcho/blob/main/honcho/environ.py
 # MIT License
-import os
 import re
-from collections import defaultdict, namedtuple
 
-PROCFILE_LINE = re.compile(r'^([A-Za-z0-9_-]+):\s*(.+)$')
-
-
-class Env(object):
-
-    def __init__(self, config):
-        self._c = config
-
-    @property
-    def port(self):
-        try:
-            return int(self._c['port'])
-        except ValueError:
-            raise ValueError(f"invalid value for port: '{self._c['port']}'")
-
-    @property
-    def procfile(self):
-        return os.path.join(self._c['app_root'], self._c['procfile'])
-
-    def load_procfile(self):
-        with open(self.procfile) as f:
-            content = f.read()
-
-        return parse_procfile(content)
+PROCFILE_LINE = re.compile(r"^([A-Za-z0-9_-]+):\s*(.+)$")
 
 
 class Procfile(object):
@@ -46,10 +21,11 @@ class Procfile(object):
         return p
 
     def add_process(self, name, command):
-        assert name not in self.processes, \
+        assert name not in self.processes, (
             "process names must be unique within a Procfile"
+        )
         self.processes[name] = command
-    
+
     def get_start_command(self):
         if "web" in self.processes:
             return self.processes["web"]
@@ -60,47 +36,3 @@ class Procfile(object):
         elif len(self.processes) == 1:
             return list(self.processes.values())[0]
         return None
-
-
-ProcessParams = namedtuple("ProcessParams", "name cmd quiet env")
-
-
-def expand_processes(processes, concurrency=None, env=None, quiet=None, port=None):
-    """
-    Get a list of the processes that need to be started given the specified
-    list of process types, concurrency, environment, quietness, and base port
-    number.
-
-    Returns a list of ProcessParams objects, which have `name`, `cmd`, `env`,
-    and `quiet` attributes, corresponding to the parameters to the constructor
-    of `honcho.process.Process`.
-    """
-    if env is not None and env.get("PORT") is not None:
-        port = int(env.get("PORT"))
-
-    if quiet is None:
-        quiet = []
-
-    con = defaultdict(lambda: 1)
-    if concurrency is not None:
-        con.update(concurrency)
-
-    out = []
-
-    for name, cmd in processes.items():
-        for i in range(con[name]):
-            n = "{0}.{1}".format(name, i + 1)
-            c = cmd
-            q = name in quiet
-            e = {'SHIPIT_PROCESS_NAME': n}
-            if env is not None:
-                e.update(env)
-            if port is not None:
-                e['PORT'] = str(port + i)
-
-            params = ProcessParams(n, c, q, e)
-            out.append(params)
-        if port is not None:
-            port += 100
-
-    return out

shipit/providers/base.py

@@ -1,8 +1,9 @@
-from __future__ import annotations
-
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Dict, List, Optional, Protocol, Literal
+from typing import Any, Dict, List, Optional, Protocol, Literal
+from shipit.procfile import Procfile
+from pydantic import BaseModel, Field
+from pydantic_settings import SettingsConfigDict
 
 
 @dataclass
@@ -11,24 +12,62 @@ class DetectResult:
     score: int  # Higher score wins when multiple providers match
 
 
-@dataclass
-class CustomCommands:
+class CustomCommands(BaseModel):
+    model_config = SettingsConfigDict(extra="ignore")
+
     install: Optional[str] = None
     build: Optional[str] = None
     start: Optional[str] = None
     after_deploy: Optional[str] = None
 
+    # if (path / "Dockerfile").exists():
+    #     # We get the start command from the Dockerfile
+    #     with open(path / "Dockerfile", "r") as f:
+    #         cmd = None
+    #         for line in f:
+    #             if line.startswith("CMD "):
+    #                 cmd = line[4:].strip()
+    #                 cmd = json.loads(cmd)
+    #         # We get the last command
+    #         if cmd:
+    #             if isinstance(cmd, list):
+    #                 cmd = " ".join(cmd)
+    #             custom_commands.start = cmd
+
+    def enrich_from_path(self, path: Path, use_procfile: bool = True) -> "CustomCommands":
+        if use_procfile:
+            procfile_path = path / "Procfile"
+            if procfile_path.exists():
+                try:
+                    procfile = Procfile.loads(procfile_path.read_text())
+                    self.start = procfile.get_start_command()
+                except Exception:
+                    pass
+        return self
+
+
+class Config(BaseModel):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    port: Optional[int] = 8080
+    commands: CustomCommands = Field(default_factory=CustomCommands)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.commands, name, None)
+
 
 class Provider(Protocol):
     def __init__(self, path: Path): ...
     @classmethod
     def name(cls) -> str: ...
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]: ...
-    def initialize(self) -> None: ...
+    def load_config(cls, path: Path, config: Config) -> Config: ...
+    @classmethod
+    def detect(
+        cls, path: Path, config: Config
+    ) -> Optional[DetectResult]: ...
     # Structured plan steps (no path args; use self.path)
     def serve_name(self) -> Optional[str]: ...
-    def platform(self) -> Optional[str]: ...
     def dependencies(self) -> list["DependencySpec"]: ...
     def declarations(self) -> Optional[str]: ...
     def build_steps(self) -> list[str]: ...
@@ -44,9 +83,9 @@ class Provider(Protocol):
 @dataclass
 class DependencySpec:
     name: str
-    env_var: Optional[str] = None
+    var_name: Optional[str] = None
     default_version: Optional[str] = None
-    architecture_var: Optional[str] = None
+    architecture_var_name: Optional[str] = None
     alias: Optional[str] = None  # Variable name in Shipit plan
     use_in_build: bool = False
     use_in_serve: bool = False

shipit/providers/hugo.py

@@ -1,19 +1,70 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec, VolumeSpec, CustomCommands, MountSpec
-from .staticfile import StaticFileProvider
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+    MountSpec,
+    Config,
+)
+from .staticfile import StaticFileProvider, StaticFileConfig
+from pydantic_settings import SettingsConfigDict
+import toml
+import json
+import yaml
+
+
+class HugoConfig(StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    hugo_version: Optional[str] = "0.149.0"
+    static_dir: Optional[str] = "public"
+
 
 class HugoProvider(StaticFileProvider):
+    def __init__(self, path: Path, config: HugoConfig):
+        super().__init__(path, config)
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> HugoConfig:
+        config = super().load_config(path, base_config)
+        if _exists(path, "hugo.toml"):
+            config_dict = toml.load(open(path / "hugo.toml"))
+        elif _exists(path, "hugo.json"):
+            config_dict = json.load(open(path / "hugo.json"))
+        elif _exists(path, "hugo.yaml"):
+            config_dict = yaml.safe_load(open(path / "hugo.yaml"))
+        elif _exists(path, "hugo.yml"):
+            config_dict = yaml.safe_load(open(path / "hugo.yml"))
+        else:
+            config_dict = {}
+        
+        config = HugoConfig(**config.model_dump())
+        if not config.static_dir:
+            hugo_publish_dir = None
+            if isinstance(config_dict, dict):
+                hugo_publish_dir = config_dict.get("publishDir")
+                if not hugo_publish_dir:
+                    # Use destination as fallback
+                    hugo_publish_dir = config_dict.get("destination")
+            hugo_publish_dir = hugo_publish_dir or "public"
+            assert isinstance(hugo_publish_dir, str), "publishDir in hugo config must be a string"
+            config.static_dir = hugo_publish_dir
+        return config
 
     @classmethod
     def name(cls) -> str:
         return "hugo"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(
+        cls, path: Path, config: Config
+    ) -> Optional[DetectResult]:
         if _exists(path, "hugo.toml", "hugo.json", "hugo.yaml", "hugo.yml"):
             return DetectResult(cls.name(), 80)
         if (
@@ -22,20 +73,18 @@ class HugoProvider(StaticFileProvider):
             and (_exists(path, "static") or _exists(path, "themes"))
         ):
             return DetectResult(cls.name(), 40)
+        if config.commands.build and config.commands.build.startswith("hugo "):
+            return DetectResult(cls.name(), 80)
         return None
 
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return "hugo"
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "hugo",
-                env_var="SHIPIT_HUGO_VERSION",
-                default_version="0.149.0",
+                var_name="config.hugo_version",
                 use_in_build=True,
             ),
             *super().dependencies(),
@@ -43,9 +92,10 @@ class HugoProvider(StaticFileProvider):
 
     def build_steps(self) -> list[str]:
         return [
-            'workdir(temp["build"])',
+            'workdir(temp.path)',
             'copy(".", ".", ignore=[".git"])',
-            'run("hugo build --destination={}".format(app["build"]), group="build")',
+            'run("hugo build", group="build")',
+            'run("cp -R {}/* {}/".format(config.static_dir, static_app.path))'
         ]
 
     def mounts(self) -> list[MountSpec]:

shipit/providers/jekyll.py

@@ -1,7 +1,6 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
+import yaml
 
 from .base import (
     DetectResult,
@@ -12,13 +11,46 @@ from .base import (
     ServiceSpec,
     VolumeSpec,
     CustomCommands,
+    Config,
 )
-from .staticfile import StaticFileProvider
+from .staticfile import StaticFileProvider, StaticFileConfig
+from pydantic_settings import SettingsConfigDict
+
+
+class JekyllConfig(StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    ruby_version: Optional[str] = "3.4.7"
+    jekyll_version: Optional[str] = "4.3.0"
+
+    static_dir: Optional[str] = "_site"
 
 
 class JekyllProvider(StaticFileProvider):
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+    def __init__(self, path: Path, config: JekyllConfig):
         self.path = path
+        self.config = config
+
+    @classmethod
+    def load_config(
+        cls, path: Path, base_config: Config
+    ) -> JekyllConfig:
+        config = super().load_config(path, base_config)
+        config = JekyllConfig(**config.model_dump())
+        if not config.static_dir:
+            jekyll_static_dir = None
+            if _exists(path, "_config.yml"):
+                config_dict = yaml.safe_load(open(path / "_config.yml"))
+            elif _exists(path, "_config.yaml"):
+                config_dict = yaml.safe_load(open(path / "_config.yaml"))
+            else:
+                config_dict = {}
+            if config_dict and isinstance(config_dict, dict):
+                jekyll_static_dir = config_dict.get("destination")
+            jekyll_static_dir = jekyll_static_dir or "_site"
+            assert isinstance(jekyll_static_dir, str), "destination in Jekyll config must be a string"
+            config.static_dir = jekyll_static_dir
+        return config
 
     @classmethod
     def name(cls) -> str:
@@ -26,45 +58,36 @@ class JekyllProvider(StaticFileProvider):
 
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
         if _exists(path, "_config.yml", "_config.yaml"):
             if _exists(path, "Gemfile"):
                 return DetectResult(cls.name(), 85)
             return DetectResult(cls.name(), 40)
-        if custom_commands.build and custom_commands.build.startswith("jekyll "):
+        if config.commands.build and config.commands.build.startswith("jekyll "):
             return DetectResult(cls.name(), 85)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return None
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "ruby",
-                env_var="SHIPIT_RUBY_VERSION",
+                var_name="config.ruby_version",
                 use_in_build=True,
                 use_in_serve=False,
             ),
             *super().dependencies(),
         ]
 
-    def declarations(self) -> Optional[str]:
-        return 'jekyll_version = getenv("SHIPIT_JEKYLL_VERSION") or "1.6.1"\n'
-
     def build_steps(self) -> list[str]:
         if _exists(self.path, "Gemfile"):
             install_deps = ["Gemfile"]
             install_deps_str = ", ".join([f'"{dep}"' for dep in install_deps])
             install_commands = [
-                f'run("bundle install", inputs=[{install_deps_str}], group="build")'
+                f'run("bundle install", inputs=[{install_deps_str}], group="install")'
             ]
             if _exists(self.path, "Gemfile.lock"):
                 install_commands = [
@@ -72,12 +95,16 @@ class JekyllProvider(StaticFileProvider):
                     *install_commands,
                 ]
         else:
-            install_commands = ['run("gem install jekyll", group="build")']
+            install_commands = [
+                'run("bundle init", group="install")',
+                'run("bundle add jekyll -v {}".format(config.jekyll_version), group="install")',
+            ]
         return [
-            'workdir(temp["build"])',
-            'copy(".", ignore=[".git"])',
+            'workdir(temp.path)',
             *install_commands,
-            'run("jekyll build --destination={}".format(app["build"]), outputs=["."], group="build")',
+            'copy(".", ignore=[".git"])',
+            'run("jekyll build", group="build")',
+            'run("cp -R {}/* {}/".format(config.static_dir, static_app.path))'
         ]
 
     def prepare_steps(self) -> Optional[list[str]]: