arkitekt-next 0.8.47__py3-none-any.whl → 0.8.49__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -4,7 +4,7 @@ from arkitekt_next.bloks.mikro import MikroBlok
 from arkitekt_next.bloks.fluss import FlussBlok
 from arkitekt_next.bloks.orkestrator import OrkestratorBlok
 from arkitekt_next.bloks.redis import RedisBlok
-from arkitekt_next.bloks.gateway import GatewayBlok
+from arkitekt_next.bloks.gateway import CaddyBlok
 from arkitekt_next.bloks.livekit import LocalLiveKitBlok
 from arkitekt_next.bloks.postgres import PostgresBlok
 from arkitekt_next.bloks.minio import MinioBlok
@@ -18,6 +18,8 @@ from arkitekt_next.bloks.rekuest import RekuestBlok
 from arkitekt_next.bloks.tailscale import TailscaleBlok
 from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.namegen import PreformedNamesBlok
+from arkitekt_next.bloks.ollama import OllamaBlok
+from arkitekt_next.bloks.self_signed import SelfSignedBlok
 
 
 def get_bloks():
@@ -27,11 +29,13 @@ def get_bloks():
         MikroBlok(),
         FlussBlok(),
         RedisBlok(),
-        GatewayBlok(),
+        CaddyBlok(),
         LocalLiveKitBlok(),
         PostgresBlok(),
         MinioBlok(),
+        OllamaBlok(),
         LokBlok(),
+        SelfSignedBlok(),
         KabinetBlok(),
         MountBlok(),
         ConfigBlok(),

arkitekt_next/__init__.py

@@ -32,6 +32,8 @@ except ImportError as e:
 
 from .builders import easy, interactive
 from .apps.types import App
+from fakts_next.helpers import afakt, fakt
+
 
 __all__ = [
     "App",
@@ -42,6 +44,8 @@ __all__ = [
     "jupy",
     "log",
     "alog",
+    "afakt",
+    "fakt",
     "progress",
     "aprogress",
     "scheduler",

arkitekt_next/apps/service/fakts_next.py

@@ -37,7 +37,6 @@ def build_arkitekt_next_fakts_next(
         requested_client_kind=client_kind,
     )
 
-
     return ArkitektNextFaktsNext(
         grant=RemoteGrant(
             demander=demander,
@@ -45,10 +44,10 @@ def build_arkitekt_next_fakts_next(
             claimer=ClaimEndpointClaimer(),
         ),
         cache=FileCache(
-                cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
-                hash=manifest.hash() + url,
-                skip_cache=no_cache,
-            ),
+            cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
+            hash=manifest.hash() + url,
+            skip_cache=no_cache,
+        ),
     )
 
 
@@ -62,7 +61,6 @@ def build_arkitekt_next_redeem_fakts_next(
     identifier = manifest.identifier
     version = manifest.version
 
-
     return ArkitektNextFaktsNext(
         grant=RemoteGrant(
             demander=RedeemDemander(token=redeem_token, manifest=manifest),
@@ -70,9 +68,9 @@ def build_arkitekt_next_redeem_fakts_next(
             claimer=ClaimEndpointClaimer(),
         ),
         cache=FileCache(
-                cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
-                hash=manifest.hash() + url,
-            ),
+            cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
+            hash=manifest.hash() + url,
+        ),
     )
 
 
@@ -91,7 +89,7 @@ def build_arkitekt_next_token_fakts_next(
             claimer=ClaimEndpointClaimer(),
         ),
         cache=FileCache(
-                cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
-                hash=manifest.hash() + url,
-            ),
+            cache_file=f".arkitekt_next/cache/{identifier}-{version}_fakts_cache.json",
+            hash=manifest.hash() + url,
+        ),
     )

arkitekt_next/apps/service/fakts_qt.py

@@ -12,6 +12,7 @@ from arkitekt_next.base_models import Manifest
 from qtpy import QtCore, QtWidgets
 from fakts_next.cache.qt.settings import QtSettingsCache
 
+
 class ArkitektNextFaktsQtRemoteGrant(RemoteGrant):
     """An ArkitektNext Fakts grant that uses Qt widgets for token and endpoint storage"""
 
@@ -38,19 +39,19 @@ def build_arkitekt_next_qt_fakts_next(
     return ArkitektNextFaktsQt(
         grant=ArkitektNextFaktsQtRemoteGrant(
             demander=DeviceCodeDemander(
-                    manifest=manifest,
-                    redirect_uri="http://127.0.0.1:6767",
-                    open_browser=True,
-                    requested_client_kind="desktop",
-                ),
+                manifest=manifest,
+                redirect_uri="http://127.0.0.1:6767",
+                open_browser=True,
+                requested_client_kind="desktop",
+            ),
             discovery=QtSelectableDiscovery(
-                    widget=beacon_widget,
-                    settings=settings,
-                    allow_appending_slash=True,
-                    auto_protocols=["http", "https"],
-                    additional_beacons=["http://localhost"],
-                ),
-            claimer=ClaimEndpointClaimer()
+                widget=beacon_widget,
+                settings=settings,
+                allow_appending_slash=True,
+                auto_protocols=["http", "https"],
+                additional_beacons=["http://localhost"],
+            ),
+            claimer=ClaimEndpointClaimer(),
         ),
-        cache=QtSettingsCache(settings=settings)
+        cache=QtSettingsCache(settings=settings),
     )

arkitekt_next/apps/service/herre.py

@@ -15,7 +15,9 @@ def build_arkitekt_next_herre_next(fakts_next: Fakts) -> ArkitektNextHerre:
     return ArkitektNextHerre(
         grant=RefreshGrant(
             grant=FaktsGrant(
-                fakts=fakts_next, fakts_group="lok", grant_registry=ARKITEKT_GRANT_REGISTRY
+                fakts=fakts_next,
+                fakts_group="lok",
+                grant_registry=ARKITEKT_GRANT_REGISTRY,
             ),
         ),
         fetcher=FaktsUserFetcher(

arkitekt_next/apps/types.py

@@ -42,7 +42,6 @@ class App(Composition):
         """Register a service"""
         self.services["rekuest"].register(*args, **kwargs)
 
-
     async def __aenter__(self):
         await super().__aenter__()
         for service in self.services.values():

arkitekt_next/base_models.py

@@ -17,8 +17,6 @@ class Requirement(BaseModel):
     """ The description is a human readable description of the requirement. Will be show to the user when asking for the requirement."""
 
 
-
-
 class Manifest(BaseModel):
     """A manifest for an app that can be installed in ArkitektNext
 
@@ -42,9 +40,7 @@ class Manifest(BaseModel):
     """ Scopes that this app should request from the user """
     logo: Optional[str]
     """ A URL to the logo of the app TODO: We should enforce this to be a http URL as local paths won't work """
-    requirements: Optional[List[Requirement]] = Field(
-        default_factory=list
-    )
+    requirements: Optional[List[Requirement]] = Field(default_factory=list)
     """ Requirements that this app has TODO: What are the requirements? """
 
     class Config:
@@ -52,7 +48,7 @@ class Manifest(BaseModel):
 
     def hash(self):
         """Hash the manifest
-        
+
         A manifest describes all the  metadata of an app. This method
         hashes the manifest to create a unique hash for the current configuration of the app.
         This hash can be used to check if the app has changed since the last time it was run,
@@ -60,7 +56,7 @@ class Manifest(BaseModel):
 
         Returns:
             str: The hash of the manifest
-        
+
         """
 
         unsorted_dict = self.model_dump()
@@ -76,7 +72,6 @@ class Manifest(BaseModel):
         json_dd = json.dumps(unsorted_dict, sort_keys=True)
         # Hash the JSON encoded dictionary
         return sha256(json_dd.encode()).hexdigest()
-    
 
     @field_validator("identifier")
     def check_identifier(cls, v):

arkitekt_next/bloks/arkitekt.py

@@ -1,16 +1,19 @@
+from typing import Any, Dict, Optional
+
 from pydantic import BaseModel
-from typing import Dict, Any
+
+from arkitekt_next.bloks.kraph import KraphBlok
 from arkitekt_next.bloks.tailscale import TailscaleBlok
-from blok import blok, InitContext, Renderer, Panel
-from .livekit import LocalLiveKitBlok
-from .mikro import MikroBlok
-from .kabinet import KabinetBlok
-from .rekuest import RekuestBlok
+from blok import InitContext, Panel, Renderer, blok
+
 from .fluss import FlussBlok
-from .gateway import GatewayBlok
 from .internal_docker import InternalDockerBlok
+from .kabinet import KabinetBlok
+from .livekit import LocalLiveKitBlok
+from .mikro import MikroBlok
 from .orkestrator import OrkestratorBlok
-from typing import Optional
+from .rekuest import RekuestBlok
+from .ollama import OllamaBlok
 
 
 class AdminCredentials(BaseModel):
@@ -19,8 +22,20 @@ class AdminCredentials(BaseModel):
     email: str
 
 
-@blok("live.arkitekt")
+@blok("live.arkitekt", dependencies=[
+    MikroBlok.as_dependency(True, True),
+    KabinetBlok.as_dependency(True, True),
+    RekuestBlok.as_dependency(True, True),
+    FlussBlok.as_dependency(True, True),
+    InternalDockerBlok.as_dependency(True, True),
+    OrkestratorBlok.as_dependency(True, True),
+    KraphBlok.as_dependency(True, False),
+    LocalLiveKitBlok.as_dependency(True, False),
+    TailscaleBlok.as_dependency(True, False),
+    OllamaBlok.as_dependency(True, False),
+])
 class ArkitektBlok:
+
     def entry(self, renderer: Renderer):
         renderer.render(
             Panel(
@@ -31,19 +46,6 @@ class ArkitektBlok:
             )
         )
 
-    def preflight(
-        self,
-        gateway: GatewayBlok,
-        livekit: Optional[LocalLiveKitBlok] = None,
-        mikro: Optional[MikroBlok] = None,
-        kabinet: Optional[KabinetBlok] = None,
-        rekuest: Optional[RekuestBlok] = None,
-        fluss: Optional[FlussBlok] = None,
-        internal_engine: Optional[InternalDockerBlok] = None,
-        scale: Optional[TailscaleBlok] = None,
-        orkestrator: Optional[OrkestratorBlok] = None,
-    ):
-        pass
 
     def build(self, cwd):
         pass

arkitekt_next/bloks/base.py

@@ -94,7 +94,9 @@ class BaseArkitektService:
             self.get_blok_meta().service_identifier, self.get_builder()
         )
 
-        dns_result = init.get_service(DnsService).get_dns_result()
+        django_secret = secret.retrieve_secret()
+
+        dns_result = dns.get_dns_result()
 
         csrf_trusted_origins = []
         for hostname in dns_result.hostnames:
@@ -108,7 +110,7 @@ class BaseArkitektService:
                     "admin": asdict(admin_access),
                     "debug": True,
                     "hosts": ["*"],
-                    "secret_key": self.secret_key,
+                    "secret_key": django_secret,
                 },
                 "redis": asdict(redis_access),
                 "lok": asdict(lok_access),

arkitekt_next/bloks/gateway.py

@@ -1,8 +1,9 @@
+from arkitekt_next.bloks.services.certer import CerterService
 from arkitekt_next.bloks.services.name import NameService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 
 from blok import blok, InitContext
 from blok.bloks.services.dns import DnsService
@@ -34,7 +35,7 @@ class ExposedPort(BaseModel):
 @blok(
     "live.arkitekt.gateway", description="A gateway for exposing services on the host"
 )
-class GatewayBlok:
+class CaddyBlok:
     def __init__(self) -> None:
         self.exposed_hosts = {}
         self.exposed_to_hosts = {}
@@ -47,6 +48,8 @@ class GatewayBlok:
         self.https_port = 443
         self.public_ips = DEFAULT_PUBLIC_URLS
         self.public_hosts = DEFAULT_PUBLIC_HOSTS
+        self.cert_mount = None
+        self.depends_on = []
 
     def get_internal_host(self):
         return "caddy"
@@ -60,7 +63,7 @@ class GatewayBlok:
     def retrieve_gateway_network(self):
         return self.gateway_network
 
-    def preflight(self, init: InitContext, dns: DnsService, name: NameService):
+    def preflight(self, init: InitContext, dns: DnsService, name: NameService, certer: Optional[CerterService] = None):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -68,6 +71,11 @@ class GatewayBlok:
         self.public_hosts = dns.get_dns_result().hostnames
         self.gateway_network = name.retrieve_name().replace("-", "_")
 
+        if certer is not None:
+            self.cert_mount = certer.retrieve_certs_mount()
+            self.depends_on = certer.retrieve_depends_on()
+        
+
     def build(
         self,
         context: ExecutionContext,
@@ -153,22 +161,25 @@ class GatewayBlok:
 
         context.file_tree.set_nested("configs", "Caddyfile", caddyfile)
 
-        caddy_depends_on = []
-        if self.with_certer:
-            caddy_depends_on.append("certer")
+        caddy_depends_on = self.depends_on
 
         exposed_ports_strings = [
             f"{port.port}:{port.port}" for port in self.exposed_ports.values()
         ]
 
+
+        volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
+        if self.cert_mount:
+            volumes.append(f"{self.cert_mount}:/certs")
+
         caddy_container = {
             "image": "caddy:latest",
-            "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
             "ports": [
                 f"{self.http_port}:80",
                 f"{self.https_port}:443",
             ]
             + exposed_ports_strings,
+            "volumes": volumes,
             "depends_on": caddy_depends_on,
             "networks": [self.gateway_network, "default"],
         }

arkitekt_next/bloks/internal_docker.py

@@ -17,7 +17,7 @@ class InternalDockerBlok:
     def __init__(self) -> None:
         self.host = "internal_docker"
 
-        self.image = "jhnnsrs/deployer:0.0.8-vanilla"
+        self.image = "jhnnsrs/deployer:nightly"
         self.instance_id = "INTERNAL_DOCKER"
 
     def preflight(
@@ -51,10 +51,6 @@ class InternalDockerBlok:
         if self.skip:
             return
         db_service = {
-            "labels": [
-                "fakts.service=io.livekit.livekit",
-                "fakts.builder=livekitio.livekit",
-            ],
             "image": self.image,
             "command": self.command,
             "volumes": [f"{self._socket}:/var/run/docker.sock"],

arkitekt_next/bloks/kraph.py

@@ -0,0 +1,42 @@
+import click
+from pydantic import BaseModel
+from typing import Dict, Any
+import yaml
+import secrets
+from blok import blok, InitContext
+
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from arkitekt_next.bloks.base import BaseArkitektService
+
+
+class AccessCredentials(BaseModel):
+    password: str
+    username: str
+    host: str
+    port: str
+    db_name: str
+
+
+@blok("live.arkitekt.kraph", description="Kraph allows you to interconnect structures in a graph database")
+class KraphBlok(BaseArkitektService):
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "kraph"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/arkitektio/kraph-server"
+        self.scopes = {
+            "kraph_read": "Read from the graph database",
+            "mikro_write": "Write image to the database",
+        }
+        self.image = "jhnnsrs/kraph:nightly"
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)

arkitekt_next/bloks/lok.py

@@ -202,7 +202,10 @@ class LokBlok:
             depends_on.append(self.postgress_access.dependency)
 
         db_service = {
-            "labels": ["fakts_next.service=live.arkitekt.lok", "fakts_next.builder=arkitekt.lok"],
+            "labels": [
+                "fakts.service=live.arkitekt.lok",
+                "fakts.builder=arkitekt.lok",
+            ],
             "depends_on": depends_on,
             "volumes": [
                 "/var/run/docker.sock:/var/run/docker.sock",

arkitekt_next/bloks/ollama.py

@@ -0,0 +1,92 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.ollama import OllamaService, OllamaCredentials
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+@blok(OllamaService, description="a self-hosted Ollama LLM server")
+class OllamaBlok:
+    def __init__(self) -> None:
+        self.host = "ollama"
+        self.image = "ollama/ollama:latest"
+        self.port = 11434
+        self.skip = False
+        self.gpu = bool
+
+    def preflight(self, init: InitContext, gateway: GatewayService):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+
+        if self.skip:
+            return
+
+        gateway.expose_port_to(self.port, self.host, 11434, False)
+
+        self.initialized = True
+
+
+    def build(self, context: ExecutionContext):
+        if self.skip:
+            return
+        db_service = {
+            "labels": [
+                "fakts.service=io.ollama.ollama",
+                "fakts.builder=ollama.ollama",
+            ],
+            "image": self.image,
+            "environment": {
+                "OLLAMA_KEEP_ALIVE": "24h",
+            }
+        }
+
+        if self.gpu:
+            db_service["deploy"] = {
+                "resources": {
+                    "reservations": {
+                        "devices": [
+                            {
+                                "driver": "nvidia",
+                                "count": 1,
+                                "capabilities": ["gpu"],
+                            }
+                        ]
+                    }
+                }
+            }
+
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    def get_options(self):
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        with_skip = Option(
+            subcommand="skip",
+            help="The fakts_next url for connection",
+            default=False,
+            type=bool,
+        )
+        with_gpu = Option(
+            subcommand="gpu",
+            help="Whether to use a gpu",
+            default=False,
+            type=self.gpu,
+        )
+
+        return [
+            with_host,
+            with_skip,
+            with_gpu,
+        ]
+
+    def __str__(self) -> str:
+        return (
+            f"LiveKitBlok(host={self.host}, command={self.command}, image={self.image})"
+        )

arkitekt_next/bloks/orkestrator.py

@@ -1,7 +1,9 @@
 from typing import Dict, Any
 import secrets
+from arkitekt_next.bloks.services.gateway import GatewayService
 from arkitekt_next.bloks.services.mount import MountService
 from blok import blok, InitContext, ExecutionContext, Option, Command
+from blok.bloks.services.dns import DnsService
 from blok.bloks.services.vscode import VsCodeService
 from blok.tree import Repo, YamlFile
 
@@ -14,6 +16,8 @@ class OrkestratorBlok:
     def __init__(self) -> None:
         self.dev = False
         self.disable = True
+        self.host = "orkestrator"
+        self.path_name = "orkestrator"
         self.repo = "https://github.com/arkitektio/orkestrator-next"
         self.build_command = ["yarn"]
         self.up_command = ["yarn", "start"]
@@ -21,36 +25,58 @@ class OrkestratorBlok:
     def preflight(
         self,
         init: InitContext,
+        gateway: GatewayService,
         mount: MountService,
         vscode: VsCodeService | None = None,
     ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        if self.disable and not self.dev:
+        if self.disable:
             return
-        self.mount = mount.register_mount("orkestrator", Repo(self.repo))
+        
+        if not self.dev:
+            gateway.expose(self.path_name, 80, self.host)
 
-        if vscode is not None:
-            vscode.register_task(
-                "Run Orkestrator",
-                "shell",
-                "yarn",
-                ["start"],
-                {"cwd": f"{self.mount}"},
-            )
-            vscode.register_task(
-                "Build Orkestrator",
-                "shell",
-                "yarn",
-                [],
-                {"cwd": f"{self.mount}"},
-            )
 
-        self.initialized = True
+            self.service = {
+                "image": "jhnnsrs/orkestrator_next:nightly",
+                "environment": {
+                    "PATH_NAME": self.path_name,
+                },
+            }
+
+            return 
+    
+        else:
+
+            self.mount = mount.register_mount("orkestrator", Repo(self.repo))
+
+            if vscode is not None:
+                vscode.register_task(
+                    "Run Orkestrator",
+                    "shell",
+                    "yarn",
+                    ["start"],
+                    {"cwd": f"{self.mount}"},
+                )
+                vscode.register_task(
+                    "Build Orkestrator",
+                    "shell",
+                    "yarn",
+                    [],
+                    {"cwd": f"{self.mount}"},
+                )
+
+            self.initialized = True
 
     def build(self, context: ExecutionContext):
-        if self.disable and not self.dev:
+        if self.disable:
+            return
+        
+        if self.dev:
+            context.docker_compose.set_nested("services", self.host, self.service)
+
             return
 
         context.install_commands.set_nested(
@@ -77,9 +103,21 @@ class OrkestratorBlok:
             help="Should we mount orkestrator as dev?",
             default=self.dev,
         )
+        with_path_name = Option(
+            subcommand="path_name",
+            help="The path name for the orkestrator service",
+            default=self.path_name,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="The host for the orkestrator service",
+            default=self.host,
+        )
 
         return [
             with_dev,
             with_repos,
+            with_path_name,
             with_disable,
+            with_host,
         ]