arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/commands/manifest/inspect.py

@@ -0,0 +1,42 @@
+import rich_click as click
+from rich.table import Table
+from rich.panel import Panel
+from rich.console import Group
+from arkitekt_next.cli.vars import get_manifest, get_console
+
+
+@click.command()
+@click.pass_context
+def inspect(ctx) -> None:
+    """Inspect the [i]current[/i] manifest of this app
+
+    The manifest is used to describe the app and its rights (scopes) and requirements, to be run on the platform.
+    This manifest is used to authenticate the app with the platform establishing its scopes and requirements.
+
+
+    """
+    manifest = get_manifest(ctx)
+
+    table = Table.grid()
+    table.add_column()
+    table.add_column()
+    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),
+        title_align="center",
+        border_style="green",
+        style="white",
+    )
+
+    get_console(ctx).print(panel)

arkitekt_next/cli/commands/manifest/main.py

@@ -0,0 +1,25 @@
+import rich_click as click
+from .inspect import inspect
+from .scopes import scopes_group
+from .version import version
+from .wizard import wizard
+
+
+@click.group()
+@click.pass_context
+def manifest(ctx) -> None:
+    """Updates the manifest of this app
+
+    The manifest is used to describe the app and its rights (scopes) and requirements, to be run on the platform.
+    This manifest is used to authenticate the app with the platform establishing its scopes and requirements.
+
+
+
+    """
+    pass
+
+
+manifest.add_command(inspect, "inspect")
+manifest.add_command(scopes_group, "scopes")
+manifest.add_command(version, "version")
+manifest.add_command(wizard, "wizard")

arkitekt_next/cli/commands/manifest/scopes.py

@@ -0,0 +1,155 @@
+import rich_click as click
+from rich.table import Table
+from rich.panel import Panel
+from rich.console import Group
+from arkitekt_next.cli.vars import *
+from arkitekt_next.cli.constants import *
+from arkitekt_next.cli.io import write_manifest
+
+
+@click.group("scopes")
+@click.pass_context
+def scopes_group(ctx):
+    """Inspect, add and remove scopes to this arkitekt_next app
+
+    Scopes are rights that are granted to any arkitekt_next application, and correspond
+    to rights that enable feature when interacting with the platform. These scopes
+    provide another element of access control to the arkitekt_next platform, and describe
+    on top of the users rights, what the application is allowed to do.
+
+    For more information, please visit the [link=https://jhnnsrs.github.io/doks]https://jhnnsrs.github.io/doks[/link]
+
+
+    """
+    pass
+
+
+@scopes_group.command("add")
+@click.argument(
+    "SCOPE",
+    nargs=-1,
+    type=click.Choice(compile_scopes()),
+)
+@click.pass_context
+def add_scopes(ctx, scope):
+    """ "Acd scopes
+
+    Scopes are rights that are granted to any arkitekt_next application, and correspond
+    to rights that enable feature when interacting with the platform. These scopes
+    provide another element of access control to the arkitekt_next platform, and describe
+    on top of the users rights, what the application is allowed to do.
+
+    For more information, please visit the [link=https://jhnnsrs.github.io/doks]https://jhnnsrs.github.io/doks[/link]
+
+
+    """
+    if not scope:
+        raise click.ClickException("Please provide at least one scope")
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    if scope:
+        manifest.scopes = set(list(scope) + manifest.scopes)
+        write_manifest(manifest)
+        console.print(f"Scopes Updated to {manifest.scopes}")
+
+
+@scopes_group.command("remove")
+@click.argument(
+    "SCOPE",
+    nargs=-1,
+    type=click.Choice(compile_scopes()),
+)
+@click.pass_context
+def remove_scopes(ctx, scope):
+    """Remove scopes
+
+    Scopes are rights that are granted to any arkitekt_next application, and correspond
+    to rights that enable feature when interacting with the platform. These scopes
+    provide another element of access control to the arkitekt_next platform, and describe
+    on top of the users rights, what the application is allowed to do.
+
+    For more information, please visit the [link=https://jhnnsrs.github.io/doks]https://jhnnsrs.github.io/doks[/link]
+
+
+    """
+    if not scope:
+        raise click.ClickException("Please provide at least one scope to remove")
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    if scope:
+        manifest.scopes = set(manifest.scopes) - set(scope)
+        write_manifest(manifest)
+        console.print(f"Scopes Updated to {manifest.scopes}")
+
+
+@scopes_group.command("list")
+@click.pass_context
+def list_scopes(ctx):
+    """List all the [i] currently [/] active scopes
+
+    Scopes are rights that are granted to any arkitekt_next application, and correspond
+    to rights that enable feature when interacting with the platform. These scopes
+    provide another element of access control to the arkitekt_next platform, and describe
+    on top of the users rights, what the application is allowed to do.
+
+    For more information, please visit the [link=https://jhnnsrs.github.io/doks]https://jhnnsrs.github.io/doks[/link]
+
+
+    """
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    table = Table.grid()
+    table.padding = (0, 1)
+    table.add_column("Scope")
+    table.add_column("Description")
+    for scope in manifest.scopes:
+        table.add_row(scope, "TODO: This should be a description")
+
+    panel = Panel(
+        Group("[bold green]Demanded Scopes[/]", table),
+        title_align="center",
+        border_style="green",
+        style="white",
+    )
+
+    console.print(panel)
+
+
+@scopes_group.command("available")
+@click.pass_context
+def list_available(ctx):
+    """List all the [i] available [/]  scopes
+
+    Scopes are rights that are granted to any arkitekt_next application, and correspond
+    to rights that enable feature when interacting with the platform. These scopes
+    provide another element of access control to the arkitekt_next platform, and describe
+    on top of the users rights, what the application is allowed to do.
+
+    For more information, please visit the [link=https://jhnnsrs.github.io/doks]https://jhnnsrs.github.io/doks[/link]
+
+
+    """
+
+    console = get_console(ctx)
+
+    table = Table.grid()
+    table.padding = (0, 1)
+    table.add_column("Scope")
+    table.add_column("Description")
+    for scope in compile_scopes():
+        table.add_row(scope, "TODO")
+
+    panel = Panel(
+        Group("[bold green]Available Scopes[/]", table),
+        title_align="center",
+        border_style="green",
+        style="white",
+    )
+
+    console.print(panel)

arkitekt_next/cli/commands/manifest/version.py

@@ -0,0 +1,147 @@
+import rich_click as click
+from semver import (
+    parse as parse_semver,
+    bump_build,
+    bump_major,
+    bump_minor,
+    bump_patch,
+    bump_prerelease,
+)
+from arkitekt_next.cli.vars import get_console, get_manifest
+from arkitekt_next.cli.io import write_manifest
+
+
+@click.group()
+@click.pass_context
+def version(ctx):
+    """Updates the version of the arkitekt_next app
+
+    ArkitektNext manifests versioning follow [link=https://semver.org]semver[/link] and are used to version the app.
+    This provides an orthogonal way to version the app, beyond node versioning. The version is used to
+    track changes and to provide a way to update the app in the platform. For more information, please visit
+    [link=https://arkitekt_next.live]https://arkitekt_next.live[/link]
+
+    """
+
+
+@version.command("set")
+@click.argument("VERSION", type=str, required=False)
+@click.pass_context
+def set_version(ctx, version):
+    """Sets the version of the arkitekt_next app
+
+    When setting the version, you can either provide a version, or you can let the cli
+    prompt you for a version. If you provide a version, it will be parsed and validated
+    against semver. If you let the cli prompt you, it will try to parse the current version
+    and suggest a new version based on that. If the current version is not a valid semver
+    version, it will prompt you for a new version without a suggestion.
+    """
+
+    manifest = get_manifest(ctx)
+    get_console(ctx)
+    old_version = manifest.version
+
+    if not version:
+        try:
+            potential_new_version = bump_patch(old_version)
+        except Exception:
+            potential_new_version = None
+
+        new_version = click.prompt(
+            "Please provide a new version", default=potential_new_version, type=str
+        )
+        version = parse_semver(new_version)
+        version = new_version
+
+    manifest.version = version
+    write_manifest(manifest)
+    get_console().print(f"Version Updated from {old_version} to {version}")
+
+
+@version.command()
+@click.pass_context
+def patch(ctx):
+    """ "Patches the version of the arkitekt_next app
+
+
+    Patches the version of the arkitekt_next app, by bumping the patch number.
+    E.g. from 1.0.1 to 1.0.2. This should be used for bugfixes and small changes.
+    """
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    old_version = manifest.version
+    manifest.version = bump_patch(old_version)
+    write_manifest(manifest)
+    console.print(f"Version Updated from {old_version} to {manifest.version}")
+
+
+@version.command()
+@click.pass_context
+def minor(ctx):
+    """Bumps the minor version number of the arkitekt_next app
+
+    Patches the version of the arkitekt_next app, by bumping the minor number.
+    E.g. from 1.0.1 to 1.1.1. This should be used for new features, that
+    are backwards compatible.
+
+    """
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    old_version = manifest.version
+    manifest.version = bump_minor(old_version)
+    write_manifest(manifest)
+    console.print(f"Version Updated from {old_version} to {manifest.version}")
+
+
+@version.command()
+@click.pass_context
+def major(ctx):
+    """Increase the major version of the arkitekt_next app"
+
+    Patches the version of the arkitekt_next app, by bumping the major number.
+    E.g. from 1.0.1 to 2.0.1, This should be used for breaking changes,
+    that are not backwards compatible (e.g. deleting a node).
+
+    """
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    old_version = manifest.version
+    manifest.version = bump_major(old_version)
+    write_manifest(manifest)
+    console.print(f"Version Updated from {old_version} to {manifest.version}")
+
+
+@version.command()
+@click.pass_context
+def prerelease(ctx):
+    """Patches the prerelease of the arkitekt_next app"
+
+
+    Patches the version of the arkitekt_next app, by bumping the prerelease number.
+    E.g. from 1.0.1 to 1.0.1-alpha.1
+    """
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    old_version = manifest.version
+    manifest.version = bump_prerelease(old_version)
+    write_manifest(manifest)
+    console.print(f"Version Updated from {old_version} to {manifest.version}")
+
+
+@version.command("build")
+@click.pass_context
+def bump_build(ctx):
+    """Patches the build of the arkitekt_next app
+
+    Patches the version of the arkitekt_next app, by bumping the build number.
+    E.g. from 1.0.1 to 1.0.1+1, This should be used for changes that are not
+    reflected in the version number, but are still important to track (e.g. a
+    hotfix).
+
+    """
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    old_version = manifest.version
+    manifest.version = bump_build(old_version)
+    write_manifest(manifest)
+    console.print(f"Version Updated from {old_version} to {manifest.version}")

arkitekt_next/cli/commands/manifest/wizard.py

@@ -0,0 +1,94 @@
+import os
+import rich_click as click
+from arkitekt_next.cli.types import Requirement, Framework
+from rich.table import Table
+from rich.panel import Panel
+from rich.console import Group
+from arkitekt_next.cli.vars import get_console
+
+
+def check_dl_frameworks():
+    import site
+    import sys
+
+    site_packages = site.getsitepackages()
+    site_packages.append(sys.prefix)
+
+    frameworks = {
+        "tensorflow": Framework.TENSORFLOW,
+        "torch": Framework.PYTORCH,
+        "torchvision": Framework.PYTORCH,
+        "tensorflow-gpu": Framework.TENSORFLOW,
+        "torch-gpu": Framework.PYTORCH,
+        "torchvision-gpu": Framework.PYTORCH,
+    }
+
+    included_frameworks = set()
+
+    for key, value in frameworks.items():
+        for site_package in site_packages:
+            if os.path.exists(os.path.join(site_package, key)):
+                included_frameworks.add(value)
+
+    return included_frameworks
+
+
+def inspect_requirements(automatic=False):
+    """Inspect the requirements and
+
+
+    return a list of requirements and reasons.
+
+    Parameters
+    ----------
+    automatic : bool, optional
+        Should we automically add all of the requirements, by default False
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    requirements = []
+    reasons = []
+    frameworks = check_dl_frameworks()
+    if frameworks:
+        requirements.append(Requirement.GPU)
+        reasons.append(
+            "Deep learning framework detected ('{}')".format(", ".join(frameworks))
+        )
+
+    return requirements, reasons
+
+
+@click.command()
+@click.pass_context
+def wizard(ctx) -> None:
+    """Inspect the current project for requirements
+
+    Inspects the current project and provides a list of [i]suggest[/]ed requirements
+    that should be added to the manifest. You should run this command in the same
+    virtual environment as you are running your app, as it will detect the installed
+    packages and provide a list of requirements that should be added to the manifest.
+
+    """
+
+    console = get_console(ctx)
+    requirements, reasons = inspect_requirements()
+
+    table = Table.grid()
+    table.padding = (0, 4, 0, 0)
+    table.add_column("Requirement")
+    table.add_column("Reason")
+
+    for item in zip(requirements, reasons):
+        table.add_row(str(item[0].value), item[1])
+
+    panel = Panel(
+        Group("[bold green]Manifest[/]", table),
+        title_align="center",
+        border_style="green",
+        style="white",
+    )
+
+    console.print(panel)

arkitekt_next/cli/commands/port/build.py

@@ -0,0 +1,231 @@
+import rich_click as click
+from arkitekt_next.cli.vars import get_console, get_manifest
+import os
+from rich.panel import Panel
+import subprocess
+import uuid
+from arkitekt_next.cli.io import generate_build
+from click import Context
+from arkitekt_next.cli.types import Flavour, Inspection
+import yaml
+from typing import Dict, Optional
+import json
+from arkitekt_next.utils import create_arkitekt_next_folder
+
+
+class InspectionError(Exception):
+    pass
+
+
+def build_flavour(flavour_name: str, flavour: Flavour) -> str:
+    """Builds the flavour to docker
+
+    Parameters
+    ----------
+    flavour : Flavour
+        The flavour to build
+    manifest : Manifest
+        The manifest of the app
+
+    Returns
+    -------
+
+    tag: str
+        The tag of the built docker container
+
+    """
+
+    build_id = str(uuid.uuid4())
+
+    relative_dir = ".arkitekt_next/flavours/{}/".format(flavour_name)
+
+    command = flavour.generate_build_command(build_id, relative_dir)
+
+    docker_run = subprocess.run(" ".join(command), shell=True)
+
+    if docker_run.returncode != 0:
+        raise click.ClickException("Could not build docker container")
+
+    return build_id
+
+
+def inspect_docker_container(build_id: str) -> Inspection:
+    try:
+        # Run 'docker inspect' with the container ID or name
+        result = subprocess.run(
+            ["docker", "inspect", build_id],
+            stdout=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+
+        # Parse the JSON output
+        try:
+            container_info = json.loads(result.stdout)
+        except json.decoder.JSONDecodeError as e:
+            combined_error = result.stdout + result.stderr
+            raise InspectionError(
+                f"Could not decode JSON output of docker inspect. {combined_error}"
+            ) from e
+
+        # Extract size information
+        try:
+            size = container_info[0][
+                "Size"
+            ]  # Size of files that have been written to the filesystem
+            size_root_fs = container_info[0][
+                "Size"
+            ]  # Total size of all the files in the container
+        except IndexError as e:
+            raise InspectionError("Container not found or invalid JSON output") from e
+        except KeyError as e:
+            raise InspectionError(
+                "Size information not found in the container details"
+            ) from e
+
+        return size, size_root_fs
+    except subprocess.CalledProcessError as e:
+        combined_error = e.stdout + e.stderr
+        raise InspectionError(f"An error occurred: {e.stdout + e.stderr}") from e
+
+
+def inspect_definitions(build_id: str) -> Inspection:
+    try:
+        # Run 'docker inspect' with the container ID or name
+        result = subprocess.run(
+            ["docker", "run", build_id, "arkitekt_next", "inspect", "definitions"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True,
+        )
+
+        # Parse the JSON output
+
+        try:
+            output = json.loads(result.stdout)
+        except json.decoder.JSONDecodeError as e:
+            combined_error = result.stdout + result.stderr
+            raise InspectionError(
+                f"Could not decode JSON output of docker inspect. {combined_error}"
+            ) from e
+
+        if "definitions" not in output:
+            raise InspectionError(
+                "Container not found or invalid JSON output for definitions"
+            )
+
+        return output["definitions"]
+    except subprocess.CalledProcessError as e:
+        combined_error = e.stdout + e.stderr
+
+        if "No such command" in combined_error:
+            raise InspectionError(
+                "Could not find the command `arkitekt_next inspect definitions` in the container. Maybe"
+                + "you forgot to install arkitekt_next in the container? "
+            )
+
+        raise InspectionError(f"An error occurred: {e.stdout + e.stderr}") from e
+
+
+def inspect_build(build_id: str) -> Inspection:
+    size, size_root_fs = inspect_docker_container(build_id)
+    definitions = inspect_definitions(build_id)
+
+    return Inspection(size=size, definitions=definitions)
+
+
+def get_flavours(ctx: Context, select: Optional[str] = None) -> Dict[str, Flavour]:
+    """Gets the flavours for this app"""
+
+    arkitekt_next_folder = create_arkitekt_next_folder()
+
+    flavours_folder = os.path.join(arkitekt_next_folder, "flavours")
+
+    if not os.path.exists(flavours_folder):
+        raise click.ClickException(
+            "We could not find the flavours folder. Please run `arkitekt_next port init` first to create a buildable flavour"
+        )
+
+    flavours = {}
+
+    for dir_name in os.listdir(flavours_folder):
+        dir = os.path.join(flavours_folder, dir_name)
+        if os.path.isdir(dir):
+            if select is not None and select != dir_name:
+                continue
+
+            if os.path.exists(os.path.join(dir, "config.yaml")):
+                with open(os.path.join(dir, "config.yaml")) as f:
+                    valued = yaml.load(f, Loader=yaml.SafeLoader)
+                try:
+                    flavour = Flavour(**valued)
+                    flavour.check_relative_paths(dir)
+                    flavours[dir_name] = flavour
+
+                except Exception as e:
+                    get_console(ctx).print_exception()
+                    raise click.ClickException(
+                        f"Could not load flavour {dir_name} from {dir} ` config.yaml ` is invalid"
+                    ) from e
+
+    return flavours
+
+
+@click.command()
+@click.option(
+    "--flavour",
+    "-f",
+    help="The flavour to build. By default all flavours are being built",
+    default=None,
+    required=False,
+)
+@click.option(
+    "--no-inspect",
+    "-n",
+    help="Should we skip the inspection of the app?",
+    is_flag=True,
+    default=False,
+)
+@click.pass_context
+def build(ctx: Context, flavour: str, no_inspect: bool) -> None:
+    """Builds the arkitekt_next app to docker"""
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    flavours = get_flavours(ctx, select=flavour)
+
+    md = Panel(
+        "Starting to Build Containers for App [bold]{}[/bold]".format(
+            manifest.identifier
+        ),
+        subtitle="Selected Flavours: {}".format(", ".join(flavours.keys())),
+    )
+    console.print(md)
+
+    build_run = str(uuid.uuid4())
+
+    for key, flavour in flavours.items():
+        md = Panel(
+            "Building Flavour [bold]{}[/bold]".format(key),
+            subtitle="This may take a while...",
+            subtitle_align="right",
+        )
+        console.print(md)
+
+        build_tag = build_flavour(key, flavour)
+
+        inspection = None
+        if not no_inspect:
+            inspection = inspect_build(build_tag)
+
+        generate_build(build_run, build_tag, key, flavour, manifest, inspection)
+
+        md = Panel(
+            "Built Flavour [bold]{}[/bold]".format(key),
+            subtitle="Build ID: {}".format(build_run),
+            subtitle_align="right",
+        )
+
+        console.print(md)