arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/apps/service/kabinet.py

@@ -0,0 +1,31 @@
+from kabinet.kabinet import Kabinet
+from kabinet.rath import KabinetLinkComposition, KabinetRath
+from rath.links.split import SplitLink
+from rath.contrib.fakts.links.aiohttp import FaktsAIOHttpLink
+from rath.contrib.fakts.links.graphql_ws import FaktsGraphQLWSLink
+from rath.contrib.herre.links.auth import HerreAuthLink
+from graphql import OperationType
+from arkitekt_next_next.healthz import FaktsHealthz
+from fakts import Fakts
+from herre import Herre
+
+
+class ArkitektNextKabinet(Kabinet):
+    rath: KabinetRath
+    healthz: FaktsHealthz
+
+
+def build_arkitekt_next_kabinet(herre: Herre, fakts: Fakts):
+    return ArkitektNextKabinet(
+        rath=KabinetRath(
+            link=KabinetLinkComposition(
+                auth=HerreAuthLink(herre=herre),
+                split=SplitLink(
+                    left=FaktsAIOHttpLink(fakts_group="kabinet", fakts=fakts),
+                    right=FaktsGraphQLWSLink(fakts_group="kabinet", fakts=fakts),
+                    split=lambda o: o.node.operation != OperationType.SUBSCRIPTION,
+                ),
+            )
+        ),
+        healthz=FaktsHealthz(fakts_group="kabinet", fakts=fakts),
+    )

arkitekt_next/apps/service/mikro_next.py

@@ -0,0 +1,81 @@
+"""
+This modules provides the main app. It is responsible for setting up the connection to the mikro-server and
+handling authentification and setting up the configuration. Mikro handles the creation of the datalayer and
+the graphql client.
+
+You can compose this app together with other apps to create a full fledged app. (Like combining with
+arkitekt_next to enable to call functions that you define on the app)
+
+Example:
+
+    A simple app that takes it configuraiton from basic.fakts and connects to the mikro-server.
+    You can define all of the logic within the context manager
+
+    ```python
+    from mikro.app import MikroApp
+
+    app = MikroApp(fakts=Fakts(subapp="basic"))
+
+    with app:
+        # do stuff
+
+    ```
+
+    Async Usage:
+
+
+    ```python
+    from mikro.app import MikroApp
+
+    app = MikroApp(fakts=Fakts(subapp="basic"))
+
+    async with app:
+        # do stuff
+
+    ```
+
+ 
+"""
+
+
+from arkitekt_next_next.healthz import FaktsHealthz
+from mikro_next.mikro_next import MikroNext
+from mikro_next.rath import MikroNextLinkComposition, MikroNextRath
+from rath.links.split import SplitLink
+from rath.contrib.fakts.links.aiohttp import FaktsAIOHttpLink
+from rath.contrib.fakts.links.graphql_ws import FaktsGraphQLWSLink
+from rath.contrib.herre.links.auth import HerreAuthLink
+from mikro_next.contrib.fakts.datalayer import FaktsDataLayer
+from mikro_next.links.upload import UploadLink
+from mikro_next.datalayer import DataLayer
+from graphql import OperationType
+from herre import Herre
+from fakts import Fakts
+
+
+class ArkitektNextMikroNext(MikroNext):
+    rath: MikroNextRath
+    datalayer: DataLayer
+    healthz: FaktsHealthz
+
+
+def build_arkitekt_next_mikro_next(herre: Herre, fakts: Fakts):
+    datalayer = FaktsDataLayer(fakts_group="datalayer", fakts=fakts)
+
+    return ArkitektNextMikroNext(
+        rath=MikroNextRath(
+            link=MikroNextLinkComposition(
+                auth=HerreAuthLink(herre=herre),
+                upload=UploadLink(
+                    datalayer=datalayer,
+                ),
+                split=SplitLink(
+                    left=FaktsAIOHttpLink(fakts_group="mikro", fakts=fakts),
+                    right=FaktsGraphQLWSLink(fakts_group="mikro", fakts=fakts),
+                    split=lambda o: o.node.operation != OperationType.SUBSCRIPTION,
+                ),
+            )
+        ),
+        datalayer=datalayer,
+        healthz=FaktsHealthz(fakts_group="mikro", fakts=fakts),
+    )

arkitekt_next/apps/service/rekuest_next.py

@@ -0,0 +1,53 @@
+from arkitekt_next_next.healthz import FaktsHealthz
+from rath.contrib.fakts.links.aiohttp import FaktsAIOHttpLink
+from rath.links.split import SplitLink
+from rath.contrib.fakts.links.graphql_ws import FaktsGraphQLWSLink
+from rath.contrib.herre.links.auth import HerreAuthLink
+from rekuest_next.rath import RekuestNextLinkComposition, RekuestNextRath
+from rekuest_next.rekuest import RekuestNext
+from graphql import OperationType
+from rekuest_next.contrib.arkitekt_next.websocket_agent_transport import (
+    ArkitektNextWebsocketAgentTransport,
+)
+
+from rekuest_next.agents.base import BaseAgent
+from fakts import Fakts
+from herre import Herre
+from rekuest_next.postmans.graphql import GraphQLPostman
+
+
+class ArkitektNextRekuestNext(RekuestNext):
+    rath: RekuestNextRath
+    agent: BaseAgent
+    healthz: FaktsHealthz
+
+
+def build_arkitekt_next_rekuest_next(
+    fakts: Fakts, herre: Herre, instance_id: str
+) -> ArkitektNextRekuestNext:
+    rath = RekuestNextRath(
+        link=RekuestNextLinkComposition(
+            auth=HerreAuthLink(herre=herre),
+            split=SplitLink(
+                left=FaktsAIOHttpLink(fakts_group="rekuest", fakts=fakts),
+                right=FaktsGraphQLWSLink(fakts_group="rekuest", fakts=fakts),
+                split=lambda o: o.node.operation != OperationType.SUBSCRIPTION,
+            ),
+        )
+    )
+
+    return ArkitektNextRekuestNext(
+        rath=rath,
+        agent=BaseAgent(
+            transport=ArkitektNextWebsocketAgentTransport(
+                fakts_group="rekuest.agent", fakts=fakts, herre=herre
+            ),
+            instance_id=instance_id,
+            rath=rath,
+        ),
+        postman=GraphQLPostman(
+            rath=rath,
+            instance_id=instance_id,
+        ),
+        healthz=FaktsHealthz(fakts_group="rekuest", fakts=fakts),
+    )

arkitekt_next/apps/service/unlok_next.py

@@ -0,0 +1,32 @@
+from herre import Herre
+from rath.contrib.fakts.links.aiohttp import FaktsAIOHttpLink
+from rath.contrib.fakts.links.graphql_ws import FaktsGraphQLWSLink
+from rath.contrib.herre.links.auth import HerreAuthLink
+from rath.links.split import SplitLink
+
+from arkitekt_next_next.healthz import FaktsHealthz
+from fakts import Fakts
+from graphql import OperationType
+from unlok_next.rath import UnlokLinkComposition, UnlokRath
+from unlok_next.unlok import Unlok
+
+
+class ArkitektNextUnlok(Unlok):
+    rath: UnlokRath
+    healthz: FaktsHealthz
+
+
+def build_arkitekt_next_unlok_next(herre: Herre, fakts: Fakts):
+    return ArkitektNextUnlok(
+        rath=UnlokRath(
+            link=UnlokLinkComposition(
+                auth=HerreAuthLink(herre=herre),
+                split=SplitLink(
+                    left=FaktsAIOHttpLink(fakts_group="lok", fakts=fakts),
+                    right=FaktsGraphQLWSLink(fakts_group="lok", fakts=fakts),
+                    split=lambda o: o.node.operation != OperationType.SUBSCRIPTION,
+                ),
+            )
+        ),
+        healthz=FaktsHealthz(fakts_group="lok", fakts=fakts),
+    )

arkitekt_next/apps/types.py

@@ -0,0 +1,53 @@
+"""
+This module contains the types for the apps
+depending on the builder used.
+
+This module imports all the apps and their types
+and sets them as attributes on the App class, if they are available.
+If they are not available, they are set to Any, so that we can add
+an import exception to the app.
+
+
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+from arkitekt_next.model import Manifest
+from koil.composition import Composition
+from fakts import Fakts
+from herre import Herre
+
+logger = logging.getLogger(__name__)
+
+
+
+class App(Composition):
+    """An app that is built with the easy builder"""
+    fakts: Fakts
+    herre: Herre
+    manifest: Manifest
+    services: Dict[str, Any]
+
+    def run(self):
+        """Run the app"""
+        self.services["rekuest"].run()
+
+
+    async def __aenter__(self):
+        await super().__aenter__()
+        print("Entering")
+        for service in self.services.values():
+            await service.__aenter__()
+
+        return self
+
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        for service in self.services.values():
+            await service.__aexit__(exc_type, exc_value, traceback)
+    
+
+    
+
+
+

arkitekt_next/builders.py

@@ -0,0 +1,264 @@
+from typing import List, Optional
+import logging
+import os
+
+from arkitekt_next.apps.service.fakts_next import build_arkitekt_next_fakts_next, build_arkitekt_next_redeem_fakts_next
+from arkitekt_next.apps.service.herre import build_arkitekt_next_herre
+from arkitekt_next.apps.service.fakts_qt import build_arkitekt_next_qt_fakts
+from arkitekt_next.apps.service.herre_qt import build_arkitekt_next_qt_herre
+from .utils import create_arkitekt_next_folder
+from .model import Manifest
+from .apps.types import App
+from .service_registry import ServiceBuilderRegistry, get_default_service_builder_registry
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+from qtpy import QtWidgets, QtCore
+
+
+def easy(
+    identifier: str,
+    version: str = "0.0.1",
+    logo: Optional[str] = None,
+    scopes: Optional[List[str]] = None,
+    url: str = DEFAULT_ARKITEKT_URL,
+    headless: bool = False,
+    log_level: str = "ERROR",
+    token: Optional[str] = None,
+    no_cache: bool = False,
+    redeem_token: Optional[str] = None,
+    app_kind: str = "development",
+    registry: Optional[ServiceBuilderRegistry] = None,
+    **kwargs,
+) -> App:
+    """Creates a next app
+
+    A simple way to create an ArkitektNext Next app, ArkitektNext next apps are
+    development apps by default, as they will try to register themselves
+    with services that are not yet available in production (such as the
+    rekuest_next and mikro_next services). They represent the next generation
+    of ArkitektNext apps, and will be the default way to create ArkitektNext apps
+    in the future. From here be dragons.
+
+    A few things to note:
+        -   The Next builder closely mimics the easy builder, but will use the
+            next generation of services (such as rekuest_next and mikro_next)
+            and will therefore not be compatible with the current generation.
+
+        -  Next apps will try to establish themselves a "development" apps, by default
+            which means that they will be authenticated with the ArkitektNext server on
+            a per user basis. If you want to create a "desktop" app, which multiple users
+            can use, you should set the `app_kind` to "desktop" TODO: Currently not implemented (use next app for this)
+        -  The Next builder can also be used in plugin apps, and when provided with a fakts token
+           will be able to connect to the ArkitektNext server without any user interaction.
+
+
+    Parameters
+    ----------
+    identifier : str
+        The apps identifier (should be globally unique, see Manifest for more info)
+    version : str, optional
+        The version of the app, by default "0.0.1"
+    logo : str, optional
+        The logo of the app as a public http url, by default None
+    scopes : List[str], optional
+        The scopes, that this apps requires, will default to standard scopes, by default None
+    url : str, optional
+        The fakts server that will be used to configure this app, in a default ArkitektNext deployment this
+        is the address of the "Lok Service" (which provides the Fakts API), by default DEFAULT_ARKITEKT_URL
+        Will be overwritten by the FAKTS_URL environment variable
+    headless : bool, optional
+        Should we run in headless, mode, e.g printing necessary interaction into the console (will forexample
+        stop opening browser windows), by default False
+    log_level : str, optional
+        The log-level to use, by default "ERROR"
+    token : str, optional
+        A fakts token to use, by default None
+        Will be overwritten by the FAKTS_TOKEN environment variable
+    no_cache : bool, optional
+        Should we skip caching token, acess-token, by default False
+        Attention: If this is set to True, the app will always have to be configured
+        and authenticated.
+    instance_id : str, optional
+        The instance_id to use, by default "main"
+        Can be set to a different value, if you want to run multiple intstances
+        of the same app by the same user.
+        Will be overwritten by the REKUEST_INSTANCE_ID environment variable
+    register_reaktion : bool, optional
+        Should we register the reaktion extension, by default True
+        If set to False, the app will not be able to use the reaktion extension
+        (which is necessary for scheduling in app` workflows from fluss)
+    app_kind : str, optional
+        The kind of app to create, by default "development"
+        Can be set to "desktop" to create a desktop app, that can be used by multiple users.
+
+    Returns
+    -------
+    NextApp
+        A built app, that can be used to interact with the ArkitektNext server
+    """
+    registry = registry or get_default_service_builder_registry()
+
+
+    manifest = Manifest(
+        version=version,
+        identifier=identifier,
+        scopes=scopes if scopes else ["openid"],
+        logo=logo,
+        requirements=registry.get_requirements(),
+    )
+
+
+    if redeem_token:
+        fakts = build_arkitekt_next_redeem_fakts_next(
+            manifest=manifest,
+            redeem_token=redeem_token,
+            url=url,
+            no_cache=no_cache,
+            headless=headless,
+        )
+    else:
+        fakts = build_arkitekt_next_fakts_next(
+            manifest=manifest,
+            url=url,
+            no_cache=no_cache,
+            headless=headless,
+            client_kind=app_kind,
+        )
+
+    herre = build_arkitekt_next_herre(fakts=fakts)
+
+    params = kwargs
+
+
+
+    url = os.getenv("FAKTS_URL", url)
+    token = os.getenv("FAKTS_TOKEN", token)
+
+    create_arkitekt_next_folder(with_cache=True)
+
+    
+
+    try:
+        from rich.logging import RichHandler
+
+        logging.basicConfig(level=log_level, handlers=[RichHandler()])
+    except ImportError:
+        logging.basicConfig(level=log_level)
+
+    print(registry.service_builders)
+
+    app = App(
+        fakts=fakts,
+        herre=herre,
+        manifest=manifest,
+        services=registry.build_service_map(fakts=fakts, herre=herre, params=params),
+    )
+
+    print()
+
+
+    return app
+
+
+
+
+def publicqt(
+    identifier: str,
+    version: str = "latest",
+    logo: Optional[str] = None,
+    scopes: Optional[List[str]] = None,
+    url: str = "http://localhost:11000",
+    headless: bool = False,
+    log_level: str = "ERROR",
+    token: Optional[str] = None,
+    no_cache: bool = False,
+    instance_id: str = "main",
+    redeem_token: Optional[str] = None,
+    app_kind: str = "desktop",
+    registry: Optional[ServiceBuilderRegistry] = None,
+    parent: Optional[QtWidgets.QWidget] =None,
+    beacon_widget: Optional[QtWidgets.QWidget]=None,
+    login_widget: Optional[QtWidgets.QWidget]=None,
+    settings: Optional[QtCore.QSettings]=None,
+    **kwargs,
+) -> App:
+    """Public QtApp creation
+
+    A simple way to create an Arkitekt app with a public grant (allowing users to sign
+    in with the application ) utlizing a retrieve grant (necessating a previous configuration
+    of the application on the server side)
+
+    Args:
+        identifier (str): The apps identifier
+        version (str, optional): The apps verion. Defaults to "latest".
+        parent (QtWidget, optional): The QtParent (for the login and server select widget). Defaults to None.
+
+    Returns:
+        Arkitekt: The Arkitekt app
+    """
+
+    from arkitekt.apps.qt import build_arkitekt_qt_app
+
+    registry = registry or get_default_service_builder_registry()
+
+
+    manifest = Manifest(
+        version=version,
+        identifier=identifier,
+        scopes=scopes if scopes else ["openid"],
+        logo=logo,
+        requirements=registry.get_requirements(),
+    )
+
+
+    if redeem_token:
+        fakts = build_arkitekt_next_redeem_fakts_next(
+            manifest=manifest,
+            redeem_token=redeem_token,
+            url=url,
+            no_cache=no_cache,
+            headless=headless,
+        )
+    else:
+        fakts = build_arkitekt_next_qt_fakts(
+            manifest=manifest,
+            url=url,
+            no_cache=no_cache,
+            client_kind=app_kind,
+            beacon_widget=beacon_widget,
+            settings=settings,
+        )
+
+    herre = build_arkitekt_next_qt_herre(manifest=manifest, fakts=fakts, login_widget=login_widget, parent=parent, settings=settings)
+
+    params = kwargs
+
+
+
+    url = os.getenv("FAKTS_URL", url)
+    token = os.getenv("FAKTS_TOKEN", token)
+
+    create_arkitekt_next_folder(with_cache=True)
+
+    
+
+    try:
+        from rich.logging import RichHandler
+
+        logging.basicConfig(level=log_level, handlers=[RichHandler()])
+    except ImportError:
+        logging.basicConfig(level=log_level)
+
+    print(registry.service_builders)
+
+    app = App(
+        fakts=fakts,
+        herre=herre,
+        manifest=manifest,
+        services=registry.build_service_map(fakts=fakts, herre=herre, params=params),
+    )
+
+    print()
+
+
+    app.enter()
+    return app

arkitekt_next/cli/commands/call/local.py

@@ -0,0 +1,132 @@
+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
+from arkitekt_next.cli.utils import import_builder
+from rekuest.api.schema import (
+    NodeKind,
+    ReserveBindsInput,
+)
+from rich.table import Table
+from rich.console import Console
+from typing import Dict, Any
+
+
+async def call_app(
+    console: Console,
+    app: App,
+    template_string: str,
+    arg: Dict[str, Any],
+):
+    async with app:
+        await app.rekuest.agent.aregister_definitions()
+
+        run_task = asyncio.create_task(app.rekuest.run())
+
+        template = app.rekuest.agent.interface_template_map[template_string]
+
+        async with arkiuse(
+            hash=template.node.hash,
+            binds=ReserveBindsInput(templates=[template.id], clients=[]),
+            postman=app.rekuest.postman,
+        ) as a:
+            if template.node.kind == NodeKind.GENERATOR:
+                async for i in a.astream(kwargs=arg):
+                    table = Table(title=f"Yields of {template.node.name}")
+                    table.add_column("key")
+                    table.add_column("value")
+
+                    for key, value in i.items():
+                        table.add_row(key, value)
+
+                    console.print(table)
+
+            else:
+                i = await a.aassign(kwargs=arg)
+                table = Table(title=f"Returns of {template.node.name}")
+                table.add_column("key")
+                table.add_column("value")
+
+                for key, value in i.items():
+                    table.add_row(key, value)
+
+                console.print(table)
+
+        run_task.cancel()
+
+        try:
+            await run_task
+        except asyncio.CancelledError:
+            pass
+
+
+@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(
+    "--template",
+    "-t",
+    "template",
+    help="The template to run",
+    type=str,
+)
+def local(
+    ctx,
+    entrypoint=None,
+    builder=None,
+    args=None,
+    template: str = None,
+    **builder_kwargs,
+):
+    """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.
+
+    """
+
+    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(console, app, template, kwargs))

arkitekt_next/cli/commands/call/main.py

@@ -0,0 +1,22 @@
+import rich_click as click
+
+
+import rich_click as click
+from .remote import remote
+from .local import local
+
+
+@click.group()
+@click.pass_context
+def call(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.
+
+    """
+
+
+call.add_command(local, "local")
+call.add_command(remote, "remote")