arkitekt-next 0.8.48__tar.gz → 0.8.49__tar.gz

{arkitekt_next-0.8.48 → arkitekt_next-0.8.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.8.48
+Version: 0.8.49
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -18,7 +18,7 @@ Provides-Extra: blok
 Provides-Extra: cli
 Provides-Extra: extended
 Provides-Extra: stream
-Requires-Dist: blok (>=0.0.19) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: blok (>=0.0.20) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: dokker (>=1.0.0)
 Requires-Dist: fakts-next (>=1.0.3)

{arkitekt_next-0.8.48 → arkitekt_next-0.8.49}/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-0.8.48 → arkitekt_next-0.8.49}/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-0.8.48 → arkitekt_next-0.8.49}/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-0.8.48 → arkitekt_next-0.8.49}/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-0.8.48 → arkitekt_next-0.8.49}/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-0.8.49/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-0.8.48 → arkitekt_next-0.8.49}/arkitekt_next/bloks/lok.py

@@ -203,8 +203,8 @@ class LokBlok:
 
         db_service = {
             "labels": [
-                "fakts_next.service=live.arkitekt.lok",
-                "fakts_next.builder=arkitekt.lok",
+                "fakts.service=live.arkitekt.lok",
+                "fakts.builder=arkitekt.lok",
             ],
             "depends_on": depends_on,
             "volumes": [

arkitekt_next-0.8.49/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-0.8.48 → arkitekt_next-0.8.49}/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,
         ]

arkitekt_next-0.8.49/arkitekt_next/bloks/self_signed.py

@@ -0,0 +1,98 @@
+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, Optional
+
+from blok import blok, InitContext
+from blok.bloks.services.dns import DnsService
+
+DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
+DEFAULT_PUBLIC_HOSTS = ["localhost"]
+
+
+class ExposedHost(BaseModel):
+    host: str
+    port: int
+    stip_prefix: bool = True
+
+
+class ExpostedToHost(BaseModel):
+    port: int
+    host: str
+    to: str
+    tls: bool = False
+
+
+class ExposedPort(BaseModel):
+    port: int
+    host: str
+    tls: bool = False
+    to: int
+
+
+@blok(
+    "live.arkitekt.certer", description="A self-signed certificate generator"
+)
+class SelfSignedBlok:
+    def __init__(self) -> None:
+        self.host = "certer"
+        self.certer_image = "jhnnsrs/certer:next"
+        self.certs_mount = "./certs"
+
+    def retrieve_certs_mount(self):
+        return self.certs_mount
+
+
+    def retrieve_depends_on(self):
+        return ["certer"]
+
+    def preflight(self, init: InitContext, dns: DnsService):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.public_ips = dns.get_dns_result().ip_addresses
+        self.public_hosts = dns.get_dns_result().hostnames
+
+
+    def build(
+        self,
+        context: ExecutionContext,
+    ):
+
+        context.file_tree.set_nested("certs", {})
+
+
+        certer_container = {
+            "image": self.certer_image,
+            "volumes": ["./certs:/certs"],
+            "environment": {
+                "DOMAIN_NAMES": ",".join(self.public_hosts),
+                "IP_ADDRESSED": ",".join(self.public_ips),
+            },
+        }
+
+        context.docker_compose.set_nested("services", self.host, certer_container)
+
+   
+
+    def get_options(self):
+        with_public_urls = Option(
+            subcommand="public_url",
+            help="Which public urls to use",
+            type=str,
+            multiple=True,
+            default=DEFAULT_PUBLIC_URLS,
+            show_default=True,
+        )
+        with_public_services = Option(
+            subcommand="public_hosts",
+            help="Which public hosts to use",
+            type=str,
+            multiple=True,
+            default=DEFAULT_PUBLIC_HOSTS,
+            show_default=True,
+        )
+
+        return [with_public_urls, with_public_services]

arkitekt_next-0.8.49/arkitekt_next/bloks/services/certer.py

@@ -0,0 +1,14 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from dataclasses import dataclass
+from typing import Dict, Any, Protocol
+
+from blok import blok, InitContext, service
+
+
+@service("live.arkitekt.certer", description="Generate HTTPS certificates for services")
+class CerterService(Protocol):
+
+    def retrieve_certs_mount(self) -> str: ...
+        
+    def retrieve_depends_on(self) -> list[str]: ...

arkitekt_next-0.8.49/arkitekt_next/bloks/services/ollama.py

@@ -0,0 +1,16 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+
+@dataclass
+class OllamaCredentials:
+    api_key: str
+    api_secret: str
+    api_url: str
+
+
+@service("io.ollama.ollama", description=" A self-hosted ollama LLM server")
+class OllamaService(Protocol):
+    pass

{arkitekt_next-0.8.48 → arkitekt_next-0.8.49}/arkitekt_next/cli/commands/kabinet/build.py

@@ -233,8 +233,16 @@ def get_flavours(ctx: Context, select: Optional[str] = None) -> Dict[str, Flavou
     is_flag=True,
     default=False,
 )
+@click.option(
+    "--tag",
+    "-t",
+    help="Tag the build with a specific tag",
+    type=str,
+    default=None,
+    required=False,
+)
 @click.pass_context
-def build(ctx: Context, flavour: str, no_inspect: bool) -> None:
+def build(ctx: Context, flavour: str, no_inspect: bool, tag: str = None) -> None:
     """Builds the arkitekt_next app to docker"""
 
     manifest = get_manifest(ctx)
@@ -262,6 +270,10 @@ def build(ctx: Context, flavour: str, no_inspect: bool) -> None:
 
         build_tag = build_flavour(key, flavour)
 
+        if tag:
+            subprocess.run(["docker", "tag", build_tag, tag], check=True)
+
+
         inspection = None
         if not no_inspect:
             inspection = inspect_build(build_tag)

{arkitekt_next-0.8.48 → arkitekt_next-0.8.49}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arkitekt-next"
-version = "0.8.48"
+version = "0.8.49"
 description = "client for the arkitekt_next platform"
 authors = ["jhnnsrs <jhnnsrs@gmail.com>"]
 license = "MIT"
@@ -26,7 +26,7 @@ semver = { version = ">=3.0.1", optional = true }
 dokker = ">=1.0.0"
 koil = ">=1.0.3"
 netifaces = { version = ">=0.11.0", python = "^3.8", optional = true }
-blok = { version = ">=0.0.19", python = "^3.9", optional = true }
+blok = { version = ">=0.0.20", python = "^3.9", optional = true }
 cryptography = { version = ">=40.0.8", python = "^3.8", optional = true }
 namegenerator = { version = ">=1.0.6", python = "^3.8", optional = true }