arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/templates/filter.py

@@ -0,0 +1,26 @@
+from arkitekt_next_next import register
+from mikro.api.schema import RepresentationFragment, from_xarray
+
+
+@register
+def max_intensity_projection(image: RepresentationFragment) -> RepresentationFragment:
+    """Z-Project the Maximum Intensity
+
+    This function projects the maximum intensity of the input image
+    along the z-axis
+
+    Parameters
+    ----------
+    image : RepresentationFragment
+        The input image
+
+    Returns
+    -------
+    RepresentationFragment
+        The projected image
+
+    """
+    image = image.data.max(dim="z")
+    return from_xarray(
+        image, name="Max Intensity Projection" + image.name, origins=[image]
+    )

arkitekt_next/cli/templates/simple.py

@@ -0,0 +1,67 @@
+from arkitekt_next_next import register
+import time
+
+
+@register
+def generate_n_string(n: int = 10, timeout: int = 2) -> str:
+    """Generate N Strings
+
+    This function generates {{n}} strings with a {{timeout}} ms timeout between each string
+
+
+    Parameters
+    ----------
+    n : int, optional
+        The number of iterations, by default 10
+    timeout : int, optional
+        The timeout, by default 2
+
+    Returns
+    -------
+    str
+        A string with Hello {n}
+    """
+    for i in range(n):
+        print(i)
+        time.sleep(timeout)
+        yield f"Hello {i}"
+
+
+@register
+def append_world(hello: str) -> str:
+    """Append World
+
+    This function appends world to the input string
+
+    Parameters
+    ----------
+    hello : str
+        The input string
+
+    Returns
+    -------
+    str
+        {{hello}} World
+    """ """"""
+    return hello + " World"
+
+
+@register
+def print_string(input: str) -> str:
+    """Print String
+
+    This function prints the input string to
+    the console
+
+    Parameters
+    ----------
+    input : str
+        The input string
+
+     Returns
+    -------
+    str
+        The printed string
+    """
+    print(input)
+    return input

arkitekt_next/cli/texts.py

@@ -0,0 +1,20 @@
+WELCOME_MESSAGE = (
+    "Welcome to ArkitektNext. ArkitektNext is a bioimage analysis framework for building"
+    " beautiful and fast interfaces around your python code. It is buid on top of "
+    "composable packages like mikro, fluss and rekuest, which allow you to build simple"
+    " apps with ease."
+)
+
+
+LOGO = """
+            _    _ _       _    _   
+  __ _ _ __| | _(_) |_ ___| | _| |_ 
+ / _` | '__| |/ / | __/ _ \ |/ / __|
+| (_| | |  |   <| | ||  __/   <| |_ 
+ \__,_|_|  |_|\_\_|\__\___|_|\_\\__|
+                                                                   
+"""
+
+ERROR_EPILOGUE = (
+    "To find out more, visit [link=https://arkitekt_next.live]https://arkitekt_next.live[/link]"
+)

arkitekt_next/cli/types.py

@@ -0,0 +1,365 @@
+from pydantic import BaseModel, Field, validator
+import datetime
+from typing import List, Optional, Union, Literal
+from enum import Enum
+import semver
+import uuid
+from rekuest.api.schema import DefinitionInput
+from string import Formatter
+import os
+
+ALLOWED_BUILDER_KEYS = [
+    "tag",
+    "dockerfile",
+]
+
+
+class Framework(str, Enum):
+    """Do we support other frameworks?"""
+
+    VANILLA = "vanilla"
+    TENSORFLOW = "tensorflow"
+    PYTORCH = "pytorch"
+
+
+class Requirement(str, Enum):
+    """ """
+
+    GPU = "gpu"
+
+
+class Packager(str, Enum):
+    CONDA = "conda"
+    POETRY = "poetry"
+    PIP = "pip"
+
+
+class Manifest(BaseModel):
+    identifier: str
+    version: str
+    author: str
+    logo: Optional[str]
+    entrypoint: str
+    scopes: List[str]
+    requirements: List[Requirement] = Field(default_factory=list)
+    created_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
+
+    @validator("version", pre=True)
+    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 BaseSelector(BaseModel):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    required: bool = True
+
+    class Config:
+        extra = "forbid"
+
+    def build_docker_params(self) -> List[str]:
+        """Builds the docker params for this selector
+
+        Should return a list of strings that can be used as docker params
+        If the selector is not required, it should return an empty list
+
+        Returns
+        -------
+        List[str]
+            The docker params for this selector
+        """
+        return []
+
+    def build_arkitekt_next_params(self) -> List[str]:
+        """Builds the arkitekt_next params for this selector
+
+        Returns
+        -------
+        List[str]
+            The docker params for this selector
+        """
+        return []
+
+
+class RAMSelector(BaseSelector):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    type: Literal["ram"]
+    min: int
+
+
+class CPUSelector(BaseSelector):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    type: Literal["cpu"]
+    min: int
+    frequency: Optional[int] = None
+
+
+class CudaSelector(BaseSelector):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    type: Literal["cuda"]
+    frequency: Optional[int] = Field(default=None, description="The frequency in MHz")
+    memory: Optional[int] = Field(default=None, description="The memory in MB")
+    architecture: Optional[str] = Field(
+        default=None, description="The architecture of the GPU"
+    )
+    compute_capability: str = Field(
+        default="3.5", description="The minimum compute capability"
+    )
+    cuda_cores: Optional[int] = None
+    cuda_version: str = Field(default="10.2", description="The minimum cuda version")
+
+    def build_docker_params(self) -> List[str]:
+        """Builds the docker params for this selector
+
+        Should return a list of strings that can be used as docker params
+        If the selector is not required, it should return an empty list
+
+        Returns
+        -------
+        List[str]
+            The docker params for this selector
+        """
+        return [
+            "--gpus",
+            "all",
+        ]
+
+
+class RocmSelector(BaseSelector):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    type: Literal["rocm"]
+    min: int
+    frequency: Optional[int] = None
+    memory: Optional[int] = None
+    architecture: Optional[str] = None
+    compute_capability: Optional[str] = None
+    cuda_cores: Optional[int] = None
+    cuda_version: Optional[str] = None
+
+    def build_docker_params(self) -> List[str]:
+        """Builds the docker params for this selector"""
+
+        return [
+            "--device=/dev/kfd",
+            "--device=/dev/dri",
+            "--group-add",
+            "video",
+            "--cap-add=SYS_PTRACE",
+            "--security-opt",
+            "seccomp=unconfined",
+        ]
+
+
+class LabelSelector(BaseSelector):
+    """A selector is a way to describe a flavours preference for a
+    compute node. It contains the node_id, the selector and the flavour_id.
+    """
+
+    type: Literal["label"]
+    key: str
+    value: str
+
+
+class ServiceSelector(BaseSelector):
+    """A service selector is a way to describe a flavours preference for a
+    service. It contains the service_id,
+    """
+
+    type: Literal["service"]
+
+
+Selector = Union[
+    RAMSelector, CPUSelector, CudaSelector, RocmSelector, LabelSelector, ServiceSelector
+]
+
+
+class Inspection(BaseModel):
+    definitions: List[DefinitionInput]
+    size: int
+
+
+class Flavour(BaseModel):
+    selectors: List[Selector]
+    description: str = Field(default="")
+    dockerfile: str = Field(default="Dockerfile")
+    build_command: List[str] = Field(
+        default_factory=lambda: [
+            "docker",
+            "build",
+            "-t",
+            "{tag}",
+            "-f",
+            "{dockerfile}",
+            ".",
+        ]
+    )
+
+    @validator("build_command", each_item=True, always=True)
+    def check_valid_template_name(cls, v):
+        """Checks that the template name is valid"""
+        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 v
+
+    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 Deployment(BaseModel):
+    """A deployment is a Release of a Build.
+    It contains the build_id, the manifest, the builder, the definitions, the image and the deployed_at timestamp.
+
+
+
+    """
+
+    deployment_run: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        description="The unique identifier of the deployment run",
+    )
+
+    deployment_id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+        description="The unique identifier of the deployment",
+    )
+    manifest: Manifest = Field(description="The manifest of the app that was deployed")
+    selectors: List[Selector] = Field(
+        description="The selectors are used to place this image on the nodes",
+        default_factory=list,
+    )
+    flavour: str = Field(
+        description="The flavour that was used to build this deployment",
+        default="vanilla",
+    )
+    build_id: str = Field(
+        description="The build_id of the build that was deployed. Is referenced in the build.yaml file."
+    )
+    inspection: Optional[Inspection] = Field(
+        description="The inspection of the build that was deployed"
+    )
+    image: str = Field(
+        description="The docker image that was built for this deployment"
+    )
+    deployed_at: datetime.datetime = Field(
+        default_factory=datetime.datetime.now,
+        description="The timestamp of the deployment",
+    )
+
+
+class DeploymentsConfigFile(BaseModel):
+    """The ConfigFile is a pydantic model that represents the deployments.yaml file
+
+
+    Parameters
+    ----------
+    BaseModel : _type_
+        _description_
+    """
+
+    deployments: List[Deployment] = []
+    latest_deployment_run: Optional[str] = None
+
+
+class Build(BaseModel):
+    build_run: str
+    build_id: str
+    inspection: Optional[Inspection] = None
+    description: str = Field(default="")
+    selectors: List[Selector] = Field(default_factory=list)
+    flavour: str = Field(default="vanilla")
+    manifest: Manifest
+    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/cli/ui.py

@@ -0,0 +1,111 @@
+from rich.console import Group
+from rich.tree import Tree
+from rich.panel import Panel
+from arkitekt_next.apps import App
+from typing import MutableSet, Tuple, Any, Dict
+import os
+from .texts import LOGO, WELCOME_MESSAGE
+
+
+def construct_codegen_welcome_panel() -> Panel:
+    md = Panel(
+        LOGO
+        + "[white]"
+        + WELCOME_MESSAGE
+        + "\n\n"
+        + "[bold green]Let's setup your codegen environment",
+        title="Welcome to ArkitektNext Codegen",
+        title_align="center",
+        border_style="green",
+        style="green",
+    )
+    return md
+
+
+def construct_changes_group(changes: MutableSet[Tuple[Any, str]]) -> Group:
+    """Construct a rich panel group for the detected changes
+
+    This panel is displayed if the app has detected changes before
+    running the app. This can be caused by a change in the code or
+    a change in the environment (e.g. a new package was installed)"""
+    panel_header = "Detected changes\n"
+
+    actor_tree = Tree("Changes in", style="white not bold")
+    panel_group = Group(panel_header, actor_tree)
+    for change, path in changes:
+        actor_tree.add(os.path.normpath(path))
+
+    return panel_group
+
+
+def construct_app_group(app: App) -> Group:
+    """Construct a rich panel group for the app
+
+    It displays the registered definitions
+
+    Parameters
+    ----------
+    app : App
+        The app to construct the panel for
+
+    Returns
+    -------
+    Group
+        A rich panel group
+    """
+    panel_header = f"Running App \n\n{app.manifest.identifier}:{app.manifest.version}\n"
+
+    actor_tree = Tree("Registered Definitions", style="white not bold")
+    panel_group = Group(panel_header, actor_tree)
+
+    rekuest = app.services.get("rekuest")
+
+    for key, extension in rekuest.agent.extensions.items():
+        tree = actor_tree.add(key)
+        for template in extension.definition_registry.templates.values():
+            tree.add(template.interface + "-" + template.definition.name)
+
+
+    return panel_group
+
+
+def construct_leaking_group(variables: Dict[str, Any]) -> Group:
+    """Construct a rich panel group for the leaking variables
+
+    This panel is displayed if the app has leaking variables
+    and is therefore considered to be not safe to run
+    as an ArkitektNext plugin
+
+    Parameters
+    ----------
+    variables : Dict[str, Any]
+        The leaking variables
+
+    Returns
+    -------
+    Group
+        The rich panel group
+    """
+    panel_header = (
+        "Detected leaking Variables\n\n"
+        "[white]Your app is leaking variables. "
+        "Leaking variables can cause memory leaks and other issues."
+        "Please make sure you are not defining variables in the"
+        "global scope (outside of functions). "
+        "If you want to define constants please make them all UPPERCASE\n\n"
+    )
+
+    actor_tree = Tree("Leaking Variables", style="white not bold")
+    panel_group = Group(panel_header, actor_tree)
+    for key, value in variables.items():
+        actor_tree.add("key: " + key + " value: " + str(value))
+
+    return panel_group
+
+
+def construct_run_panel(app: App) -> Panel:
+    app_group = construct_app_group(app)
+
+    return Panel(
+        app_group, style="bold green", border_style="green", title="ArkitektNext Run"
+    )

arkitekt_next/cli/utils.py

@@ -0,0 +1,15 @@
+from importlib import import_module
+from typing import Callable
+from arkitekt_next.apps.types import App
+import os
+
+
+def import_builder(builder: str) -> Callable[..., App]:
+    module_path, function_name = builder.rsplit(".", 1)
+    module = import_module(module_path)
+    function = getattr(module, function_name)
+    return function
+
+
+def build_relative_dir(*paths):
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), *paths)

arkitekt_next/cli/validators.py

@@ -0,0 +1,17 @@
+import semver
+from .errors import ValidationError
+import rich_click as click
+
+
+def is_valid_semver(param: str, loaded=False) -> semver.VersionInfo:
+    """Checks if the param is a valid semver version and returns it as a semver object"""
+    if not semver.Version.is_valid(param):
+        if loaded:
+            raise click.ClickException(
+                "Manifest version incorrect, please update your manifest to a valid semver version  [link=https://semver.org]semver[/link]."
+            )
+
+        raise ValidationError(
+            "ArkitektNext versions need to follow semantic versioning. Please choose a correct format (examples: 0.0.0, 0.1.0, 0.0.0-alpha.1)"
+        )
+    return semver.Version.parse(param)

arkitekt_next/cli/vars.py

@@ -0,0 +1,39 @@
+import contextvars
+from rich.console import Console
+import rich_click as click
+from .types import Manifest
+
+
+current_console: contextvars.ContextVar[Console] = contextvars.ContextVar(
+    "current_console"
+)
+current_manifest: contextvars.ContextVar[Manifest] = contextvars.ContextVar(
+    "current_manifest"
+)
+
+
+def get_console(ctx) -> Console:
+    try:
+        return ctx.obj["console"]
+    except LookupError:
+        raise click.ClickException(
+            "No Current Console. Probably you are not running this command from the CLI."
+        )
+
+
+def set_console(ctx, console):
+    ctx.obj["console"] = console
+
+
+def get_manifest(ctx) -> Manifest:
+    """Get the current manifest or raise an exception."""
+    try:
+        return ctx.obj["manifest"]
+    except LookupError:
+        raise click.ClickException(
+            "No manifest found. You need to run the `arkitekt_next init` command first."
+        )
+
+
+def set_manifest(ctx, manifest):
+    ctx.obj["manifest"] = manifest

arkitekt_next/cli/versions/v1.yaml

@@ -0,0 +1 @@
+version: v1

arkitekt_next/constants.py

@@ -0,0 +1,6 @@
+REPO_URL = (
+    "https://arkitekt_next.live/repo.json"
+)
+
+
+DEFAULT_ARKITEKT_URL = "http://127.0.0.1:12000"