arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/cli/commands/port/wizard.py

@@ -0,0 +1,329 @@
+from arkitekt_next.cli.types import Manifest, Packager
+from arkitekt_next.cli.vars import get_manifest
+import sys
+import rich_click as click
+from click import Context
+import subprocess
+from rich import get_console
+
+try:
+    pass
+except ImportError as e:
+    raise ImportError("Please install rekuest to use this feature") from e
+
+
+import os
+
+
+def get_base_prefix_compat() -> str:
+    """Get base/real prefix, or sys.prefix if there is none."""
+    return (
+        getattr(sys, "base_prefix", None)
+        or getattr(sys, "real_prefix", None)
+        or sys.prefix
+    )
+
+
+def in_virtualenv() -> bool:
+    """Returns True if in a virtualenv, otherwise False."""
+    return get_base_prefix_compat() != sys.prefix
+
+
+def pip_no_gpu(manifest: Manifest, python_version: str) -> str:
+    """A function to generate a dockerfile for pip without gpu support
+
+    Parameters
+    ----------
+    manifest : Manifest
+        The manifest of the project
+    python_version : str
+        The python version to use
+
+    Returns
+    -------
+    str
+        The dockerfile
+    """
+    get_console().print("[blue]Setting up environment...[/blue]")
+    if not in_virtualenv():
+        click.confirm(
+            "You are not in a virtual environment. Consider using a virtual environment. Do you want to continue?",
+            abort=True,
+        )
+
+    if not os.path.exists(".requirements.txt") and click.confirm(
+        "Do you want to freeze the dependencies the current interpreter?"
+    ):
+        subprocess.check_call("pip freeze > requirements.txt", shell=True)
+
+    get_console().print("[blue]Generating Dockerfile...[/blue]")
+
+    BASE_IMAGE = f"FROM python:{python_version}\n"
+    PIP_APPENDIX = "# setup pip  environment\nCOPY ./requirements.txt /tmp/requirements.txt\nRUN pip install /tmp/requirements.yml\n"
+    WORKDIR_APPENDIX = "RUN mkdir /app \nWORKDIR /app"
+
+    dockerfile = BASE_IMAGE
+    if click.confirm(
+        "Do you want to install a requirements.txt with the dependencies with pip?"
+    ):
+        dockerfile += PIP_APPENDIX
+
+    if click.confirm("Do you want to use the current working directory as the app?"):
+        dockerfile += WORKDIR_APPENDIX
+
+    return dockerfile
+
+
+def poetry_no_gpu(manifest: Manifest, python_version: str) -> str:
+    """A function to generate a dockerfile for pip without gpu support
+
+    Parameters
+    ----------
+    manifest : Manifest
+        The manifest of the project
+    python_version : str
+        The python version to use
+
+    Returns
+    -------
+    str
+        The dockerfile
+    """
+    get_console().print("[blue]Setting up environment...[/blue]")
+    if not in_virtualenv():
+        click.confirm(
+            "You are not in a virtual environment. Consider using a virtual environment. Do you want to continue?",
+            abort=True,
+        )
+
+    if click.confirm("Do you want to lock the current dependencies?"):
+        subprocess.check_call("poetry lock", shell=True)
+
+    get_console().print("[blue]Generating Dockerfile...[/blue]")
+
+    BASE_IMAGE = f"FROM python:{python_version}\n"
+    SETUP_POETRY = "# Install dependencies\nRUN pip install poetry rich\nENV PYTHONUNBUFFERED=1\n# Install Project files\nCOPY pyproject.toml /tmp\nCOPY poetry.lock /tmp\nRUN poetry config virtualenvs.create false\nWORKDIR /tmp\nRUN poetry install\n"
+    WORKDIR_APPENDIX = "RUN mkdir /app\nCOPY . /app\nWORKDIR /app\n"
+
+    dockerfile = BASE_IMAGE
+    dockerfile += SETUP_POETRY
+
+    if click.confirm("Do you want to use the current working directory as the app?"):
+        dockerfile += WORKDIR_APPENDIX
+
+    return dockerfile
+
+
+CONDA_GPU = """
+FROM jhnnsrs/tensorflow_conda_gpu:latest
+
+# setup conda virtual environment
+COPY ./requirements.yml /tmp/requirements.yml
+RUN conda env create --name camera-seg -f /tmp/requirements.yml
+
+RUN conda activate camera-seg   
+"""
+
+
+CONDA_NO_GPU = """
+FROM jhnnsrs/tensorflow_conda:latest
+
+# setup conda virtual environment
+COPY ./requirements.yml /tmp/requirements.yml
+RUN conda env create --name camera-seg -f /tmp/requirements.yml
+
+RUN conda activate camera-seg
+"""
+
+BUILDERS = {
+    "pip": {
+        "gpu": None,
+        "no-gpu": pip_no_gpu,
+    },
+    "conda": None,
+    "poetry": {
+        "gpu": None,
+        "no-gpu": poetry_no_gpu,
+    },
+}
+
+
+def build_dockerfile(
+    manifest: Manifest, packager: Packager, gpu: bool, python_version: str
+) -> str:
+    """A function to build a dockerfile
+
+    It delegates to the correct builder, based on the packager and gpu support
+
+
+    Parameters
+    ----------
+    manifest : Manifest
+        The manifest of the project
+    packager : Packager
+        The detected packager
+    gpu : bool
+        The detected gpu support
+    python_version : str
+        _description_
+
+    Returns
+    -------
+    str
+        The dockerfile
+
+    Raises
+    ------
+    click.ClickException
+        An exception if the packager is not supported
+    """
+
+    strategy = BUILDERS.get(packager, {})
+
+    if not strategy:
+        raise click.ClickException(
+            f"Packager {packager} is not supported. Please create a issue on github and create your own Dockerfile for now."
+        )
+
+    builder = strategy.get(gpu and "gpu" or "no-gpu", None)
+
+    if not builder:
+        raise click.ClickException(
+            f"Packager {packager} {gpu and 'with GPU Support'} is not supported. Please create a issue on github and create your own Dockerfile for now."
+        )
+
+    return builder(manifest, python_version)
+
+
+def docker_file_wizard(manifest: Manifest, auto: bool = True) -> str:
+    """A wizard to generate a dockerfile
+
+    Parameters
+    ----------
+    manifest : Manifest
+        The manifest of the project
+    auto : bool, optional
+        Should we autodefault prompts to true, by default True
+
+    Returns
+    -------
+    str
+        The dockerfile
+
+    ------
+    ImportError
+        If toml is not installed
+    """
+    python_version = (
+        f"{ sys.version_info.major}.{ sys.version_info.minor}.{ sys.version_info.micro}"
+    )
+    python_version = (
+        python_version
+        if auto
+        else click.prompt(
+            "Which python version to do you want to use?", default=python_version
+        )
+    )
+
+    packager = None
+
+    gpu = "gpu" in manifest.requirements
+
+    # loading environment
+    # check if running in conda
+    conda_env = os.environ.get("CONDA_DEFAULT_ENV")
+    if conda_env:
+        click.echo(f"Found running in conda environment {conda_env}")
+
+        packager = Packager.CONDA
+
+    # Check if pyproject.toml exists
+    if os.path.exists("pyproject.toml"):
+        # Check if poetry is installed
+        try:
+            import toml
+        except ImportError as e:
+            raise ImportError("Please install toml to use this feature") from e
+
+        # Check if poetry is used
+        pyproject = toml.load("pyproject.toml")
+        if "tool" in pyproject and "poetry" in pyproject["tool"]:
+            click.echo("Found poetry project")
+            do = True if auto else click.confirm("Do you want to use poetry?")
+            if do:
+                packager = Packager.POETRY
+
+    if not packager:
+        click.echo(
+            "No advanced packager found. Considering using poetry "
+            "with a pyproject.toml or conda with a environment.yml"
+        )
+
+        if os.path.exists("requirements.txt"):
+            click.prompt("Found requirements.txt file in current directory. Using it.")
+
+        packager = Packager.PIP
+
+    if not click.confirm(
+        f"Would you like to generate Template Dockerfile: Using {packager} with Python {python_version} {'and' if gpu else 'without'} GPU support"
+    ):
+        raise click.Abort("Aborted")
+
+    dockfile = build_dockerfile(
+        manifest, packager, gpu=gpu, python_version=python_version
+    )
+
+    return dockfile
+
+
+def check_overwrite_dockerfile(ctx: Context, param: str, value: bool) -> bool:
+    """A callback to check if the dockerfile should be overwritten
+
+    Parameters
+    ----------
+    ctx : Context
+        The context of the click command
+    param : str
+        The parameter name
+    value : str
+        The value of the parameter
+
+    Returns
+    -------
+    bool
+        Should we overwrite the dockerfile?
+    """
+
+    app_file = ctx.params["dockerfile"]
+    if os.path.exists(app_file) and not value:
+        should_overwrite = click.confirm(
+            "Docker already exists. Do you want to overwrite?", abort=True
+        )
+        if should_overwrite:
+            return True
+        else:
+            raise click.Abort()
+
+    return value
+
+
+@click.command()
+@click.option("--dockerfile", help="The dockerfile to generate", default="Dockerfile")
+@click.option(
+    "--overwrite-dockerfile",
+    "-o",
+    help="Should we overwrite the existing Dockerfile?",
+    is_flag=True,
+    default=False,
+    callback=check_overwrite_dockerfile,
+)
+@click.pass_context
+def wizard(ctx: Context, dockerfile: str, overwrite_dockerfile: bool) -> None:
+    """Runs the port wizard to generate a dockerfile to be used with port"""
+
+    manifest = get_manifest(ctx)
+
+    dockfile = docker_file_wizard(manifest)
+
+    with open(dockerfile, "w") as file:
+        file.write(dockfile)

arkitekt_next/cli/commands/run/dev.py

@@ -0,0 +1,349 @@
+from importlib import import_module, reload
+import asyncio
+from arkitekt_next import App
+from watchfiles import awatch, Change
+from rich.panel import Panel
+from rich.console import Console
+from watchfiles.filters import PythonFilter
+import os
+import sys
+import inspect
+from rekuest.definition.registry import get_default_definition_registry
+from rekuest.agents.hooks import get_default_hook_registry
+from typing import MutableSet, Tuple, Any, Set
+from arkitekt_next.cli.ui import construct_changes_group, construct_app_group
+from arkitekt_next.cli.commands.run.utils import import_builder
+from arkitekt_next.cli.types import Manifest
+from arkitekt_next.apps.types import App
+import rich_click as click
+import os
+from arkitekt_next.cli.options import (
+    with_fakts_url,
+    with_builder,
+    with_token,
+    with_instance_id,
+    with_headless,
+    with_log_level,
+    with_skip_cache,
+)
+from arkitekt_next.cli.vars import get_console, get_manifest
+
+
+class EntrypointFilter(PythonFilter):
+    """Checks if the entrypoint is changed"""
+
+    def __init__(self, entrypoint: str, *args, **kwargs) -> None:
+        """A filter that checks if the entrypoint is changed
+
+        Parameters
+        ----------
+        entrypoint : str
+            The entrypoint to check
+        """
+        super().__init__(*args, **kwargs)
+        self.entrypoint = entrypoint
+
+    def __call__(self, change: Change, path: str) -> bool:
+        """Checks if any of the python filters are changed
+        _description_
+                Parameters
+                ----------
+                change : Change
+                    The change type
+                path : str
+                    The causing path
+
+                Returns
+                -------
+                bool
+                    Should we reload?
+        """
+        x = super().__call__(change, path)
+        if not x:
+            return False
+
+        basename = os.path.basename(path)
+        module_name = basename.split(".")[0]
+
+        return module_name == self.entrypoint
+
+
+class DeepFilter(PythonFilter):
+    """Checks if any of the python filters are changed"""
+
+    def __call__(self, change: Change, path: str) -> bool:
+        """Checks if any of the python filters are changed
+
+        Parameters
+        ----------
+        change : Change
+            The change type
+        path : str
+            The causing path
+
+        Returns
+        -------
+        bool
+            Should we reload?
+        """
+        return super().__call__(change, path)
+
+
+async def run_app(app: App) -> None:
+    """A helper function to run the app
+
+    Parameters
+    ----------
+    app : App
+        The app to run
+
+    """
+
+    rekuest = app.services.get("rekuest")
+    async with app:
+        await rekuest.run()
+
+
+def reload_modules(reloadable_modules) -> None:
+    """Reloads the modules in the reloadable_modules set"""
+    for module in reloadable_modules:
+        reload(sys.modules[module])
+
+
+def check_deeps(changes: Set[Tuple[Change, str]]) -> Set[str]:
+    """Checks if any of the changes
+    are happening in a module that is installed
+    and returns the modules that should be reloaded
+
+
+
+    Parameters
+    ----------
+    changes : Set[ Tuple[Change, str] ]
+        The changes to check
+
+    Returns
+    -------
+    Set[str]
+        A set of modules that should be reloaded
+    """
+    normalized = [os.path.normpath(file) for modified, file in changes]
+
+    reloadable_modules = set()
+
+    for key, v in sys.modules.items():
+        try:
+            filepath = inspect.getfile(v)
+        except OSError:
+            continue
+        except TypeError:
+            continue
+
+        for i in normalized:
+            if filepath.startswith(i):
+                reloadable_modules.add(key)
+
+    return reloadable_modules
+
+
+def reset_structure() -> None:
+    """Resets the default defintiion rgistry and all
+    regitered nodes"""
+    get_default_definition_registry().definitions.clear()
+    get_default_hook_registry().reset()
+
+
+def is_entrypoint_change(
+    changes: MutableSet[Tuple[Any, str]], entrypoint_real_path: str
+) -> bool:
+    for change, path in changes:
+        if os.path.normpath(path) == entrypoint_real_path:
+            return True
+    return False
+
+
+async def run_dev(
+    console: Console,
+    manifest: Manifest,
+    version=None,
+    builder: str = "arkitekt_next.builders.easy",
+    deep: bool = False,
+    **builder_kwargs,
+):
+    entrypoint = manifest.entrypoint
+    identifier = manifest.identifier
+    version = version or "dev"
+    entrypoint_file = f"{manifest.entrypoint}.py"
+    os.path.realpath(entrypoint_file)
+
+    builder_func = import_builder(builder)
+
+    generation_message = "[not bold white]This is a development tool for arkitekt_next apps. It will watch your app for changes and reload it when it detects a change. It will also print out the current state of your app.[/]"
+
+    if deep:
+        generation_message += "\n\n - [not bold white][b]Deep mode[/] is enabled. This will watch all your installed packages for changes and reload them if they are changed.[/]"
+    else:
+        generation_message += "\n\n - [not bold white][b]Deep mode[/] is disabled. This will only watch your entrypoint for changes.[/]"
+
+    panel = Panel(
+        generation_message,
+        style="bold green",
+        border_style="green",
+        title="ArkitektNext Dev Mode",
+    )
+    console.print(panel)
+
+    try:
+        module = import_module(manifest.entrypoint)
+
+    except Exception:
+        console.print_exception()
+        panel = Panel(
+            f"Error while importing your entrypoint please fix your file {entrypoint} and save",
+            style="bold red",
+            border_style="red",
+        )
+        console.print(panel)
+        module = None
+
+    def callback(future):
+        if future.cancelled():
+            return
+        else:
+            has_exception = future.exception()
+
+            if not has_exception:
+                panel = Panel(
+                    "App finished running", style="bold yellow", border_style="yellow"
+                )
+                console.print(panel)
+            else:
+                try:
+                    raise has_exception
+                except Exception:
+                    console.print_exception()
+                    panel = Panel(
+                        "Error running App", style="bold red", border_style="red"
+                    )
+                    console.print(panel)
+
+    try:
+        app: App = builder_func(
+            identifier=identifier,
+            version=version,
+            logo=manifest.logo,
+            **builder_kwargs,
+        )
+        group = construct_app_group(app)
+        panel = Panel(group, style="bold green", border_style="green")
+        console.print(panel)
+
+        x = asyncio.create_task(run_app(app))
+        x.add_done_callback(callback)
+    except Exception:
+        console.print_exception()
+        panel = Panel(
+            "Error building initial App", style="bold red", border_style="red"
+        )
+        console.print(panel)
+
+    async for changes in awatch(
+        ".",
+        watch_filter=EntrypointFilter(entrypoint) if not deep else DeepFilter(),
+        debounce=2000,
+        step=500,
+    ):
+        if deep:
+            to_be_reloaded = check_deeps(changes)
+            if not to_be_reloaded:
+                continue
+
+        group = construct_changes_group(changes)
+        panel = Panel(group, style="bold blue", border_style="blue")
+        console.print(panel)
+
+        console.print(panel)
+        # Cancelling the app
+        if not x or x.done():
+            pass
+
+        else:
+            x.cancel()
+            panel = Panel(
+                "Cancelling latest version", style="bold yellow", border_style="yellow"
+            )
+            console.print(panel)
+            try:
+                await x
+
+            except asyncio.CancelledError:
+                pass
+
+        # Restarting the app
+        try:
+            with console.status("Reloading module..."):
+                reset_structure()
+
+                if not module:
+                    module = import_module(entrypoint)
+                else:
+                    if deep:
+                        reload_modules(to_be_reloaded)
+                    else:
+                        reload(module)
+        except Exception:
+            console.print_exception()
+            panel = Panel(
+                "Reload unsucessfull please fix your app and save",
+                style="bold red",
+                border_style="red",
+            )
+            console.print(panel)
+            continue
+
+        try:
+            app = builder_func(
+                identifier=identifier,
+                version=version,
+                logo=manifest.logo,
+                **builder_kwargs,
+            )
+            group = construct_app_group(app)
+            panel = Panel(group, style="bold green", border_style="green")
+            console.print(panel)
+
+            x = asyncio.create_task(run_app(app))
+            x.add_done_callback(callback)
+        except Exception:
+            console.print_exception()
+            panel = Panel(
+                "Error building reloaded App", style="bold red", border_style="red"
+            )
+            console.print(panel)
+
+
+@click.command()
+@with_fakts_url
+@with_builder
+@with_token
+@with_instance_id
+@with_headless
+@with_log_level
+@with_skip_cache
+@click.option(
+    "--deep",
+    help="Should we check the whole directory for changes and reload them when changes?",
+    is_flag=True,
+)
+@click.pass_context
+def dev(ctx, **kwargs):
+    """Runs the app in dev mode (with hot reloading)
+
+    Running the app in dev mode will automatically reload the app when changes are detected.
+    This is useful for development and debugging.
+    """
+
+    manifest = get_manifest(ctx)
+    console = get_console(ctx)
+
+    asyncio.run(run_dev(console, manifest, **kwargs))

arkitekt_next/cli/commands/run/main.py

@@ -0,0 +1,22 @@
+import rich_click as click
+from .dev import dev
+from .prod import prod
+
+
+@click.group()
+@click.pass_context
+def run(ctx):
+    """Runs your arkitekt_next app
+
+    Running your app locally is the first step to developing your app. You can run your app in
+    development mode, which will automatically reload your app when you change the code, or in
+    production mode, which not reload your app when you change the code, but allows you to
+    scale your app to multiple processes.
+
+
+
+    """
+
+
+run.add_command(dev, "dev")
+run.add_command(prod, "prod")