arkitekt-next 0.8.60__py3-none-any.whl → 0.8.62__py3-none-any.whl

arkitekt_next/cli/commands/kabinet/build.py

@@ -5,9 +5,9 @@ import os
 from rich.panel import Panel
 import subprocess
 import uuid
-from arkitekt_next.cli.io import generate_build
+from .io import generate_build
 from click import Context
-from arkitekt_next.cli.types import Flavour, InspectionInput
+from .types import Flavour, InspectionInput
 import yaml
 from typing import Dict, Optional
 import json
@@ -93,24 +93,38 @@ def inspect_docker_container(build_id: str) -> InspectionInput:
         raise InspectionError(f"An error occurred: {e.stdout + e.stderr}") from e
 
 
-def inspect_templates(build_id: str, url:str) -> list[TemplateInput]:
+def inspect_templates(build_id: str, url: str) -> list[TemplateInput]:
     try:
         # Run 'docker inspect' with the container ID or name
         process = subprocess.Popen(
-            " ".join(["docker", "run", "-it", "--network", "host",  build_id, "arkitekt-next", "inspect", "templates", "-mr", "--url", url]),
+            " ".join(
+                [
+                    "docker",
+                    "run",
+                    "-it",
+                    "--network",
+                    "host",
+                    build_id,
+                    "arkitekt-next",
+                    "inspect",
+                    "templates",
+                    "-mr",
+                    "--url",
+                    url,
+                ]
+            ),
             shell=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
 
-
         lines = []
-            # Poll process for new output until finished
+        # Poll process for new output until finished
         while True:
             if process.poll() is not None:
                 break
             nextline = process.stdout.readline()
-            
+
             lines.append(nextline.decode("utf-8"))
             sys.stdout.buffer.write(nextline)
             sys.stdout.flush()
@@ -267,7 +281,13 @@ def get_flavours(ctx: Context, select: Optional[str] = None) -> Dict[str, Flavou
     default=DEFAULT_ARKITEKT_URL,
 )
 @click.pass_context
-def build(ctx: Context, flavour: str, no_inspect: bool, tag: str = None, url: str = DEFAULT_ARKITEKT_URL) -> None:
+def build(
+    ctx: Context,
+    flavour: str,
+    no_inspect: bool,
+    tag: str = None,
+    url: str = DEFAULT_ARKITEKT_URL,
+) -> None:
     """Builds the arkitekt_next app to docker"""
 
     manifest = get_manifest(ctx)
@@ -298,7 +318,6 @@ def build(ctx: Context, flavour: str, no_inspect: bool, tag: str = None, url: st
         if tag:
             subprocess.run(["docker", "tag", build_tag, tag], check=True)
 
-
         inspection = None
         if not no_inspect:
             inspection = inspect_build(build_tag, url)

arkitekt_next/cli/commands/kabinet/init.py

@@ -1,6 +1,6 @@
 from importlib.metadata import version
 from arkitekt_next.cli.constants import compile_dockerfiles
-from arkitekt_next.cli.types import Flavour
+from .types import Flavour
 from arkitekt_next.cli.utils import build_relative_dir
 import rich_click as click
 from click import Context

arkitekt_next/cli/commands/kabinet/io.py

@@ -0,0 +1,206 @@
+import datetime
+import uuid
+from arkitekt_next.utils import create_arkitekt_next_folder
+import os
+from typing import Optional, List, Dict
+from arkitekt_next.cli.types import (
+    Manifest,
+)
+
+from .types import (
+    Build,
+    BuildsConfigFile,
+    Flavour,
+    DeploymentsConfigFile,
+)
+from kabinet.api.schema import (
+    InspectionInput,
+    AppImageInput,
+    DockerImageInput,
+    ManifestInput,
+)
+
+import yaml
+import json
+import rich_click as click
+
+
+def get_builds(selected_run: Optional[str] = None) -> Dict[str, Build]:
+    """Will load the builds.yaml file and return a dictionary of builds
+
+    Will load the builds.yaml file and return a dictionary of builds
+    where the key is the build_id and the value is the build object.
+
+
+    Returns
+    -------
+    Dict[str, Build]
+        The loaded builds
+    """
+    path = create_arkitekt_next_folder()
+    config_file = os.path.join(path, "builds.yaml")
+
+    builds = {}
+
+    if os.path.exists(config_file):
+        with open(config_file, "r") as file:
+            config = BuildsConfigFile(**yaml.safe_load(file))
+
+            # We will only return the builds from the selected run
+            selected_run = selected_run or config.latest_build_run
+
+            builds = {
+                build.build_id: build
+                for build in config.builds
+                if build.build_run == selected_run
+            }
+            return builds
+    else:
+        raise click.ClickException(
+            "Could not find any builds. Please run `arkitekt_next port build` first"
+        )
+
+
+def manifest_to_input(manifest: Manifest) -> ManifestInput:
+
+    return ManifestInput(**manifest.model_dump(by_alias=True))
+
+
+def generate_build(
+    build_run: str,
+    build_id: str,
+    flavour_name: str,
+    flavour: Flavour,
+    manifest: Manifest,
+    inspection: Optional[InspectionInput],
+) -> Build:
+    """Generates a build from a builder, build_id and manifest
+
+    Will generate a build from a builder, build_id and manifest,
+    and write it to the builds.yaml file in the arkitekt_next folder.
+
+
+    Parameters
+    ----------
+    builder : str
+        The builder that was used to build the build
+    build_id : str
+        The build_id of the build
+    manifest : Manifest
+        The manifest of the build
+
+    Returns
+    -------
+    Build
+        The generated build
+    """
+    path = create_arkitekt_next_folder()
+
+    config_file = os.path.join(path, "builds.yaml")
+
+    build = Build(
+        manifest=manifest_to_input(manifest),
+        flavour=flavour_name,
+        selectors=flavour.selectors,
+        build_id=build_id,
+        build_run=build_run,
+        description=flavour.description,
+        inspection=inspection,
+    )
+
+    if os.path.exists(config_file):
+        with open(config_file, "r") as file:
+            config = BuildsConfigFile(**yaml.safe_load(file))
+            config.builds.append(build)
+            config.latest_build_run = build_run
+    else:
+        config = BuildsConfigFile(builds=[build], latest_build_run=build_run)
+
+    with open(config_file, "w") as file:
+        yaml.safe_dump(
+            json.loads(
+                config.json(exclude_none=True, exclude_unset=True, by_alias=True)
+            ),
+            file,
+            sort_keys=True,
+        )
+
+    return build
+
+
+def get_deployments() -> DeploymentsConfigFile:
+    """Loads the deployments.yaml file and returns the deployments
+
+    Will load the deployments.yaml file and return the deployments
+    as a DeploymentsConfigFile object. If no deployments.yaml file
+    exists, it will return an empty DeploymentsConfigFile object.
+
+    Returns
+    -------
+    DeploymentsConfigFile
+        The deployments as a DeploymentsConfigFile object
+    """
+    path = create_arkitekt_next_folder()
+    config_file = os.path.join(path, "deployments.yaml")
+    if os.path.exists(config_file):
+        with open(config_file, "r") as file:
+            return DeploymentsConfigFile(**yaml.safe_load(file))
+    else:
+        return DeploymentsConfigFile()
+
+
+def generate_deployment(
+    deployment_run: str,
+    build: Build,
+    image: str,
+) -> AppImageInput:
+    """Generates a deployment from a build and an image
+
+    Parameters
+    ----------
+
+    build : Build
+        The build that should be deployed
+    image: str
+        The image that is the actuall deployment of the build
+    with_definitions: bool:
+        Should we generated and inspect definitions to bundle with
+        the deployment?
+
+    Returns:
+    ------
+    Deployment: The created deployment
+
+    """
+
+    path = create_arkitekt_next_folder()
+
+    config_file = os.path.join(path, "deployments.yaml")
+
+    app_image = AppImageInput(
+        appImageId=uuid.uuid4().hex,
+        manifest=build.manifest,
+        flavourName=build.flavour,
+        selectors=build.selectors,
+        inspection=build.inspection,
+        image=DockerImageInput(imageString=image, buildAt=datetime.datetime.now()),
+    )
+
+    if os.path.exists(config_file):
+        with open(config_file, "r") as file:
+            config = DeploymentsConfigFile(**yaml.safe_load(file))
+            config.app_images.append(app_image)
+            config.latest_app_image = app_image.app_image_id
+    else:
+        config = DeploymentsConfigFile(
+            app_images=[app_image], latest_app_image=app_image.app_image_id
+        )
+
+    with open(config_file, "w") as file:
+        yaml.safe_dump(
+            json.loads(config.model_dump_json(exclude_none=True, by_alias=True)),
+            file,
+            sort_keys=True,
+        )
+
+    return app_image

arkitekt_next/cli/commands/kabinet/main.py

@@ -1,14 +1,34 @@
 import rich_click as click
-from .build import build
-from .publish import publish
-from .stage import stage
-from .init import init
-from .wizard import wizard
-from .validate import validate
+
 from click import Context
 
 
-@click.group()
+class LazyGroup(click.Group):
+
+    def list_commands(self, ctx):
+        return ["build", "init", "validate", "publish", "stage", "wizard"]
+
+    def get_command(self, ctx, cmd_name):
+        from .build import build
+        from .publish import publish
+        from .stage import stage
+        from .init import init
+        from .validate import validate
+
+        if cmd_name == "build":
+            return build
+        elif cmd_name == "init":
+            return init
+        elif cmd_name == "validate":
+            return validate
+        elif cmd_name == "publish":
+            return publish
+        elif cmd_name == "stage":
+            return stage
+        return None
+
+
+@click.group(cls=LazyGroup)
 @click.pass_context
 def kabinet(ctx: Context) -> None:
     """Deploy the arkitekt_next app with Port
@@ -21,11 +41,3 @@ def kabinet(ctx: Context) -> None:
     """
 
     pass
-
-
-kabinet.add_command(build, "build")
-kabinet.add_command(init, "init")
-kabinet.add_command(validate, "validate")
-kabinet.add_command(publish, "publish")
-kabinet.add_command(stage, "stage")
-kabinet.add_command(wizard, "wizard")

arkitekt_next/cli/commands/kabinet/publish.py

@@ -2,9 +2,9 @@ import rich_click as click
 import subprocess
 from .utils import search_username_in_docker_info
 from arkitekt_next.cli.vars import get_console
-from arkitekt_next.cli.types import Build
+from .types import Build
 from rich.panel import Panel
-from arkitekt_next.cli.io import get_builds, get_deployments, generate_deployment
+from .io import get_builds, get_deployments, generate_deployment
 from click import Context
 import uuid
 

arkitekt_next/cli/commands/kabinet/stage.py

@@ -2,7 +2,7 @@ import rich_click as click
 from arkitekt_next.cli.vars import get_manifest
 import subprocess
 from click import Context
-from arkitekt_next.cli.io import get_builds
+from .io import get_builds
 from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
 
 

arkitekt_next/cli/commands/kabinet/types.py

@@ -0,0 +1,139 @@
+from importlib.metadata import version
+from pydantic import BaseModel, Field, field_validator
+import datetime
+from typing import List, Optional, Union, Literal, Dict
+from enum import Enum
+import semver
+import uuid
+from arkitekt_next.base_models import Requirement
+from string import Formatter
+import os
+
+from kabinet.api.schema import (
+    AppImageInput,
+    InspectionInput,
+    SelectorInput,
+    ManifestInput,
+)
+
+ALLOWED_BUILDER_KEYS = [
+    "tag",
+    "dockerfile",
+    "package_version",
+]
+
+
+class SelectorType(str, Enum):
+    RAM = "ram"
+    CPU = "cpu"
+    GPU = "gpu"
+    LABEL = "label"
+
+
+class Flavour(BaseModel):
+    selectors: List[SelectorInput]
+    description: str = Field(default="")
+    dockerfile: str = Field(default="Dockerfile")
+    build_command: List[str] = Field(
+        default_factory=lambda: [
+            "docker",
+            "build",
+            "-t",
+            "{tag}",
+            "-f",
+            "{dockerfile}",
+            ".",
+        ]
+    )
+
+    @field_validator("build_command", mode="before")
+    def check_valid_template_name(cls, value):
+        """Checks that the build_command templates are valid"""
+
+        for v in value:
+            for literal_text, field_name, format_spec, conversion in Formatter().parse(
+                v
+            ):
+                if field_name is not None:
+                    assert (
+                        field_name in ALLOWED_BUILDER_KEYS
+                    ), f"Invalid template key {field_name}. Allowed keys are {ALLOWED_BUILDER_KEYS}"
+
+        return value
+
+    def generate_build_command(self, tag: str, relative_dir: str):
+        """Generates the build command for this flavour"""
+
+        dockerfile = os.path.join(relative_dir, self.dockerfile)
+
+        return [v.format(tag=tag, dockerfile=dockerfile) for v in self.build_command]
+
+    def check_relative_paths(self, flavour_folder: str):
+        """Checks that the paths are relative to the flavour folder"""
+
+        dockerfile_path = os.path.join(flavour_folder, self.dockerfile)
+
+        if not os.path.exists(dockerfile_path):
+            raise Exception(
+                f"Could not find Dockerfile {self.dockerfile} in flavour {flavour_folder}"
+            )
+
+
+class DeploymentsConfigFile(BaseModel):
+    """The ConfigFile is a pydantic model that represents the deployments.yaml file
+
+
+    Parameters
+    ----------
+    BaseModel : _type_
+        _description_
+    """
+
+    app_images: List[AppImageInput] = []
+    latest_app_image: Optional[str] = None
+
+
+class Build(BaseModel):
+    build_run: str
+    build_id: str
+    inspection: Optional[InspectionInput] = None
+    description: str = Field(default="")
+    selectors: List[SelectorInput] = Field(default_factory=list)
+    flavour: str = Field(default="vanilla")
+    manifest: ManifestInput
+    build_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
+    base_docker_command: List[str] = Field(
+        default_factory=lambda: ["docker", "run", "-it", "--net", "host"]
+    )
+    base_arkitekt_next_command: List[str] = Field(
+        default_factory=lambda: ["arkitekt-next", "run", "prod", "--headless"]
+    )
+
+    def build_docker_command(self) -> List[str]:
+        """Builds the docker command for this build"""
+
+        base_command = self.base_docker_command
+
+        for selector in self.selectors:
+            base_command = base_command + selector.build_docker_params()
+
+        base_command = base_command + [self.build_id]
+
+        return base_command
+
+    def build_arkitekt_next_command(self, fakts_next_url: str):
+        """Builds the arkitekt_next command for this build"""
+
+        base_command = self.base_arkitekt_next_command
+
+        for selector in self.selectors:
+            base_command = base_command + selector.build_arkitekt_next_params()
+
+        base_command = base_command + ["--url", fakts_next_url]
+
+        return base_command
+
+
+class BuildsConfigFile(BaseModel):
+    builds: List[Build] = Field(default_factory=list)
+    latest_build_run: Optional[str] = None

arkitekt_next/cli/commands/kabinet/utils.py

@@ -2,7 +2,7 @@ import logging
 from typing import Optional
 import os
 import yaml
-from arkitekt_next.cli.types import Flavour
+from .types import Flavour
 from arkitekt_next.cli.vars import get_console
 import rich_click as click
 

arkitekt_next/cli/commands/kabinet/validate.py

@@ -1,4 +1,4 @@
-from arkitekt_next.cli.types import Flavour
+from .types import Flavour
 import rich_click as click
 from click import Context
 from rich import get_console

arkitekt_next/cli/commands/manifest/inspect.py

@@ -17,20 +17,15 @@ def inspect(ctx) -> None:
     """
     manifest = get_manifest(ctx)
 
-    table = Table.grid()
-    table.add_column()
+    table = Table.grid(padding=(0, 3))
     table.add_column()
+    table.add_column(justify="right")
     table.add_row("Identifier", manifest.identifier)
     table.add_row("Version", manifest.version)
     table.add_row("Author", manifest.author)
     table.add_row("Logo", manifest.logo or "-")
     table.add_row("Entrypoint", manifest.entrypoint)
     table.add_row("Scopes", ", ".join(manifest.scopes) if manifest.scopes else "-")
-    table.add_row(
-        "Requirements",
-        ", ".join(manifest.requirements) if manifest.requirements else "-",
-    )
-    table.add_row("Created at", str(manifest.created_at.strftime("%Y/%m/%d %H:%M")))
 
     panel = Panel(
         Group("[bold green]Manifest[/]", table),

arkitekt_next/cli/commands/manifest/main.py

@@ -2,7 +2,6 @@ import rich_click as click
 from .inspect import inspect
 from .scopes import scopes_group
 from .version import version
-from .wizard import wizard
 
 
 @click.group()
@@ -22,4 +21,3 @@ def manifest(ctx) -> None:
 manifest.add_command(inspect, "inspect")
 manifest.add_command(scopes_group, "scopes")
 manifest.add_command(version, "version")
-manifest.add_command(wizard, "wizard")