arkitekt-next 0.7.8__py3-none-any.whl

arkitekt_next/__init__.py

@@ -0,0 +1,43 @@
+def missing_install(name: str, error: Exception):
+    def real_missing_install(*args, **kwargs):
+        raise ImportError(
+            f"Missing import: {name}. Please install the missing package. "
+        ) from error
+
+    return real_missing_install
+
+
+try:
+    from rekuest_next.register import register
+    from rekuest_next.agents.hooks import background
+    from rekuest_next.agents.hooks import startup
+except ImportError as e:
+    raise e
+    register = missing_install("rekuest_next", e)
+    background = missing_install("rekuest_next", e)
+    startup = missing_install("rekuest_next", e)
+
+from .builders import easy
+from .apps.types import App
+
+__all__ = [
+    "App",
+    "register",
+    "easy",
+    "publicqt",
+    "jupy",
+    "log",
+    "alog",
+    "progress",
+    "aprogress",
+    "scheduler",
+    "register_structure",
+    "group",
+    "useGuardian",
+    "useInstanceID",
+    "useUser",
+    "next",
+    "background",
+    "startup",
+    "register_next",
+]

arkitekt_next/apps/__init__.py

@@ -0,0 +1,3 @@
+from .types import App
+
+__all__ = ["App"]

arkitekt_next/apps/easy.py

@@ -0,0 +1,99 @@
+from .types import EasyApp
+from typing import Optional, List
+
+
+def build_arkitekt_app(
+    manifest: Manifest,
+    url=None,
+    no_cache=False,
+    headless=False,
+    instance_id=None,
+    token=None,
+    app_kind="development",
+    redeem_token=None,
+):
+    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)
+
+    try:
+        from arkitekt_next_next.apps.service.rekuest_next import build_arkitekt_next_rekuest_next
+
+        rekuest = build_arkitekt_next_rekuest_next(
+            fakts=fakts, herre=herre, instance_id=instance_id
+        )
+    except ImportError as e:
+        rekuest = ImportException(import_exception=e, install_library="rekuest_next")
+
+    try:
+        from arkitekt_next_next.apps.service.mikro_next import build_arkitekt_next_mikro_next
+
+        mikro = build_arkitekt_next_mikro_next(fakts=fakts, herre=herre)
+    except ImportError as e:
+        raise e
+        mikro = ImportException(import_exception=e, install_library="mikro_next")
+
+    try:
+        from arkitekt_next_next.apps.service.fluss_next import build_arkitekt_next_fluss
+
+        fluss = build_arkitekt_next_fluss(herre=herre, fakts=fakts)
+    except ImportError as e:
+        raise e
+        fluss = ImportException(import_exception=e, install_library="fluss_next")
+
+    try:
+        from arkitekt_next_next.apps.service.unlok_next import build_arkitekt_next_unlok_next
+
+        unlok = build_arkitekt_next_unlok_next(herre=herre, fakts=fakts)
+    except ImportError as e:
+        raise e
+        fluss = ImportException(import_exception=e, install_library="fluss_next")
+
+    try:
+        from arkitekt_next_next.apps.service.omero_ark import build_arkitekt_next_omero_ark
+
+        omero_ark = build_arkitekt_next_omero_ark(herre=herre, fakts=fakts)
+    except ImportError as e:
+        omero_ark = ImportException(import_exception=e, install_library="omero_ark")
+
+    try:
+        from arkitekt_next_next.apps.service.kluster import build_arkitekt_next_kluster
+
+        kluster = build_arkitekt_next_kluster(herre=herre, fakts=fakts)
+    except ImportError as e:
+        kluster = ImportException(import_exception=e, install_library="kluster")
+
+    try:
+        from arkitekt_next_next.apps.service.kabinet import build_arkitekt_next_kabinet
+
+        kabinet = build_arkitekt_next_kabinet(herre=herre, fakts=fakts)
+    except ImportError as e:
+        kabinet = ImportException(import_exception=e, install_library="kluster")
+
+    return NextApp(
+        manifest=manifest,
+        fakts=fakts,
+        herre=herre,
+        rekuest=rekuest,
+        mikro=mikro,
+        kabinet=kabinet,
+        unlok=unlok,
+        fluss=fluss,
+        kluster=kluster,
+        omero_ark=omero_ark,
+    )

arkitekt_next/apps/next.py

@@ -0,0 +1,40 @@
+from arkitekt_next_next.apps.fallbacks import ImportException
+from arkitekt_next_next.apps.service.fakts_next import (
+    build_arkitekt_next_fakts_next,
+    build_arkitekt_next_redeem_fakts_next,
+)
+from arkitekt_next_next.apps.service.herre import build_arkitekt_next_herre
+from arkitekt_next_next.model import Manifest
+
+from .types import NextApp
+
+
+def build_next_app(
+    manifest: Manifest,
+    url=None,
+    no_cache=False,
+    headless=False,
+    instance_id=None,
+    token=None,
+    app_kind="development",
+    redeem_token=None,
+):
+    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)
+

arkitekt_next/apps/qt.py

@@ -0,0 +1,97 @@
+from arkitekt_next_next.model import Manifest
+from arkitekt_next_next.apps.types import QtApp
+from arkitekt_next_next.apps.fallbacks import ImportException, InstallModuleException
+from typing import Any, Optional
+
+
+def build_arkitekt_next_qt_app(
+    manifest: Manifest,
+    no_cache: bool = False,
+    instance_id: Optional[str] = None,
+    beacon_widget: Any = None,
+    login_widget: Any = None,
+    parent: Any = None,
+    settings: Any = None,
+):
+    try:
+        from koil.composition.qt import QtPedanticKoil
+        from qtpy import QtCore
+
+        settings = settings or QtCore.QSettings()
+    except ImportError as e:
+        raise InstallModuleException("Please install qtpy to use arkitekt_next_qt") from e
+
+    try:
+        from arkitekt_next_next.apps.service.fakts_qt import build_arkitekt_next_qt_fakts
+
+        fakts = build_arkitekt_next_qt_fakts(
+            manifest=manifest,
+            no_cache=no_cache,
+            beacon_widget=beacon_widget,
+            parent=parent,
+            settings=settings,
+        )
+    except ImportError as e:
+        fakts = ImportException(import_exception=e, install_library="qtpy")
+
+    try:
+        from arkitekt_next_next.apps.service.herre_qt import build_arkitekt_next_qt_herre
+
+        herre = build_arkitekt_next_qt_herre(
+            manifest=manifest,
+            fakts=fakts,
+            login_widget=login_widget,
+            parent=parent,
+            settings=settings,
+        )
+    except ImportError as e:
+        herre = ImportException(import_exception=e, install_library="qtpy")
+
+    try:
+        from arkitekt_next_next.apps.service.rekuest import build_arkitekt_next_rekuest
+
+        rekuest = build_arkitekt_next_rekuest(
+            fakts=fakts, herre=herre, instance_id=instance_id or "main"
+        )
+    except ImportError as e:
+        rekuest = ImportException(import_exception=e, install_library="rekuest")
+
+    try:
+        from arkitekt_next_next.apps.service.mikro import build_arkitekt_next_mikro
+
+        mikro = build_arkitekt_next_mikro(fakts=fakts, herre=herre)
+    except ImportError as e:
+        mikro = ImportException(import_exception=e, install_library="mikro")
+
+    try:
+        from arkitekt_next_next.apps.service.unlok import build_arkitekt_next_unlok
+
+        unlok = build_arkitekt_next_unlok(herre=herre, fakts=fakts)
+    except ImportError as e:
+        unlok = ImportException(import_exception=e, install_library="unlok")
+
+    try:
+        from arkitekt_next_next.apps.service.fluss import build_arkitekt_next_fluss
+
+        fluss = build_arkitekt_next_fluss(herre=herre, fakts=fakts)
+    except ImportError as e:
+        fluss = ImportException(import_exception=e, install_library="fluss")
+
+    try:
+        from arkitekt_next_next.apps.service.kluster import build_arkitekt_next_kluster
+
+        kluster = build_arkitekt_next_kluster(herre=herre, fakts=fakts)
+    except ImportError as e:
+        kluster = ImportException(import_exception=e, install_library="kluster")
+
+    return QtApp(
+        koil=QtPedanticKoil(parent=parent),
+        manifest=manifest,
+        fakts=fakts,
+        herre=herre,
+        rekuest=rekuest,
+        mikro=mikro,
+        unlok=unlok,
+        fluss=fluss,
+        kluster=kluster,
+    )

arkitekt_next/apps/service/__init__.py

@@ -0,0 +1,3 @@
+""" Modules for services, all services should be placed here.
+Services SHOULD not be used directly, but build through the
+builders in arkitekt_next/apps."""

arkitekt_next/apps/service/fakts.py

@@ -0,0 +1,88 @@
+from fakts.fakts import Fakts
+from fakts.fakts import Fakts
+from typing import Optional
+from fakts.grants.remote.discovery.well_known import WellKnownDiscovery
+from fakts.grants.remote import RemoteGrant
+from fakts.grants.remote.demanders.auto_save import AutoSaveDemander
+from fakts.grants.remote.demanders.cache import CacheTokenStore
+from fakts.grants.remote.demanders.static import StaticDemander
+from fakts.grants.remote.demanders.device_code import DeviceCodeDemander
+from fakts.grants.remote.claimers.post import ClaimEndpointClaimer
+from fakts.grants.remote.demanders.redeem import RedeemDemander
+from arkitekt_next_next.model import Manifest
+
+
+class ArkitektNextFaktsQt(Fakts):
+    grant: RemoteGrant
+
+
+class ArkitektNextFakts(Fakts):
+    pass
+
+
+def build_arkitekt_next_fakts(
+    manifest: Manifest,
+    url: Optional[str] = None,
+    no_cache: bool = False,
+    headless: bool = False,
+) -> ArkitektNextFakts:
+    identifier = manifest.identifier
+    version = manifest.version
+
+    if no_cache:
+        demander = DeviceCodeDemander(
+            manifest=manifest,
+            redirect_uri="http://127.0.0.1:6767",
+            open_browser=not headless,
+        )
+
+    else:
+        demander = AutoSaveDemander(
+            demander=DeviceCodeDemander(
+                manifest=manifest,
+                redirect_uri="http://127.0.0.1:6767",
+                open_browser=not headless,
+            ),
+            store=CacheTokenStore(
+                cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json"
+            ),
+        )
+
+    return ArkitektNextFakts(
+        grant=RemoteGrant(
+            demander=demander,
+            discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )
+
+
+def build_arkitekt_next_token_fakts(
+    manifest: Manifest,
+    token: str,
+    url,
+    no_cache: Optional[bool] = False,
+    headless=False,
+):
+    return ArkitektNextFakts(
+        grant=RemoteGrant(
+            demander=StaticDemander(token=token),
+            discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )
+
+def build_arkitekt_next_redeem_fakts(
+    manifest: Manifest,
+    redeem_token: str,
+    url,
+    no_cache: Optional[bool] = False,
+    headless=False,
+):
+    return ArkitektNextFakts(
+        grant=RemoteGrant(
+            demander=RedeemDemander(token=redeem_token, manifest=manifest),
+            discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )

arkitekt_next/apps/service/fakts_next.py

@@ -0,0 +1,79 @@
+from typing import Optional
+
+from fakts.fakts import Fakts
+from fakts.grants.remote import RemoteGrant
+from fakts.grants.remote.discovery.well_known import WellKnownDiscovery
+from fakts.grants.remote import RemoteGrant
+from fakts.grants.remote.demanders.auto_save import AutoSaveDemander
+from fakts.grants.remote.demanders.cache import CacheTokenStore
+from fakts.grants.remote.demanders.static import StaticDemander
+from fakts.grants.remote.demanders.device_code import DeviceCodeDemander
+from fakts.grants.remote.claimers.post import ClaimEndpointClaimer
+from fakts.grants.remote.demanders.redeem import RedeemDemander
+
+from arkitekt_next.model import Manifest
+
+
+class ArkitektNextFaktsQt(Fakts):
+    grant: RemoteGrant
+
+
+class ArkitektNextFaktsNext(Fakts):
+    pass
+
+
+def build_arkitekt_next_fakts_next(
+    manifest: Manifest,
+    url: Optional[str] = None,
+    no_cache: bool = False,
+    headless: bool = False,
+    client_kind: str = "development",
+) -> ArkitektNextFaktsNext:
+    identifier = manifest.identifier
+    version = manifest.version
+
+    if no_cache:
+        demander = DeviceCodeDemander(
+            manifest=manifest,
+            redirect_uri="http://127.0.0.1:6767",
+            open_browser=not headless,
+            requested_client_kind=client_kind,
+        )
+
+    else:
+        demander = AutoSaveDemander(
+            demander=DeviceCodeDemander(
+                manifest=manifest,
+                redirect_uri="http://127.0.0.1:6767",
+                open_browser=not headless,
+                requested_client_kind=client_kind,
+            ),
+            store=CacheTokenStore(
+                cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
+                hash=manifest.hash(),
+            ),
+        )
+
+    return ArkitektNextFaktsNext(
+        grant=RemoteGrant(
+            demander=demander,
+            discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )
+
+
+def build_arkitekt_next_redeem_fakts_next(
+    manifest: Manifest,
+    redeem_token: str,
+    url,
+    no_cache: Optional[bool] = False,
+    headless=False,
+):
+    return ArkitektNextFaktsNext(
+        grant=RemoteGrant(
+            demander=RedeemDemander(token=redeem_token, manifest=manifest),
+            discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )

arkitekt_next/apps/service/fakts_qt.py

@@ -0,0 +1,82 @@
+from fakts.fakts import Fakts
+from typing import Optional
+from fakts.grants.remote import RemoteGrant
+from fakts.grants.remote.demanders.auto_save import AutoSaveDemander
+from fakts.grants.remote.discovery.auto_save import AutoSaveDiscovery
+from fakts.grants.remote.discovery.qt.auto_save_endpoint_widget import (
+    AutoSaveEndpointWidget,
+)
+from fakts.grants.remote.discovery.qt.qt_settings_endpoint_store import (
+    QtSettingsEndpointStore,
+)
+from fakts.grants.remote.demanders.qt.qt_settings_token_store import QTSettingTokenStore
+
+from fakts.grants.remote.demanders.retrieve import RetrieveDemander
+from fakts.grants.remote.claimers.post import ClaimEndpointClaimer
+from fakts.grants.remote.discovery.qt.selectable_beacon import (
+    SelectBeaconWidget,
+    QtSelectableDiscovery,
+)
+from arkitekt_next.model import Manifest
+from qtpy import QtCore, QtWidgets
+
+
+class ArkitektNextFaktsAutoSaveDiscovery(AutoSaveDiscovery):
+    """An ArkitektNext Fakts discovery that uses Qt widgets for token and endpoint storage"""
+
+    discovery: QtSelectableDiscovery
+
+
+class ArkitektNextFaktsQtRemoteGrant(RemoteGrant):
+    """An ArkitektNext Fakts grant that uses Qt widgets for token and endpoint storage"""
+
+    discovery: ArkitektNextFaktsAutoSaveDiscovery
+
+
+class ArkitektNextFaktsQt(Fakts):
+    """A Fakts that uses Qt widgets for token and endpoint storage"""
+
+    grant: ArkitektNextFaktsQtRemoteGrant
+
+
+def build_arkitekt_next_qt_fakts(
+    manifest: Manifest,
+    no_cache: Optional[bool] = False,
+    beacon_widget: Optional[QtWidgets.QWidget] = None,
+    parent: Optional[QtWidgets.QWidget] = None,
+    settings: Optional[QtCore.QSettings] = None,
+) -> ArkitektNextFaktsQt:
+    beacon_widget = beacon_widget or SelectBeaconWidget(
+        parent=parent, settings=settings
+    )
+
+    return ArkitektNextFaktsQt(
+        grant=RemoteGrant(
+            demander=AutoSaveDemander(
+                store=QTSettingTokenStore(
+                    settings=settings,
+                    save_key="fakts_token",
+                ),
+                demander=RetrieveDemander(
+                    manifest=manifest,
+                    redirect_uri="http://127.0.0.1:6767",
+                ),
+            ),
+            discovery=AutoSaveDiscovery(
+                store=QtSettingsEndpointStore(
+                    settings=settings,
+                    save_key="fakts_endpoint",
+                ),
+                decider=AutoSaveEndpointWidget(
+                    parent=parent,
+                ),
+                discovery=QtSelectableDiscovery(
+                    widget=beacon_widget,
+                    settings=settings,
+                    allow_appending_slash=True,
+                    auto_protocols=["http", "https"],
+                ),
+            ),
+            claimer=ClaimEndpointClaimer(),
+        )
+    )

arkitekt_next/apps/service/fluss_next.py

@@ -0,0 +1,31 @@
+from fluss_next.fluss import Fluss
+from fluss_next.rath import FlussLinkComposition, FlussRath
+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 ArkitektNextFluss(Fluss):
+    rath: FlussRath
+    healthz: FaktsHealthz
+
+
+def build_arkitekt_next_fluss(herre: Herre, fakts: Fakts):
+    return ArkitektNextFluss(
+        rath=FlussRath(
+            link=FlussLinkComposition(
+                auth=HerreAuthLink(herre=herre),
+                split=SplitLink(
+                    left=FaktsAIOHttpLink(fakts_group="fluss", fakts=fakts),
+                    right=FaktsGraphQLWSLink(fakts_group="fluss", fakts=fakts),
+                    split=lambda o: o.node.operation != OperationType.SUBSCRIPTION,
+                ),
+            )
+        ),
+        healthz=FaktsHealthz(fakts_group="fluss", fakts=fakts),
+    )

arkitekt_next/apps/service/grant_registry.py

@@ -0,0 +1,27 @@
+from herre.fakts.grant import FaktsGrant
+from herre.fakts.registry import GrantRegistry, GrantType
+from herre.grants.oauth2.authorization_code import AuthorizationCodeGrant
+from herre.grants.oauth2.redirecters.aiohttp_server import AioHttpServerRedirecter
+from herre.grants.oauth2.client_credentials import ClientCredentialsGrant
+
+
+ARKITEKT_GRANT_REGISTRY = GrantRegistry()
+
+
+def build_authorization_code_grant(**kwargs) -> FaktsGrant:
+    return AuthorizationCodeGrant(**kwargs, redirecter=AioHttpServerRedirecter())
+
+
+def build_client_credentials_grant(**kwargs) -> FaktsGrant:
+    return ClientCredentialsGrant(**kwargs)
+
+
+ARKITEKT_GRANT_REGISTRY.register_grant(
+    GrantType.AUTHORIZATION_CODE,
+    build_authorization_code_grant,
+)
+
+ARKITEKT_GRANT_REGISTRY.register_grant(
+    GrantType.CLIENT_CREDENTIALS,
+    build_client_credentials_grant,
+)

arkitekt_next/apps/service/herre.py

@@ -0,0 +1,24 @@
+from herre.herre import Herre
+from fakts import Fakts
+from herre.grants.oauth2.refresh import RefreshGrant
+from herre.fakts.fakts_endpoint_fetcher import FaktsUserFetcher
+from herre.fakts.grant import FaktsGrant
+from arkitekt_next.model import User
+from arkitekt_next.apps.service.grant_registry import ARKITEKT_GRANT_REGISTRY
+
+
+class ArkitektNextHerre(Herre):
+    pass
+
+
+def build_arkitekt_next_herre(fakts: Fakts) -> ArkitektNextHerre:
+    return ArkitektNextHerre(
+        grant=RefreshGrant(
+            grant=FaktsGrant(
+                fakts=fakts, fakts_group="lok", grant_registry=ARKITEKT_GRANT_REGISTRY
+            ),
+        ),
+        fetcher=FaktsUserFetcher(
+            fakts=fakts, fakts_key="lok.userinfo_url", userModel=User
+        ),
+    )

arkitekt_next/apps/service/herre_qt.py

@@ -0,0 +1,57 @@
+from herre.herre import Herre
+from fakts import Fakts
+from herre.grants.oauth2.refresh import RefreshGrant
+from herre.fakts.grant import FaktsGrant
+from herre.fakts.fakts_qt_store import FaktsQtStore
+
+from herre.grants.auto_login import AutoLoginGrant
+from herre.grants.qt.auto_login import AutoLoginWidget
+from herre.fakts.fakts_endpoint_fetcher import FaktsUserFetcher
+from arkitekt_next.model import Manifest, User
+from arkitekt_next.apps.service.grant_registry import ARKITEKT_GRANT_REGISTRY
+
+
+class ArkitektNextAutoLogin(AutoLoginGrant):
+    store: FaktsQtStore
+    fetcher: FaktsUserFetcher
+    grant: FaktsGrant
+
+
+class ArkitektNextRefreshGrant(RefreshGrant):
+    grant: ArkitektNextAutoLogin
+
+
+class ArkitektNextHerreQt(Herre):
+    grant: ArkitektNextRefreshGrant
+
+
+def build_arkitekt_next_qt_herre(
+    manifest: Manifest,
+    fakts: Fakts,
+    login_widget=None,
+    parent=None,
+    settings=None,
+):
+    login_widget = login_widget or AutoLoginWidget(parent=parent)
+
+    grant = ArkitektNextAutoLogin(
+        store=FaktsQtStore(
+            fakts=fakts,
+            settings=settings,
+            fakts_key="lok.endpoint_url",
+        ),
+        widget=login_widget,
+        fetcher=FaktsUserFetcher(
+            fakts=fakts, fakts_key="lok.userinfo_url", userModel=User
+        ),
+        grant=FaktsGrant(
+            fakts=fakts, fakts_group="lok", grant_registry=ARKITEKT_GRANT_REGISTRY
+        ),
+    )
+
+    return ArkitektNextHerreQt(
+        grant=ArkitektNextRefreshGrant(grant=grant),
+        fetcher=FaktsUserFetcher(
+            fakts=fakts, fakts_key="lok.userinfo_url", userModel=User
+        ),
+    )