arkitekt-next 0.13.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -10,6 +10,8 @@ from arkitekt_next.bloks.postgres import PostgresBlok
 from arkitekt_next.bloks.minio import MinioBlok
 from arkitekt_next.bloks.kabinet import KabinetBlok
 from arkitekt_next.bloks.lok import LokBlok
+from arkitekt_next.bloks.alpaka import AlpakaBlok
+from arkitekt_next.bloks.lovekit import LovekitBlok
 from arkitekt_next.bloks.config import ConfigBlok
 from arkitekt_next.bloks.mount import MountBlok
 from arkitekt_next.bloks.internal_docker import InternalDockerBlok
@@ -33,6 +35,8 @@ def get_bloks() -> list[Blok]:
         FlussBlok(),
         RedisBlok(),
         CaddyBlok(),
+        AlpakaBlok(),
+        LovekitBlok(),
         LocalLiveKitBlok(),
         PostgresBlok(),
         MinioBlok(),

arkitekt_next/__init__.py

@@ -1,5 +1,5 @@
 from .builders import easy, interactive
-from .apps.protocols import App
+from .app.app import App
 from fakts_next.helpers import afakt, fakt
 from .init_registry import init, InitHookRegistry, get_default_init_hook_registry
 from .service_registry import (

arkitekt_next/app/__init__.py

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

arkitekt_next/{apps/protocols.py → app/app.py}

@@ -12,10 +12,8 @@ an import exception to the app.
 import logging
 from typing import Any, Dict, TYPE_CHECKING
 from koil import unkoil
-from arkitekt_next.base_models import Manifest
 from koil.composition import Composition
 from fakts_next import Fakts
-from herre_next import Herre
 
 
 if TYPE_CHECKING:
@@ -29,8 +27,6 @@ class App(Composition):
     """An app that is built with the easy builder"""
 
     fakts: Fakts
-    herre: Herre
-    manifest: Manifest
     services: Dict[str, Any]
 
     @property
@@ -55,6 +51,14 @@ class App(Composition):
 
         self.rekuest.register(*args, **kwargs)
 
+    def register_startup(self, *args, **kwargs):
+        """Register a startup service"""
+        self.rekuest.register_startup(*args, **kwargs)
+
+    def register_background(self, *args, **kwargs):
+        """Register a background service"""
+        self.rekuest.register_background(*args, **kwargs)
+
     async def __aenter__(self):
         await super().__aenter__()
         for service in self.services.values():

arkitekt_next/{apps/service/fakts_next.py → app/fakts.py}

@@ -11,10 +11,10 @@ from fakts_next.grants.remote.demanders.device_code import (
 from fakts_next.grants.remote.claimers.post import ClaimEndpointClaimer
 from fakts_next.grants.remote.demanders.redeem import RedeemDemander
 from fakts_next.cache.file import FileCache
-from arkitekt_next.base_models import Manifest
+from fakts_next.models import Manifest
 
 
-def build_arkitekt_next_fakts_next(
+def build_device_code_fakts(
     manifest: Manifest,
     url: Optional[str] = None,
     no_cache: bool = False,
@@ -37,6 +37,7 @@ def build_arkitekt_next_fakts_next(
             discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
             claimer=ClaimEndpointClaimer(),
         ),
+        manifest=manifest,
         cache=FileCache(
             cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
             hash=manifest.hash() + url,
@@ -44,11 +45,12 @@ def build_arkitekt_next_fakts_next(
     )
 
 
-def build_arkitekt_next_redeem_fakts_next(manifest: Manifest, redeem_token: str, url: str) -> Fakts:
+def build_redeem_fakts(manifest: Manifest, redeem_token: str, url: str) -> Fakts:
     identifier = manifest.identifier
     version = manifest.version
 
     return Fakts(
+        manifest=manifest,
         grant=RemoteGrant(
             demander=RedeemDemander(token=redeem_token, manifest=manifest),
             discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
@@ -61,7 +63,7 @@ def build_arkitekt_next_redeem_fakts_next(manifest: Manifest, redeem_token: str,
     )
 
 
-def build_arkitekt_next_token_fakts_next(
+def build_token_fakts(
     manifest: Manifest,
     token: str,
     url: str,
@@ -70,6 +72,7 @@ def build_arkitekt_next_token_fakts_next(
     version = manifest.version
 
     return Fakts(
+        manifest=manifest,
         grant=RemoteGrant(
             demander=StaticDemander(token=token),  # type: ignore
             discovery=WellKnownDiscovery(url=url, auto_protocols=["https", "http"]),
@@ -80,4 +83,3 @@ def build_arkitekt_next_token_fakts_next(
             hash=manifest.hash() + url,
         ),
     )
-

arkitekt_next/bloks/admin.py

@@ -2,7 +2,7 @@ from blok import blok, InitContext, Option
 from arkitekt_next.bloks.services.admin import AdminService, AdminCredentials
 
 
-@blok(AdminService, description="sdmin credentials for the application")
+@blok(AdminService, description="Admin credentials for the application")
 class AdminBlok:
     def __init__(self) -> None:
         self.password = "admin"

arkitekt_next/bloks/alpaka.py

@@ -1,3 +1,4 @@
+from dataclasses import asdict
 from typing import Dict, Any
 import secrets
 
@@ -9,6 +10,7 @@ from arkitekt_next.bloks.services.db import DBService
 from arkitekt_next.bloks.services.gateway import GatewayService
 from arkitekt_next.bloks.services.lok import LokService
 from arkitekt_next.bloks.services.mount import MountService
+from arkitekt_next.bloks.services.ollama import OllamaService
 from arkitekt_next.bloks.services.redis import RedisService
 from arkitekt_next.bloks.services.s3 import S3Service
 from arkitekt_next.bloks.services.secret import SecretService
@@ -20,6 +22,9 @@ from arkitekt_next.bloks.base import BaseArkitektService
 
 @blok("live.arkitekt.alpaka", description="a container and app management service")
 class AlpakaBlok(BaseArkitektService):
+    def get_builder(self):
+        return "arkitekt.generic"
+
     def __init__(self) -> None:
         self.dev = False
         self.host = "alpaka"
@@ -35,23 +40,18 @@ class AlpakaBlok(BaseArkitektService):
         self.secret_key = secrets.token_hex(16)
         self.image = "jhnnsrs/alpaka:nightly"
 
-    def get_additional_config(self):
-        return {"ensured_repos": self.ensured_repos}
-
     def preflight(
         self,
-        init: InitContext,
         lok: LokService,
         db: DBService,
         redis: RedisService,
         s3: S3Service,
         config: ConfigService,
-        channel: ChannelService,
+        ollama: OllamaService,
         mount: MountService,
         admin: AdminService,
         secret: SecretService,
-        gateway: GatewayService | None = None,
-        dns: DnsService = None,
+        gateway: GatewayService,
         mount_repo: bool = False,
         host: str = "",
         image: str = "",
@@ -62,43 +62,75 @@ class AlpakaBlok(BaseArkitektService):
         disable: bool = False,
         dev: bool = False,
     ):
-        return super().preflight(
-            init,
-            lok,
-            db,
-            redis,
-            s3,
-            config,
-            channel,
-            mount,
-            admin,
-            secret,
-            gateway,
-            dns,
-            mount_repo,
-            host,
-            image,
-            secret_key,
-            build_repo,
-            command,
-            repo,
-            disable,
-            dev,
-        )
+        lok.register_scopes(self.scopes)
 
-    def get_builder(self):
-        return "arkitekt.generic"
+        path_name = self.host
+
+        gateway.expose(path_name, 80, self.host)
+
+        postgress_access = db.register_db(self.host)
+        redis_access = redis.register()
+        lok_access = lok.retrieve_credentials()
+        admin_access = admin.retrieve()
+        minio_access = s3.create_buckets(self.buckets)
+        lok_labels = lok.retrieve_labels("live.arkitekt.alpaka", self.get_builder())
+        ollama_access = ollama.get_access()
 
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)
+        django_secret = secret.retrieve_secret()
 
-    def get_additional_options(self):
-        with_repos = Option(
-            subcommand="repos",
-            help="The default repos to enable for the service",
-            default=self.secret_key,
+        csrf_trusted_origins = []
+
+        configuration = YamlFile(
+            **{
+                "db": asdict(postgress_access),
+                "django": {
+                    "admin": asdict(admin_access),
+                    "debug": True,
+                    "hosts": ["*"],
+                    "secret_key": django_secret,
+                },
+                "redis": asdict(redis_access),
+                "lok": asdict(lok_access),
+                "s3": asdict(minio_access),
+                "scopes": self.scopes,
+                "force_script_name": path_name,
+                "csrf_trusted_origins": csrf_trusted_origins,
+                **self.get_additional_config(),
+            }
         )
 
-        return [
-            with_repos,
-        ]
+        config_mount = config.register_config(f"{self.host}.yaml", configuration)
+
+        depends_on = []
+
+        if redis_access.dependency:
+            depends_on.append(redis_access.dependency)
+
+        if postgress_access.dependency:
+            depends_on.append(postgress_access.dependency)
+
+        if minio_access.dependency:
+            depends_on.append(minio_access.dependency)
+
+        if ollama_access.dependency:
+            depends_on.append(ollama_access.dependency)
+
+        service = {
+            "labels": lok_labels,
+            "volumes": [f"{config_mount}:/workspace/config.yaml"],
+            "depends_on": depends_on,
+        }
+
+        if mount_repo or dev:
+            mount = mount.register_mount(self.host, Repo(repo))
+            service["volumes"].extend([f"{mount}:/workspace"])
+
+        if build_repo or dev:
+            mount = mount.register_mount(self.host, Repo(repo))
+            service["build"] = mount
+        else:
+            service["image"] = image
+
+        service["command"] = command
+
+        self.service = service

arkitekt_next/bloks/arkitekt.py

@@ -10,12 +10,13 @@ from blok import InitContext, Panel, Renderer, blok
 from .fluss import FlussBlok
 from .internal_docker import InternalDockerBlok
 from .kabinet import KabinetBlok
-from .livekit import LocalLiveKitBlok
 from .mikro import MikroBlok
 from .orkestrator import OrkestratorBlok
 from .rekuest import RekuestBlok
 from .ollama import OllamaBlok
 from .elektro import ElektroBlok
+from .alpaka import AlpakaBlok
+from .lovekit import LovekitBlok
 
 
 class AdminCredentials(BaseModel):
@@ -34,7 +35,9 @@ class AdminCredentials(BaseModel):
         FlussBlok.as_dependency(True, True),
         InternalDockerBlok.as_dependency(True, True),
         KraphBlok.as_dependency(True, True),
+        AlpakaBlok.as_dependency(True, True),
         ElektroBlok.as_dependency(True, True),
+        LovekitBlok.as_dependency(True, True),
     ],
 )
 class ArkitektBlok:

arkitekt_next/bloks/gateway.py

@@ -68,10 +68,14 @@ class CaddyBlok:
         self,
         init: InitContext,
         name: NameService,
+        certs: CerterService,
     ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
+        self.cert_mount = certs.retrieve_certs_mount()
+        self.depends_on = certs.retrieve_depends_on()
+
         self.gateway_network = name.retrieve_name().replace("-", "_")
 
     def build(
@@ -164,6 +168,8 @@ class CaddyBlok:
         ]
 
         volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
+        if self.cert_mount:
+            volumes.append(f"{self.cert_mount}:/certs")
 
         caddy_container = {
             "image": "caddy:latest",

arkitekt_next/bloks/l.py

@@ -0,0 +1,136 @@
+from dataclasses import asdict
+from typing import Dict, Any
+import secrets
+
+
+from arkitekt_next.bloks.services.admin import AdminService
+from arkitekt_next.bloks.services.channel import ChannelService
+from arkitekt_next.bloks.services.config import ConfigService
+from arkitekt_next.bloks.services.db import DBService
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.lok import LokService
+from arkitekt_next.bloks.services.mount import MountService
+from arkitekt_next.bloks.services.ollama import OllamaService
+from arkitekt_next.bloks.services.redis import RedisService
+from arkitekt_next.bloks.services.s3 import S3Service
+from arkitekt_next.bloks.services.secret import SecretService
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.bloks.services.dns import DnsService
+from blok.tree import Repo, YamlFile
+from arkitekt_next.bloks.base import BaseArkitektService
+
+
+@blok("live.arkitekt.alpaka", description="a container and app management service")
+class AlpakaBlok(BaseArkitektService):
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "alpaka"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/arkitektio/alpaka-server"
+        self.scopes = {
+            "alpaka_pull": "Pull new Models",
+            "alpaka_chat": "Add repositories to the database",
+        }
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+        self.image = "jhnnsrs/alpaka:nightly"
+
+    def preflight(
+        self,
+        lok: LokService,
+        db: DBService,
+        redis: RedisService,
+        s3: S3Service,
+        config: ConfigService,
+        ollama: OllamaService,
+        mount: MountService,
+        admin: AdminService,
+        secret: SecretService,
+        gateway: GatewayService,
+        mount_repo: bool = False,
+        host: str = "",
+        image: str = "",
+        secret_key: str = "",
+        build_repo: bool = False,
+        command: str = "",
+        repo: str = "",
+        disable: bool = False,
+        dev: bool = False,
+    ):
+        lok.register_scopes(self.scopes)
+
+        path_name = self.host
+
+        gateway.expose(path_name, 80, self.host)
+
+        postgress_access = db.register_db(self.host)
+        redis_access = redis.register()
+        lok_access = lok.retrieve_credentials()
+        admin_access = admin.retrieve()
+        minio_access = s3.create_buckets(self.buckets)
+        lok_labels = lok.retrieve_labels("live.arkitekt.alpaka", self.get_builder())
+        ollama_access = ollama.get_access()
+
+        django_secret = secret.retrieve_secret()
+
+        csrf_trusted_origins = []
+
+        configuration = YamlFile(
+            **{
+                "db": asdict(postgress_access),
+                "django": {
+                    "admin": asdict(admin_access),
+                    "debug": True,
+                    "hosts": ["*"],
+                    "secret_key": django_secret,
+                },
+                "redis": asdict(redis_access),
+                "lok": asdict(lok_access),
+                "s3": asdict(minio_access),
+                "scopes": self.scopes,
+                "force_script_name": path_name,
+                "csrf_trusted_origins": csrf_trusted_origins,
+                **self.get_additional_config(),
+            }
+        )
+
+        config_mount = config.register_config(f"{self.host}.yaml", configuration)
+
+        depends_on = []
+
+        if redis_access.dependency:
+            depends_on.append(redis_access.dependency)
+
+        if postgress_access.dependency:
+            depends_on.append(postgress_access.dependency)
+
+        if minio_access.dependency:
+            depends_on.append(minio_access.dependency)
+
+        if ollama_access.dependency:
+            depends_on.append(ollama_access.dependency)
+
+        service = {
+            "labels": lok_labels,
+            "volumes": [f"{config_mount}:/workspace/config.yaml"],
+            "depends_on": depends_on,
+        }
+
+        if mount_repo or dev:
+            mount = mount.register_mount(self.host, Repo(repo))
+            service["volumes"].extend([f"{mount}:/workspace"])
+
+        if build_repo or dev:
+            mount = mount.register_mount(self.host, Repo(repo))
+            service["build"] = mount
+        else:
+            service["image"] = image
+
+        service["command"] = command
+
+        self.service = service

arkitekt_next/bloks/livekit.py

@@ -21,9 +21,9 @@ class LocalLiveKitBlok:
         self.api_key = "devkey"
         self.api_secret = "secret"
         self.skip = False
+        self.api_port = 7880
 
     def preflight(self, init: InitContext, gateway: GatewayService):
-
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -37,12 +37,13 @@ class LocalLiveKitBlok:
 
         self.initialized = True
 
-    def retrieve_access(self):
+    def get_access(self):
         return LivekitCredentials(
             **{
                 "api_key": self.api_key,
                 "api_secret": self.api_secret,
-                "api_url": f"http://{self.host}:7880",
+                "host": self.host,
+                "port": self.api_port,
             }
         )