arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/constants.py

@@ -0,0 +1,63 @@
+from .types import Requirement
+from .utils import build_relative_dir
+from typing import List
+import os
+
+
+def compile_scopes() -> List[str]:
+    """Compile all available scopes"""
+    return ["read", "write"]
+
+
+def compile_requirements():
+    """Compile all available requirements"""
+    return [Requirement.GPU.value]
+
+
+def compile_builders():
+    return ["arkitekt_next.builders.easy", "arkitekt_next.builders.port"]
+
+
+def compile_runtimes():
+    return ["nvidia", "standard"]
+
+
+def compile_schema_versions() -> List[str]:
+    z = build_relative_dir("schemas")
+    return [
+        os.path.basename(f) for f in os.listdir(z) if os.path.isdir(os.path.join(z, f))
+    ]
+
+
+def compile_configs() -> List[str]:
+    z = build_relative_dir("configs")
+    return [
+        os.path.basename(f) for f in os.listdir(z) if os.path.isdir(os.path.join(z, f))
+    ]
+
+
+def compile_dockerfiles() -> List[str]:
+    z = build_relative_dir("dockerfiles")
+    return [
+        os.path.basename(f).replace(".dockerfile", "")
+        for f in os.listdir(z)
+        if os.path.isfile(os.path.join(z, f))
+    ]
+
+
+def compile_templates() -> List[str]:
+    z = build_relative_dir("templates")
+    return [
+        os.path.basename(f).split(".")[0]
+        for f in os.listdir(z)
+        if os.path.isfile(os.path.join(z, f))
+    ]
+
+
+def compile_services() -> List[str]:
+    z = build_relative_dir("schemas")
+    return [
+        os.path.basename(f).split(".")[0]
+        for f in os.listdir(z)
+        if os.path.isfile(os.path.join(z, f))
+    ]

arkitekt_next/cli/dockerfiles/vanilla.dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.8-slim-buster
+
+RUN pip install "arkitekt_next[all]>=0.7.a7"
+
+RUN mkdir /app
+WORKDIR /app
+COPY .arkitekt_next /app/.arkitekt_next
+COPY app.py /app/app.py

arkitekt_next/cli/errors.py

@@ -0,0 +1,4 @@
+class ValidationError(Exception):
+    """Raised when a validation error occurs."""
+
+    pass

arkitekt_next/cli/inspect.py

@@ -0,0 +1 @@
+

arkitekt_next/cli/io.py

@@ -0,0 +1,255 @@
+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,
+    DefinitionInput,
+)
+import yaml
+import json
+import rich_click as click
+
+
+def load_manifest_yaml(path: str) -> Manifest:
+    """Loads a manifest from a yaml file
+
+    Uses yaml safe load to load the manifest from a yaml file
+    (to avoid unsafe yaml attributes)
+
+    Parameters
+    ----------
+    path : str
+        The path to the yaml file
+
+    Returns
+    -------
+    Manifest
+        The loaded manifest
+    """
+    with open(path, "r") as file:
+        manifest = yaml.safe_load(file)
+        return Manifest(**manifest)
+
+
+def load_manifest() -> Optional[Manifest]:
+    """Loads the manifest from the arkitekt_next folder
+
+    Will load the manifest from the current working directories
+    arkitekt_next folder. If no folder exists, it will create one, but
+    will not create a manifest.
+
+    Returns
+    -------
+    Optional[Manifest]
+        The loaded manifest, or None if no manifest exists
+    """
+    path = create_arkitekt_next_folder()
+    config_file = os.path.join(path, "manifest.yaml")
+    if os.path.exists(config_file):
+        return load_manifest_yaml(config_file)
+    return None
+
+
+def write_manifest(manifest: Manifest):
+    """Writes a manifest to the arkitekt_next folder
+
+    Will write a manifest to the current working directories
+    arkitekt_next folder. If no folder exists, it will create one.
+
+
+    Parameters
+    ----------
+    manifest : Manifest
+        The manifest to write
+    """
+    path = create_arkitekt_next_folder()
+    config_file = os.path.join(path, "manifest.yaml")
+
+    with open(config_file, "w") as file:
+        yaml.safe_dump(
+            json.loads(manifest.json(exclude_none=True, exclude_unset=True)),
+            file,
+            sort_keys=True,
+        )
+
+
+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 generate_build(
+    build_run: str,
+    build_id: str,
+    flavour_name: str,
+    flavour: Flavour,
+    manifest: Manifest,
+    inspection: Optional[Inspection],
+) -> 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,
+        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,
+    definitions: Optional[List[DefinitionInput]] = None,
+) -> Deployment:
+    """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")
+
+    deployment = Deployment(
+        build_id=build.build_id,
+        manifest=build.manifest,
+        flavour=build.flavour,
+        selectors=build.selectors,
+        inspection=build.inspection,
+        image=image,
+    )
+
+    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
+    else:
+        config = DeploymentsConfigFile(deployments=[deployment])
+        config.latest_deployment_run = deployment_run
+
+    with open(config_file, "w") as file:
+        yaml.safe_dump(
+            json.loads(config.json(exclude_none=True, by_alias=True)),
+            file,
+            sort_keys=True,
+        )
+
+    return deployment

arkitekt_next/cli/main.py

@@ -0,0 +1,83 @@
+import sys
+import os
+
+try:
+    import rich_click as click
+
+    from rich.console import Console
+except ImportError:
+    print(
+        "ArkitektNext CLI is not installed, please install it first. By installing the cli, e.g with `pip install arkitekt_next[cli]`, you can use the `arkitekt_next` command."
+    )
+    sys.exit(1)
+
+from arkitekt_next.cli.vars import *
+from arkitekt_next.cli.constants import *
+from arkitekt_next.cli.texts import *
+from arkitekt_next.cli.commands.run.main import run
+from arkitekt_next.cli.commands.gen.main import gen
+from arkitekt_next.cli.commands.server.main import server
+from arkitekt_next.cli.commands.port.main import port
+from arkitekt_next.cli.commands.init.main import init
+from arkitekt_next.cli.commands.manifest.main import manifest
+from arkitekt_next.cli.commands.inspect.main import inspect
+from arkitekt_next.cli.commands.call.main import call
+from arkitekt_next.cli.io import load_manifest
+from arkitekt_next.utils import create_arkitekt_next_folder
+
+default_docker_file = """
+FROM python:3.8-slim-buster
+
+
+RUN pip install arkitekt_next==0.4.23
+
+
+RUN mkdir /app
+COPY . /app
+WORKDIR /app
+
+"""
+
+
+click.rich_click.HEADER_TEXT = LOGO
+click.rich_click.ERRORS_EPILOGUE = ERROR_EPILOGUE
+click.rich_click.USE_RICH_MARKUP = True
+
+
+@click.group()
+@click.pass_context
+def cli(ctx):
+    """ArkitektNext is a framework for building safe and performant apps that then can be centrally orchestrated and managed
+    in workflows.
+
+
+    This is the CLI for the ArkitektNext Python SDK. It allows you to create and deploy ArkitektNext Apps from your python code
+    as well as to run them locally for testing and development. For more information about ArkitektNext, please visit
+    [link=https://arkitekt_next.live]https://arkitekt_next.live[/link]
+    """
+    sys.path.append(os.getcwd())
+
+    ctx.obj = {}
+    console = Console()
+    set_console(ctx, console)
+
+    create_arkitekt_next_folder()
+
+    manifest = load_manifest()
+    if manifest:
+        set_manifest(ctx, manifest)
+
+    pass
+
+
+cli.add_command(init, "init")
+cli.add_command(run, "run")
+cli.add_command(gen, "gen")
+cli.add_command(port, "port")
+cli.add_command(manifest, "manifest")
+cli.add_command(inspect, "inspect")
+cli.add_command(server, "server")
+cli.add_command(call, "call")
+
+if __name__ == "__main__":
+    cli()

arkitekt_next/cli/options.py

@@ -0,0 +1,166 @@
+import rich_click as click
+
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+from .constants import *
+from .types import *
+from .vars import *
+from .ui import *
+
+with_fakts_url = click.option(
+    "--url",
+    "-u",
+    help="The fakts url for connection",
+    default=DEFAULT_ARKITEKT_URL,
+    envvar="FAKTS_URL",
+)
+
+with_token = click.option(
+    "--token",
+    "-t",
+    help="The token for the fakts instance",
+    envvar="FAKTS_TOKEN",
+    required=False,
+)
+with_version = click.option(
+    "--version",
+    "-v",
+    help="Override the version of the app",
+    envvar="ARKITEKT_VERSION",
+)
+
+with_log_level = click.option(
+    "--log",
+    "-l",
+    help="Override the logging level",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+    envvar="ARKITEKT_LOG_LEVEL",
+)
+
+
+with_skip_cache = click.option(
+    "--no-cache",
+    "-nc",
+    is_flag=True,
+    default=False,
+    help="Should we skip the cache",
+    envvar="ARKITEKT_NO_CACHE",
+)
+
+with_instance_id = click.option(
+    "--instance-id",
+    "-i",
+    default="main",
+    help="The token for the fakts instance",
+    envvar="REKUEST_INSTANCE",
+)
+
+with_log_level = click.option(
+    "--log-level",
+    "-l",
+    default="ERROR",
+    help="The token for the fakts instance",
+    envvar="ARKITEKT_LOG_LEVEL",
+)
+
+
+with_builder = click.option(
+    "--builder",
+    "-b",
+    default="arkitekt_next.builders.easy",
+    help="The builder for this run",
+    envvar="ARKITEKT_BUILDER",
+)
+
+with_headless = click.option(
+    "--headless",
+    "-h",
+    is_flag=True,
+    default=False,
+    help="Should we start headless",
+    envvar="ARKITEKT_HEADLESS",
+)
+
+
+def check_gen_boring(ctx, param, value):
+    """Callback to check and prompt for file overwrite."""
+
+    if not value:
+        get_console(ctx).print(construct_codegen_welcome_panel())
+
+    return value
+
+
+with_boring = click.option(
+    "--boring",
+    help="Should we skip the welcome message?",
+    is_flag=True,
+    default=False,
+    callback=check_gen_boring,
+)
+with_seperate_document_dirs = click.option(
+    "--seperate-doc-dirs",
+    "-sd",
+    help="Should we generate seperate dirs for the documents?",
+    is_flag=True,
+    default=False,
+)
+with_choose_services = click.option(
+    "--services",
+    "-s",
+    help="The services to create the codegen for",
+    multiple=True,
+    type=click.Choice(compile_services()),
+    default=["mikro"],
+)
+with_graphql_config = click.option(
+    "--config",
+    "-c",
+    help="The name of the configuration file",
+    type=str,
+    default="graphql.config.yaml",
+)
+with_api_path = click.option(
+    "--path",
+    "-c",
+    help="The path of the api to be generated",
+    prompt="Where should we generate the api? (relative to the current directory)",
+    type=str,
+    default="api",
+)
+
+
+def check_overwrite_config(ctx, param, value):
+    """Callback to check and prompt for file overwrite."""
+
+    config = ctx.params["config"]
+    if os.path.exists(config) and not value:
+        should_overwrite = click.confirm(
+            "GraphQL Config file already exists. Do you want to overwrite?"
+        )
+        return should_overwrite
+
+    return value
+
+
+with_overwrite_graphql = click.option(
+    "--overwrite-config",
+    "-o",
+    help="Should we overwrite the config file if it already exists",
+    is_flag=True,
+    default=False,
+    callback=check_overwrite_config,
+)
+with_documents = click.option(
+    "--documents",
+    "-d",
+    help="With documents",
+    is_flag=True,
+    default=True,
+)
+with_schemas = click.option(
+    "--schemas",
+    "-s",
+    help="Should we copy the schemas",
+    is_flag=True,
+    default=True,
+)