arkitekt-next 0.8.12__tar.gz → 0.8.14__tar.gz

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.8.12
+Version: 0.8.14
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -20,20 +20,20 @@ Requires-Dist: blok (>=0.0.19) ; (python_version >= "3.9" and python_version < "
 Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: dokker (>=1.0.0)
 Requires-Dist: fakts (>=1.0.0)
-Requires-Dist: fluss-next (>=0.1.86) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.87) ; extra == "all"
 Requires-Dist: herre (>=1.0.0)
-Requires-Dist: kabinet (>=0.1.25) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.26) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=1.0.0)
-Requires-Dist: lovekit (>=0.1.12) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
-Requires-Dist: mikro-next (>=0.1.41) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: lovekit (>=0.1.13) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: mikro-next (>=0.1.42) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
 Requires-Dist: namegenerator (>=1.0.6) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: netifaces (>=0.11.0) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
-Requires-Dist: reaktion-next (>=0.1.76) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.34) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: reaktion-next (>=0.1.77) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
+Requires-Dist: rekuest-next (>=0.2.35) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
 Requires-Dist: rich-click (>=1.6.1) ; extra == "cli" or extra == "all"
 Requires-Dist: semver (>=3.0.1) ; extra == "cli" or extra == "all"
 Requires-Dist: turms (>=0.6.0) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
-Requires-Dist: unlok-next (>=0.1.80) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: unlok-next (>=0.1.81) ; python_version >= "3.8" and python_version < "4.0"
 Requires-Dist: watchfiles (>=0.18.1) ; extra == "cli" or extra == "all"
 Description-Content-Type: text/markdown
 

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/base_models.py

@@ -6,6 +6,7 @@ from typing import List, Optional
 
 
 class Requirement(BaseModel):
+    key: str
     service: str
     """ The service is the service that will be used to fill the key, it will be used to find the correct instance. It needs to fullfill
     the reverse domain naming scheme"""
@@ -15,41 +16,48 @@ class Requirement(BaseModel):
     """ The description is a human readable description of the requirement. Will be show to the user when asking for the requirement."""
 
 
-def build_default_requirements() -> dict[str, Requirement]:
-    return {
-        "lok": Requirement(
+def build_default_requirements() -> List[Requirement]:
+    return [
+        Requirement(
+            key="lok",
             service="live.arkitekt_next.lok",
             description="An instance of ArkitektNext Lok to authenticate the user",
         ),
-        "rekuest": Requirement(
+        Requirement(
+            key="rekuest",
             service="live.arkitekt_next.rekuest",
             description="An instance of ArkitektNext Rekuest to assign to nodes",
         ),
-        "kabinet": Requirement(
+        Requirement(
+            key="kabinet",
             service="live.arkitekt_next.kabinet",
             description="An instance of ArkitektNext Kabinet to retrieve nodes from",
         ),
-        "mikro": Requirement(
+        Requirement(
+            key="mikro",
             service="live.arkitekt_next.mikro",
             description="An instance of ArkitektNext Mikro to make requests to the user's data",
             optional=True,
         ),
-        "fluss": Requirement(
+        Requirement(
+            key="fluss",
             service="live.arkitekt_next.fluss",
             description="An instance of ArkitektNext Fluss to make requests to the user's data",
             optional=False,
         ),
-        "port": Requirement(
+        Requirement(
+            key="port",
             service="live.arkitekt_next.port",
             description="An instance of ArkitektNext Fluss to make requests to the user's data",
             optional=True,
         ),
-        "datalayer": Requirement(
+        Requirement(
+            key="datalayer",
             service="live.arkitekt_next.datalayer",
             description="An instance of ArkitektNext Datalayer to make requests to the user's data",
             optional=False,
         ),
-    }
+    ]
 
 
 class Manifest(BaseModel):
@@ -75,7 +83,7 @@ class Manifest(BaseModel):
     """ Scopes that this app should request from the user """
     logo: Optional[str]
     """ A URL to the logo of the app TODO: We should enforce this to be a http URL as local paths won't work """
-    requirements: Optional[dict[str, Requirement]] = Field(
+    requirements: Optional[List[Requirement]] = Field(
         default_factory=build_default_requirements
     )
     """ Requirements that this app has TODO: What are the requirements? """

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/cli/commands/inspect/requirements.py

@@ -66,10 +66,10 @@ def requirements(
         logo=manifest.logo,
     )
 
-    x = {
-        key: item.model_dump(by_alias=True)
-        for key, item in app.manifest.requirements.items()
-    }
+    x = [
+        item.model_dump(by_alias=True)
+        for item in app.manifest.requirements
+    ]
     if machine_readable:
         print("--START_REQUIREMENTS--" + json.dumps(x) + "--END_REQUIREMENTS--")
 

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/cli/commands/kabinet/build.py

@@ -6,7 +6,7 @@ import subprocess
 import uuid
 from arkitekt_next.cli.io import generate_build
 from click import Context
-from arkitekt_next.cli.types import Flavour, Inspection
+from arkitekt_next.cli.types import Flavour, InspectionInput
 import yaml
 from typing import Dict, Optional
 import json
@@ -51,7 +51,7 @@ def build_flavour(flavour_name: str, flavour: Flavour) -> str:
     return build_id
 
 
-def inspect_docker_container(build_id: str) -> Inspection:
+def inspect_docker_container(build_id: str) -> InspectionInput:
     try:
         # Run 'docker inspect' with the container ID or name
         result = subprocess.run(
@@ -173,12 +173,12 @@ def inspect_requirements(build_id: str) -> Dict[str, Requirement]:
         raise InspectionError(f"An error occurred: {e.stdout + e.stderr}") from e
 
 
-def inspect_build(build_id: str) -> Inspection:
+def inspect_build(build_id: str) -> InspectionInput:
     size, size_root_fs = inspect_docker_container(build_id)
     templates = inspect_templates(build_id)
     requirements = inspect_requirements(build_id)
 
-    return Inspection(size=size, templates=templates, requirements=requirements)
+    return InspectionInput(size=size, templates=templates, requirements=requirements)
 
 
 def get_flavours(ctx: Context, select: Optional[str] = None) -> Dict[str, Flavour]:

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/cli/commands/kabinet/publish.py

@@ -23,11 +23,11 @@ def check_if_build_already_deployed(build: Build) -> None:
         A click exception if the manifest has already been deployed
     """
     config = get_deployments()
-    for deployment in config.deployments:
+    for deployment in config.app_images:
         if (
             deployment.manifest.identifier == build.manifest.identifier
             and deployment.manifest.version == build.manifest.version
-            and deployment.flavour == build.flavour
+            and deployment.flavour_name == build.flavour
         ):
             raise click.ClickException(
                 f"Deployment of {build.manifest.identifier}/{build.manifest.version} in the {build.flavour} flavour already exists."

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/cli/io.py

@@ -1,15 +1,17 @@
+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 (
-    Inspection,
     Manifest,
     Build,
     BuildsConfigFile,
-    Deployment,
     Flavour,
     DeploymentsConfigFile,
 )
+from kabinet.api.schema import InspectionInput, AppImageInput, DockerImageInput
+
 import yaml
 import json
 import rich_click as click
@@ -120,7 +122,7 @@ def generate_build(
     flavour_name: str,
     flavour: Flavour,
     manifest: Manifest,
-    inspection: Optional[Inspection],
+    inspection: Optional[InspectionInput],
 ) -> Build:
     """Generates a build from a builder, build_id and manifest
 
@@ -201,7 +203,7 @@ def generate_deployment(
     deployment_run: str,
     build: Build,
     image: str,
-) -> Deployment:
+) -> AppImageInput:
     """Generates a deployment from a build and an image
 
     Parameters
@@ -225,29 +227,29 @@ def generate_deployment(
 
     config_file = os.path.join(path, "deployments.yaml")
 
-    deployment = Deployment(
-        build_id=build.build_id,
+    app_image = AppImageInput(
+        appImageId=uuid.uuid4().hex,
         manifest=build.manifest,
-        flavour=build.flavour,
+        flavourName=build.flavour,
         selectors=build.selectors,
         inspection=build.inspection,
-        image=image,
+        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.deployments.append(deployment)
-            config.latest_deployment_run = deployment_run
+            config.app_images.append(app_image)
+            config.latest_app_image = app_image.app_image_id
     else:
-        config = DeploymentsConfigFile(deployments=[deployment])
-        config.latest_deployment_run = deployment_run
+        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.json(exclude_none=True, by_alias=True)),
+            json.loads(config.model_dump_json(exclude_none=True, by_alias=True)),
             file,
             sort_keys=True,
         )
 
-    return deployment
+    return app_image

arkitekt_next-0.8.14/arkitekt_next/cli/types.py

@@ -0,0 +1,182 @@
+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
+from rekuest_next.api.schema import TemplateInput
+
+ALLOWED_BUILDER_KEYS = [
+    "tag",
+    "dockerfile",
+    "package_version",
+]
+
+
+class Framework(str, Enum):
+    """Do we support other frameworks?"""
+
+    VANILLA = "vanilla"
+    TENSORFLOW = "tensorflow"
+    PYTORCH = "pytorch"
+
+
+class Packager(str, Enum):
+    CONDA = "conda"
+    POETRY = "poetry"
+    PIP = "pip"
+
+
+class Manifest(BaseModel):
+    identifier: str
+    version: str
+    author: str
+    logo: Optional[str] = None
+    entrypoint: str
+    scopes: List[str]
+    created_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
+
+    @field_validator("version", mode="before")
+    def version_must_be_semver(cls, v) -> str:
+        """Checks that the version is a valid semver version"""
+        if isinstance(v, str):
+            try:
+                semver.VersionInfo.parse(v)
+            except ValueError:
+                raise ValueError("Version must be a valid semver version")
+        return str(v)
+
+    def to_console_string(self):
+        return f"📦 {self.identifier} ({self.version}) by {self.author}"
+
+    def to_builder_dict(self):
+        return {
+            "identifier": self.identifier,
+            "version": self.version,
+            "logo": self.logo,
+            "scopes": self.scopes,
+        }
+
+    class Config:
+        validate_assignment = True
+
+
+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_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_url]
+
+        return base_command
+
+
+class BuildsConfigFile(BaseModel):
+    builds: List[Build] = Field(default_factory=list)
+    latest_build_run: Optional[str] = None

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/arkitekt_next/service_registry.py

@@ -19,12 +19,11 @@ class Registration(BaseModel):
     builder: Callable[[Herre, Fakts, Params], object]
 
 
-basic_requirements = {
-    "lok": Requirement(
+basic_requirements = [Requirement(
+        key="lok",
         service="live.arkitekt.lok",
         description="An instance of ArkitektNext Lok to authenticate the user",
-    ),
-}
+    )]
 
 
 class ServiceBuilderRegistry:
@@ -39,7 +38,7 @@ class ServiceBuilderRegistry:
         requirement: Requirement,
     ):
         self.service_builders[name] = service_builder
-        self.requirements[name] = requirement
+        self.requirements.append(requirement)
 
     def get(self, name):
         return self.services.get(name)

{arkitekt_next-0.8.12 → arkitekt_next-0.8.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arkitekt-next"
-version = "0.8.12"
+version = "0.8.14"
 description = "client for the arkitekt_next platform"
 authors = ["jhnnsrs <jhnnsrs@gmail.com>"]
 license = "MIT"
@@ -11,13 +11,13 @@ readme = "README.md"
 python = "^3.8"
 herre = ">=1.0.0"
 fakts = ">=1.0.0"
-mikro-next = { version = ">=0.1.41", python = "^3.10", optional = true }
-kabinet = { version = ">=0.1.25", optional = true,  python = "^3.9" }
-fluss-next = { version = ">=0.1.86", optional = true }
-reaktion-next= { version = ">=0.1.76", python = "^3.8", optional = true }
-rekuest-next= { version = ">=0.2.34", python = "^3.8", optional = true }
-unlok-next= { version = ">=0.1.80", python = "^3.8", optional = true }
-lovekit = { version = ">=0.1.12", python = "^3.10", optional = true }
+mikro-next = { version = ">=0.1.42", python = "^3.10", optional = true }
+kabinet = { version = ">=0.1.26", optional = true,  python = "^3.9" }
+fluss-next = { version = ">=0.1.87", optional = true }
+reaktion-next= { version = ">=0.1.77", python = "^3.8", optional = true }
+rekuest-next= { version = ">=0.2.35", python = "^3.8", optional = true }
+unlok-next= { version = ">=0.1.81", python = "^3.8", optional = true }
+lovekit = { version = ">=0.1.13", python = "^3.10", optional = true }
 rich-click = { version = ">=1.6.1", optional = true }
 watchfiles = { version = ">=0.18.1", optional = true }
 turms = { version = ">=0.6.0", python = "^3.9", optional = true }