arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/commands/port/init.py

@@ -0,0 +1,82 @@
+from arkitekt_next.cli.constants import compile_dockerfiles
+from arkitekt_next.cli.types import Flavour
+from arkitekt_next.cli.utils import build_relative_dir
+import rich_click as click
+from click import Context
+from rich import get_console
+from arkitekt_next.utils import create_arkitekt_next_folder
+import yaml
+from rich.panel import Panel
+
+try:
+    pass
+except ImportError as e:
+    raise ImportError("Please install rekuest to use this feature") from e
+
+import os
+
+
+@click.command()
+@click.option("--flavour", "-f", help="The flavour to use", default="vanilla")
+@click.option(
+    "--description",
+    "-d",
+    help="The description for this flavour to use",
+    default="This is a vanilla flavour",
+)
+@click.option(
+    "--overwrite",
+    "-o",
+    help="Should we overwrite the existing Dockerfile?",
+    is_flag=True,
+    default=False,
+)
+@click.option(
+    "--template",
+    "-t",
+    help="The dockerfile template to use",
+    default="vanilla",
+    type=click.Choice(compile_dockerfiles()),
+)
+@click.pass_context
+def init(
+    ctx: Context, description: str, overwrite: bool, flavour: str, template: str
+) -> None:
+    """Runs the port wizard to generate a dockerfile to be used with port"""
+
+    arkitekt_next_folder = create_arkitekt_next_folder()
+
+    flavour_folder = os.path.join(arkitekt_next_folder, "flavours", flavour)
+    if os.path.exists(flavour_folder) and not overwrite:
+        raise click.ClickException(
+            f"The flavour {flavour} does already exist. Please initialize a different flavour or use the --overwrite flag"
+        )
+    else:
+        os.makedirs(flavour_folder, exist_ok=True)
+
+    config_file = os.path.join(flavour_folder, "config.yaml")
+    dockerfile = os.path.join(flavour_folder, "Dockerfile")
+
+    fl = Flavour(
+        selectors=[],
+        description=description,
+        dockerfile="Dockerfile",
+    )
+
+    with open(config_file, "w") as file:
+        yaml.dump(fl.dict(), file)
+
+    with open(build_relative_dir("dockerfiles", f"{template}.dockerfile"), "r") as f:
+        dockerfile_content = f.read()
+
+    with open(dockerfile, "w") as f:
+        f.write(dockerfile_content)
+
+    panel = Panel(
+        title=f"Created new flavour [bold]{flavour}[/bold]\n",
+        renderable="You can now edit the Dockerfile and add selectors to the config.yaml file\n"
+        + "To learn more about selectors and how flavours work, please visit [link=https://arkitekt_next.live]https://arkitekt_next.live[/link]",
+        style="green",
+    )
+
+    get_console().print(panel)

arkitekt_next/cli/commands/port/main.py

@@ -0,0 +1,31 @@
+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()
+@click.pass_context
+def port(ctx: Context) -> None:
+    """Deploy the arkitekt_next app with Port
+
+    The port deployer is an arkitekt_next plugin service, which allows you to deploy your arkitekt_next app to
+    any arkitekt_next instance and make it instantly available to the world. Port uses docker to containerize
+    your application and will publish it locally to your dockerhub account, and mark it locally as
+    deployed. People can then use your github repository to deploy your app to their arkitekt_next instance.
+
+    """
+
+    pass
+
+
+port.add_command(build, "build")
+port.add_command(init, "init")
+port.add_command(validate, "validate")
+port.add_command(publish, "publish")
+port.add_command(stage, "stage")
+port.add_command(wizard, "wizard")

arkitekt_next/cli/commands/port/publish.py

@@ -0,0 +1,102 @@
+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 rich.panel import Panel
+from arkitekt_next.cli.io import get_builds, get_deployments, generate_deployment
+from click import Context
+import uuid
+
+
+def check_if_build_already_deployed(build: Build) -> None:
+    """Checks if a manifest has already been deployed. If it has, it raises a click.ClickException.
+
+    Parameters
+    ----------
+    manifest : Manifest
+        THe manifest to check
+
+    Raises
+    ------
+    click.ClickException
+        A click exception if the manifest has already been deployed
+    """
+    config = get_deployments()
+    for deployment in config.deployments:
+        if (
+            deployment.manifest.identifier == build.manifest.identifier
+            and deployment.manifest.version == build.manifest.version
+            and deployment.flavour == build.flavour
+        ):
+            raise click.ClickException(
+                f"Deployment of {build.manifest.identifier}/{build.manifest.version} in the {build.flavour} flavour already exists."
+                + " You cannot deploy a build twice for the same version and flavour"
+            )
+
+
+@click.command()
+@click.option("--build", help="The build run to use", type=str, default=None)
+@click.option("--tag", help="The tag to use")
+@click.pass_context
+def publish(ctx: Context, build: str, tag: str) -> None:
+    """Deploys aa previous build to dockerhub"""
+
+    console = get_console(ctx)
+
+    deployment_run = str(uuid.uuid4())
+
+    builds = get_builds(selected_run=build)
+
+    if len(builds) == 0:
+        raise click.ClickException("Could not find any builds")
+
+    docker_info = subprocess.check_output(["docker", "info"]).decode("utf-8")
+    username = search_username_in_docker_info(docker_info)
+    if not username:
+        username = click.prompt(
+            "Could not find username in docker info. Please provide your docker username"
+        )
+
+    for build_id, build_model in builds.items():
+        if build_model.manifest.version == "dev":
+            raise click.ClickException(
+                "You cannot deploy a dev version. Please run `arkitekt_next version` first to set a version"
+            )
+
+        check_if_build_already_deployed(build_model)
+
+        tag = tag or click.prompt(
+            "The tag to use",
+            default=f"{username}/{build_model.manifest.identifier}:{build_model.manifest.version}-{build_model.flavour}",
+        )
+
+        md = Panel("Building Docker Container")
+        console.print(md)
+
+        docker_run = subprocess.run(["docker", "tag", build_model.build_id, tag])
+        if docker_run.returncode != 0:
+            raise click.ClickException("Could not retag docker container")
+
+        console.print(md)
+        docker_run = subprocess.run(["docker", "push", tag])
+        if docker_run.returncode != 0:
+            raise click.ClickException("Could not push docker container")
+
+        generate_deployment(
+            deployment_run,
+            build_model,
+            tag,
+            definitions=[],
+        )
+
+        md = Panel(
+            f"[bold green] Sucessfully pushed {tag} your plugin to dockerhub"
+            + "We have also generated a deployment file for you. "
+            + "Make sure to commit and push your changes to github to make them available to others.",
+            title="Yeah! Success",
+            title_align="center",
+            border_style="green",
+            style="green",
+        )
+        console.print(md)

arkitekt_next/cli/commands/port/stage.py

@@ -0,0 +1,59 @@
+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 arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+
+
+@click.command()
+@click.option("--build", help="The build to use", type=str, default=None)
+@click.option("--flavour", "-f", help="The flavour to use", default="vanilla")
+@click.option(
+    "--url", "-u", help="The fakts server to use", type=str, default=DEFAULT_ARKITEKT_URL
+)
+@click.option(
+    "--builder", help="The builder to use", type=str, default="arkitekt_next.builders.easy"
+)
+@click.pass_context
+def stage(ctx: Context, build: str, url: str, flavour: str, builder: str) -> None:
+    """Stages the latest Build for testing
+
+    Stages the current build for testing. This will create a temporary staged version
+    of the app that is run agains the local arkitekt_next instance. The builder will be changed
+    to the easy or provided builder to ensure that the app can be run headlessly
+
+
+    """
+
+    get_manifest(ctx)
+
+    builds = get_builds(build)
+
+    if len(builds) == 0:
+        raise click.ClickException("Could not find any builds")
+
+    if len(builds) > 1:
+        try:
+            build_model = next(
+                build for build in builds.values() if build.flavour == flavour
+            )
+        except StopIteration:
+            raise click.ClickException(
+                f"Could not find a build for flavour {flavour}. Please run `arkitekt_next port build` "
+                + "first to build the flavour"
+            )
+
+    else:
+        build_model = list(builds.values())[0]
+
+    command = build_model.build_docker_command() + build_model.build_arkitekt_next_command(
+        url
+    )
+
+    click.echo(f"Staging build {build} with flavour {flavour} against {url}")
+    click.echo("Running command: " + " ".join(command))
+
+    subprocess.run(" ".join(command), shell=True)
+
+    raise click.ClickException("Docker container exited")

arkitekt_next/cli/commands/port/utils.py

@@ -0,0 +1,47 @@
+from typing import Optional
+import os
+import yaml
+from arkitekt_next.cli.types import Flavour
+from arkitekt_next.cli.vars import get_console
+import rich_click as click
+
+
+def search_username_in_docker_info(docker_info: str):
+    for line in docker_info.splitlines():
+        if "Username" in line:
+            return line.split(":")[1].strip()
+
+
+def validate_flavours(flavours_folder: str, only: Optional[str]):
+    for dir_name in os.listdir(flavours_folder):
+        dir = os.path.join(flavours_folder, dir_name)
+        if os.path.isdir(dir):
+            if only is not None and only != 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)
+
+                except Exception as e:
+                    get_console().print_exception()
+                    raise click.ClickException(f"Flavour {dir_name} is invalid") from e
+
+                try:
+                    flavour.check_relative_paths(dir)
+                except Exception as e:
+                    raise click.ClickException(
+                        f"Relative Paths in Flavour {dir_name} are invalid. {e}"
+                    ) from e
+
+            else:
+                raise click.ClickException(
+                    f"Flavour {dir_name} is invalid. No config.yaml file found"
+                )
+
+        else:
+            print(
+                f"Found file {dir_name} in flavours folder. Not a valid flavour. Ignoring"
+            )

arkitekt_next/cli/commands/port/validate.py

@@ -0,0 +1,78 @@
+from arkitekt_next.cli.types import Flavour
+import rich_click as click
+from click import Context
+from rich import get_console
+from arkitekt_next.utils import create_arkitekt_next_folder
+import yaml
+
+
+try:
+    pass
+except ImportError as e:
+    raise ImportError("Please install rekuest to use this feature") from e
+
+import os
+
+
+@click.command()
+@click.option("--flavour", "-f", help="The flavour to use", default=None)
+@click.option(
+    "--description",
+    "-d",
+    help="The description for this flavour to use",
+    default="This is a vanilla flavour",
+)
+@click.option(
+    "--overwrite",
+    "-o",
+    help="Should we overwrite the existing Dockerfile?",
+    is_flag=True,
+    default=False,
+)
+@click.pass_context
+def validate(ctx: Context, description: str, overwrite: bool, flavour: str) -> None:
+    """Runs the port wizard to generate a dockerfile to be used with port"""
+
+    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"
+        )
+
+    for dir_name in os.listdir(flavours_folder):
+        dir = os.path.join(flavours_folder, dir_name)
+        if os.path.isdir(dir):
+            if flavour is not None and flavour != 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)
+
+                except Exception as e:
+                    get_console().print_exception()
+                    raise click.ClickException(f"Flavour {dir_name} is invalid") from e
+
+                try:
+                    flavour.check_relative_paths(dir)
+                except Exception as e:
+                    raise click.ClickException(
+                        f"Relative Paths in Flavour {dir_name} are invalid. {e}"
+                    ) from e
+
+            else:
+                raise click.ClickException(
+                    f"Flavour {dir_name} is invalid. No config.yaml file found"
+                )
+
+        else:
+            print(
+                f"Found file {dir_name} in flavours folder. Not a valid flavour. Ignoring"
+            )
+
+    click.echo("Ice Ice Baby! All flavours are valid")