arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/commands/call/remote.py

@@ -0,0 +1,90 @@
+import rich_click as click
+from arkitekt_next.cli.options import *
+import asyncio
+from arkitekt_next.cli.ui import construct_run_panel
+from importlib import import_module
+from rekuest.postmans.utils import arkiuse
+import rich_click as click
+from arkitekt_next.cli.options import *
+import asyncio
+from arkitekt_next.cli.ui import construct_run_panel
+from importlib import import_module
+from arkitekt_next.cli.utils import import_builder
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+
+
+async def call_app(
+    app: App,
+    hash,
+    arg,
+):
+    async with app:
+        async with arkiuse(
+            hash=hash,
+            postman=app.rekuest.postman,
+        ) as a:
+            print(arg)
+            print(await a.aassign(kwargs=arg))
+
+
+@click.command("prod")
+@click.option(
+    "--url",
+    help="The fakts url for connection",
+    default=DEFAULT_ARKITEKT_URL,
+    envvar="FAKTS_URL",
+)
+@with_builder
+@with_token
+@with_instance_id
+@with_headless
+@with_log_level
+@with_skip_cache
+@click.pass_context
+@click.option(
+    "--arg",
+    "-a",
+    "args",
+    help="Key Value pairs for the setup",
+    type=(str, str),
+    multiple=True,
+)
+@click.option(
+    "--hash",
+    "-h",
+    help="The hash of the node to run",
+    type=str,
+)
+def remote(ctx, entrypoint=None, builder=None, args=None, hash=str, **builder_kwargs):
+    """ALlows you to run a get the output of a node in a remote app.
+
+    This is useful for debugging and testing. In this mode the app itself will not
+    be run, so local nodes cannot be called. Only nodes that are availabble on your
+    arkitekt_next server can be called.
+
+    """
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+    entrypoint = entrypoint or manifest.entrypoint
+
+    kwargs = dict(args or [])
+
+    builder = import_builder(builder)
+
+    with console.status("Loading entrypoint module..."):
+        try:
+            import_module(entrypoint)
+        except ModuleNotFoundError as e:
+            console.print(f"Could not find entrypoint module {entrypoint}")
+            raise e
+
+    app = builder(
+        **manifest.to_builder_dict(),
+        **builder_kwargs,
+    )
+
+    panel = construct_run_panel(app)
+    console.print(panel)
+
+    asyncio.run(call_app(app, hash, kwargs))

arkitekt_next/cli/commands/gen/compile.py

@@ -0,0 +1,45 @@
+import rich_click as click
+import os
+
+
+@click.command()
+@click.argument("projects", default=None, required=False, nargs=-1)
+@click.option(
+    "--config",
+    help="The config to use",
+    type=click.Path(exists=True),
+    default=None,
+)
+def compile(projects, config):
+    """Genererate the code of a project"
+
+    Uses a previously generated graphql-config.yaml file to generate the code for a or multiple projects.
+    If no project is specified, all projects will be generated.
+
+
+    """
+    app_directory = os.getcwd()
+
+    from turms.run import scan_folder_for_single_config, load_projects_from_configpath
+    from turms.cli.main import generate_projects
+
+    config = config or scan_folder_for_single_config(app_directory)
+    if not config:
+        raise click.ClickException(
+            f"No config file found. Please run `arkitekt_next gen init` in {app_directory} to create a default config file or specify a config file with the --config flag"
+        )
+
+    parsing_projects = load_projects_from_configpath(config)
+    if projects:
+        parsing_projects = {
+            key: value for key, value in parsing_projects.items() if key in projects
+        }
+
+    if not parsing_projects:
+        raise click.ClickException(
+            f"No projects found with the name '{projects}'. Available Projects: {', '.join(parsing_projects.keys())}"
+        )
+
+    generate_projects(parsing_projects, title="ArkitektNext Compile")
+
+    pass

arkitekt_next/cli/commands/gen/init.py

@@ -0,0 +1,122 @@
+import os
+import shutil
+import rich_click as click
+from arkitekt_next.cli.options import (
+    with_documents,
+    with_graphql_config,
+    with_api_path,
+    with_boring,
+    with_choose_services,
+    with_schemas,
+    with_seperate_document_dirs,
+)
+import yaml
+from arkitekt_next.cli.utils import build_relative_dir
+from arkitekt_next.cli.vars import get_console, get_manifest
+
+
+@click.command()
+@with_seperate_document_dirs
+@with_boring
+@with_choose_services
+@with_graphql_config
+@with_api_path
+@with_schemas
+@with_graphql_config
+@with_documents
+@click.pass_context
+def init(ctx, boring, services, config, documents, schemas, path, seperate_doc_dirs):
+    """Initialize code generation for the arkitekt_next app
+
+    Code generation for API's is done with the help of GraphQL Code Generation
+    that is powered by turms. This command initializes the code generation for
+    the app. It creates the necessary folders and files for the code generation
+    to work. It also creates a graphql config file that is used by turms to
+    generate the code.
+
+    """
+    app_directory = os.getcwd()
+
+    app_api_path = os.path.join(app_directory, path)
+    app_documents = os.path.join(app_directory, "graphql", "documents")
+
+    app_schemas = os.path.join(app_directory, "graphql", "schemas")
+
+    if documents:
+        os.makedirs(app_documents, exist_ok=True)
+    if schemas:
+        os.makedirs(app_schemas, exist_ok=True)
+    if path:
+        os.makedirs(app_api_path, exist_ok=True)
+
+    # Initializing the config
+    projects = {}
+
+    base_config = yaml.load(
+        open(build_relative_dir("configs", "base.yaml"), "r"), Loader=yaml.FullLoader
+    )
+
+    for service in services:
+        schema_path = build_relative_dir("schemas", f"{service}.schema.graphql")
+
+        if documents:
+            os.makedirs(os.path.join(app_documents, service), exist_ok=True)
+            if seperate_doc_dirs:
+                os.makedirs(
+                    os.path.join(app_documents, service, "queries"), exist_ok=True
+                )
+                os.makedirs(
+                    os.path.join(app_documents, service, "mutations"), exist_ok=True
+                )
+                os.makedirs(
+                    os.path.join(app_documents, service, "subscriptions"), exist_ok=True
+                )
+
+        if schemas:
+            if os.path.exists(schema_path):
+                try:
+                    shutil.copyfile(
+                        schema_path,
+                        os.path.join(app_schemas, service + ".graphql"),
+                    )
+                except FileExistsError:
+                    if click.confirm(
+                        f"Schema for {service} already exist. Do you want to overwrite them?"
+                    ):
+                        shutil.copyfile(
+                            schema_path,
+                            os.path.join(app_schemas, service + ".graphql"),
+                        )
+            else:
+                get_console(ctx).print(f"[red]No schema found for {service} [/]")
+
+        try:
+            project = base_config["projects"][service]
+        except KeyError:
+            get_console(ctx).print(f"[red]No config found for {service} [/]")
+            continue
+
+        if schemas:
+            project["schema"] = os.path.join(app_schemas, service + ".graphql")
+        if documents:
+            project["documents"] = (
+                os.path.join(app_documents, service) + "/**/*.graphql"
+            )
+
+        project["extensions"]["turms"]["out_dir"] = path
+        project["extensions"]["turms"]["generated_name"] = f"{service}.py"
+
+        projects[service] = project
+
+    if os.path.exists(config):
+        if not click.confirm(
+            f"GraphQL Config file already exists. Do you want to overwrite?"
+        ):
+            click.echo("Aborting...")
+            ctx.abort()
+
+    graph_config_path = os.path.join(app_directory, config)
+    yaml.safe_dump(
+        {"projects": projects}, open(graph_config_path, "w"), sort_keys=False
+    )
+    get_console(ctx).print(f"Config file written to {graph_config_path}")

arkitekt_next/cli/commands/gen/main.py

@@ -0,0 +1,29 @@
+import rich_click as click
+from .watch import watch
+from .compile import compile
+from .init import init
+
+
+@click.group()
+def gen():
+    """Codegeneration tools for ArkitektNext Apps (requires turms)
+
+    Code generation for API's is done with the help of GraphQL Code Generation
+    that is powered by [link=https://github.com/jhnnsrs/turms]turms[/link]. Simply
+    design your API in the documents folder and run `arkitekt_next gen compile` to
+    create fully typed code for your API. You can also run `arkitekt_next gen watch`
+    to automatically generate code when your documents change. This is useful
+    for development.
+
+    """
+    try:
+        pass
+    except ImportError as e:
+        raise click.ClickException(
+            "Turms is not installed. Please install turms first before using the arkitekt_next codegen."
+        ) from e
+
+
+gen.add_command(watch, "watch")
+gen.add_command(compile, "compile")
+gen.add_command(init, "init")

arkitekt_next/cli/commands/gen/watch.py

@@ -0,0 +1,32 @@
+import rich_click as click
+import os
+
+
+@click.command()
+@click.argument("project", default=None, required=False)
+@click.option(
+    "--config", help="The config to use", type=click.Path(exists=True), default=None
+)
+def watch(project, config):
+    """Watch your projects documents and automatically generate code when they change
+
+    This command will watch all the projects in your config file and automatically
+    generate code when the documents change. This is useful for development.
+
+    """
+    app_directory = os.getcwd()
+
+    from turms.run import scan_folder_for_single_config, load_projects_from_configpath
+    from turms.cli.main import watch_projects
+
+    config = config or scan_folder_for_single_config(app_directory)
+    if not config:
+        raise click.ClickException(
+            f"No config file found. Please run `arkitekt_next gen init` in {app_directory} to create a default config file or specify a config file with the --config flag"
+        )
+
+    projects = load_projects_from_configpath(config)
+    if project:
+        projects = {key: value for key, value in projects.items() if key == project}
+
+    watch_projects(projects, title="ArkitektNext Code Watch")

arkitekt_next/cli/commands/init/main.py

@@ -0,0 +1,194 @@
+import rich_click as click
+import os
+from arkitekt_next.cli.constants import *
+from getpass import getuser
+from arkitekt_next.cli.types import Manifest, Requirement
+from arkitekt_next.cli.vars import get_manifest, get_console
+import semver
+from arkitekt_next.cli.io import write_manifest
+from rich.panel import Panel
+from typing import Optional, List
+
+
+def check_overwrite_app(ctx, param, value):
+    """Callback to check and prompt for file overwrite."""
+
+    app_file = ctx.params["entrypoint"] + ".py"
+    if os.path.exists(app_file) and not value:
+        should_overwrite = click.confirm(
+            "Entrypoint File already exists. Do you want to overwrite?"
+        )
+        return should_overwrite
+
+    return value
+
+
+def check_overwrite(ctx, param, value):
+    """Callback to check and prompt for file overwrite."""
+
+    try:
+        manifest = get_manifest(ctx)
+        if not value:
+            should_overwrite = click.confirm(
+                f"Another ArkitektNext app {manifest.to_console_string()} exists already at {os.getcwd()}?. Do you want to overwrite?",
+                abort=True,
+            )
+            if not should_overwrite:
+                ctx.abort()
+    except click.ClickException:
+        pass
+
+    return value
+
+
+def ensure_semver(ctx, param, value):
+    """Callback to check and prompt for file overwrite."""
+
+    if not value:
+        value = click.prompt(
+            "The version of your app",
+            default="0.0.1",
+        )
+
+    while not semver.Version.is_valid(value):
+        get_console().print(
+            "ArkitektNext versions need to follow [link=https://semver.org]semver[/link]. Please choose a correct format (examples: 0.0.0, 0.1.0, 0.0.0-alpha.1)"
+        )
+        value = click.prompt(
+            "The version of your app",
+            default="0.0.1",
+        )
+
+    return value
+
+
+@click.command()
+@click.option(
+    "--overwrite-manifest",
+    "-om",
+    help="Should we overwrite the existing manifest if it already exists?",
+    is_flag=True,
+    default=False,
+    callback=check_overwrite,
+)
+@click.option(
+    "--template",
+    "-t",
+    help="The template to use. You can choose from a variety of preconfigured templates. They are just starting points and can be changed later.",
+    type=click.Choice(compile_templates()),
+    default="simple",
+)
+@click.option(
+    "--identifier",
+    "-i",
+    help="The identifier of your app. This will be used to identify your app in the ArkitektNext ecosystem. It should be unique and should follow the [link=https://en.wikipedia.org/wiki/Reverse_domain_name_notation]reverse domain name notation[/link] (example: com.example.myapp)",
+    prompt="Your app identifier",
+    default=os.path.basename(os.getcwd()),
+)
+@click.option(
+    "--version",
+    "-v",
+    help="The version of your app. Needs to follow [link=https://semver.org/]semantic versioning[/link].",
+    default="0.0.1",
+    callback=ensure_semver,
+)
+@click.option(
+    "--author",
+    help="The author of your app. This will be shown to users of your app",
+    prompt="Your name",
+    default=getuser(),
+)
+@click.option(
+    "--template",
+    help="Which template to use top create entrypoint",
+    prompt="Your app file template",
+    type=click.Choice(compile_templates()),
+    default="simple",
+)
+@click.option(
+    "--logo",
+    help="Which logo to use for this app, needs to be a valid url",
+    required=False,
+)
+@click.option(
+    "--entrypoint",
+    "-e",
+    help="The entrypoint of your app. This will be the name of the python file. Omit the .py ending",
+    prompt="Your app file",
+    default="app",
+)
+@click.option(
+    "--overwrite-app",
+    "-oa",
+    help="Do you want to overwrite the app file if it exists?",
+    is_flag=True,
+    default=False,
+    callback=check_overwrite_app,
+)
+@click.option(
+    "--requirements",
+    "-r",
+    help="Dedicated hardware requirements for this app. They will be used to inform Plugin Schedulers like port, on which compute resources to put your plugin app, once deployed.You can choose multiple for your app. For a list of requirements, run `arkitekt_next manifest requirements available`",
+    type=click.Choice(compile_requirements()),
+    multiple=True,
+    default=[],
+)
+@click.option(
+    "--scopes",
+    "-s",
+    help="The scopes of the app. You can choose multiple for your app. For a list of scopes, run `arkitekt_next manifest scopes available`",
+    type=click.Choice(compile_scopes()),
+    multiple=True,
+    default=["read"],
+)
+@click.pass_context
+def init(
+    ctx,
+    identifier: str,
+    version: str,
+    author: str,
+    logo: Optional[str],
+    scopes: List[str],
+    template: str,
+    requirements: List[Requirement],
+    entrypoint: str,
+    overwrite_manifest: bool,
+    overwrite_app: bool,
+):
+    """Initializes an ArkitektNext app
+
+    This command will create a new ArkitektNext app in the current directory. It will
+    create a `.arkitekt_next` folder that will contain a manifest and a `app.py` file,
+    which will serve as the entrypoint for your app. By default, the app will be
+    initialized with a simple hello world app, but you can choose from a variety
+    of templates.
+
+    """
+
+    console = get_console(ctx)
+
+    manifest = Manifest(
+        logo=logo,
+        author=author,
+        identifier=identifier,
+        version=version,
+        scopes=scopes,
+        requirements=requirements,
+        entrypoint=entrypoint,
+    )
+
+    with open(build_relative_dir("templates", f"{template}.py")) as f:
+        template_app = f.read()
+
+    if not os.path.exists(f"{entrypoint}.py") or overwrite_app:
+        with open(f"{entrypoint}.py", "w") as f:
+            f.write(template_app)
+
+    write_manifest(manifest)
+    md = Panel(
+        f"{manifest.to_console_string()} was successfully initialized\n\n"
+        + "[not bold white]We are excited to see what you come up with!",
+        border_style="green",
+        style="green",
+    )
+    console.print(md)

arkitekt_next/cli/commands/inspect/definitions.py

@@ -0,0 +1,53 @@
+import rich_click as click
+from importlib import import_module
+from arkitekt_next.cli.vars import get_console, get_manifest
+from arkitekt_next.cli.options import with_builder
+import json
+
+
+async def run_app(app):
+    async with app:
+        await app.rekuest.run()
+
+
+@click.command("prod")
+@click.pass_context
+@click.option(
+    "--pretty",
+    "-p",
+    help="Should we just output json?",
+    is_flag=True,
+    default=False,
+)
+@with_builder
+def definitions(
+    ctx,
+    pretty: bool,
+    builder=None,
+):
+    """Runs the app in production mode
+
+    \n
+    You can specify the builder to use with the --builder flag. By default, the easy builder is used, which is designed to be easy to use and to get started with.
+
+    """
+    from rekuest.definition.registry import get_default_definition_registry
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    entrypoint = manifest.entrypoint
+
+    with console.status("Loading entrypoint module..."):
+        try:
+            import_module(entrypoint)
+        except ModuleNotFoundError as e:
+            console.print(f"Could not find entrypoint module {entrypoint}")
+            raise e
+
+    definitions = get_default_definition_registry().dump()
+
+    if pretty:
+        console.print(json.dumps(definitions, indent=2))
+    else:
+        print(json.dumps(definitions))

arkitekt_next/cli/commands/inspect/main.py

@@ -0,0 +1,22 @@
+import rich_click as click
+
+
+import rich_click as click
+from .variables import variables
+from .definitions import definitions
+
+
+@click.group()
+@click.pass_context
+def inspect(ctx):
+    """Inspects your arkitekt_next app
+
+    Inspects various parts of your arkitekt_next app. This is useful for debugging
+    and development. It also represents methods that are called by the arkitekt_next
+    server when you run your app in production mode.
+
+    """
+
+
+inspect.add_command(variables, "variables")
+inspect.add_command(definitions, "definitions")

arkitekt_next/cli/commands/inspect/variables.py

@@ -0,0 +1,92 @@
+from importlib import import_module
+import inspect as pyinspect
+import rich_click as click
+
+from arkitekt_next.cli.ui import construct_leaking_group
+from arkitekt_next.cli.vars import get_console, get_manifest
+from rich.panel import Panel
+
+import rich_click as click
+
+
+def inspect_dangerous_variables(module_path):
+    """Inspect the module and return a dictionary of all the variables that are
+    not upper case and that are not classes, modules, functions or builtins.
+
+    This is used to check if a module is safe to import. Or if it runs code
+    that might be dangegours:
+
+    TODO: This is not the ebst way to do this. We should probably use the ast
+    module to parse the module and check for dangerous code. This is a quick
+    and dirty solution.
+
+    """
+
+    module = import_module(module_path)
+
+    dangerous_variables = {}
+
+    for key, value in pyinspect.getmembers(module):
+        if key.startswith("_"):
+            continue
+        if pyinspect.isclass(value):
+            continue
+        if pyinspect.ismodule(value):
+            continue
+        if pyinspect.isfunction(value):
+            continue
+        if pyinspect.isbuiltin(value):
+            continue
+
+        if type(value) in [str, float, int, bool, list, dict, tuple]:
+            if key != key.upper():
+                dangerous_variables[key] = value
+            continue
+
+    return dangerous_variables
+
+
+def scan_module(module_path):
+    """Scan a module for dangerous variables."""
+    return inspect_dangerous_variables(module_path)
+
+
+@click.command()
+@click.pass_context
+def variables(ctx, entrypoint):
+    """Scans your arkitekt_next app for unsafe variables
+
+    When designing an ArkitektNext app, you should not have variables in your
+    global scope, as on potential reloads (like for example in development)
+    these variables will be redefined and cause memory leaks and other issues.
+
+    You can use this command to scan your app for dangerous variables. If you
+    have any, you should consider moving them into a function or class.
+
+    """
+
+    console = get_console(ctx)
+
+    if not entrypoint:
+        manifest = get_manifest(ctx)
+        entrypoint = manifest.entrypoint
+
+    variables = scan_module(entrypoint)
+
+    if not variables:
+        console.print(
+            Panel(
+                "No dangerous variables found. You are good to go!  🎉",
+                style="green",
+                border_style="green",
+                title="ArkitektNext Scan",
+            )
+        )
+        return
+
+    group = construct_leaking_group(variables)
+
+    panel = Panel(
+        group, title="ArkitektNext Scan", expand=True, border_style="red", style="red"
+    )
+    console.print(panel)