arkitekt-next 0.15.0__tar.gz → 0.16.0__tar.gz

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkitekt-next
-Version: 0.15.0
+Version: 0.16.0
 Summary: client for the arkitekt_next platform
 Author-email: jhnnsrs <jhnnsrs@gmail.com>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Requires-Dist: watchfiles>=1.0.5
 Provides-Extra: all
 Requires-Dist: fluss-next>=0.2.0; extra == 'all'
 Requires-Dist: kabinet>=0.2.0; extra == 'all'
-Requires-Dist: mikro-next>=0.4; extra == 'all'
+Requires-Dist: mikro-next>=0.6; extra == 'all'
 Requires-Dist: reaktion-next>=0.2.0; extra == 'all'
 Requires-Dist: rekuest-next>=0.7; extra == 'all'
 Requires-Dist: rich-click>=1.6.1; extra == 'all'
@@ -47,7 +47,7 @@ Requires-Dist: kraph>=0.2.0; extra == 'kraph'
 Provides-Extra: lovekit
 Requires-Dist: lovekit>=0.2.0; extra == 'lovekit'
 Provides-Extra: mikro
-Requires-Dist: mikro-next>=0.4.0; extra == 'mikro'
+Requires-Dist: mikro-next>=0.6.0; extra == 'mikro'
 Provides-Extra: reaktion
 Requires-Dist: reaktion-next>=0.2.0; extra == 'reaktion'
 Provides-Extra: unlok

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/alpaka.py

@@ -66,7 +66,10 @@ class AlpakaBlok(BaseArkitektService):
 
         path_name = self.host
 
-        gateway.expose(path_name, 80, self.host)
+        gateway_path = gateway.expose_service(path_name, 80, self.host)
+        lok.register_service_on_subpath(
+            self.get_blok_meta().service_identifier, gateway_path, "ht"
+        )
 
         postgress_access = db.register_db(self.host)
         redis_access = redis.register()

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/base.py

@@ -83,17 +83,20 @@ class BaseArkitektService:
 
         path_name = self.host
 
-        if gateway:
-            print("Registering gateway access")
-            gateway_access = 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(
-            self.get_blok_meta().service_identifier, self.get_builder()
+
+        self.service_identifier = self.get_blok_meta().service_identifier
+
+        gateway_path = gateway.expose_service(
+            path_name, 80, self.host, strip_prefix=False
+        )
+
+        lok_labels = lok.register_service_on_subpath(
+            self.service_identifier, gateway_path, "ht"
         )
 
         django_secret = secret.retrieve_secret()
@@ -135,7 +138,6 @@ class BaseArkitektService:
             depends_on.append(minio_access.dependency)
 
         service = {
-            "labels": lok_labels,
             "volumes": [f"{config_mount}:/workspace/config.yaml"],
             "depends_on": depends_on,
         }

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/gateway.py

@@ -42,9 +42,7 @@ class CaddyBlok:
         self.exposed_to_hosts = {}
         self.http_expose_default = None
         self.exposed_ports = {}
-        self.with_certer = True
-        self.with_tailscale = True
-        self.certer_image = "jhnnsrs/certer:next"
+        self.with_certer = False
         self.http_port = 80
         self.https_port = 443
         self.public_ips = DEFAULT_PUBLIC_URLS
@@ -68,14 +66,10 @@ 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(
@@ -102,7 +96,7 @@ class CaddyBlok:
 }}
                 """
 
-        for protocol in ["http", "https"]:
+        for protocol in ["http"]:
             caddyfile += f"""
 {protocol}:// {{
 """
@@ -168,14 +162,11 @@ class CaddyBlok:
         ]
 
         volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
-        if self.cert_mount:
-            volumes.append(f"{self.cert_mount}:/certs")
 
         caddy_container = {
             "image": "caddy:latest",
             "ports": [
                 f"{self.http_port}:80",
-                f"{self.https_port}:443",
             ]
             + exposed_ports_strings,
             "volumes": volumes,
@@ -190,10 +181,13 @@ class CaddyBlok:
             {"driver": "bridge", "name": self.gateway_network},
         )
 
-    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = False):
+    def expose_service(
+        self, path_name: str, port: int, host: str, strip_prefix: bool = False
+    ):
         self.exposed_hosts[path_name] = ExposedHost(
             host=host, port=port, stip_prefix=strip_prefix
         )
+        return path_name
 
     def expose_mapped(self, path_name: str, port: int, host: str, to: str):
         self.exposed_to_hosts[path_name] = ExpostedToHost(host=host, port=port, to=to)

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/internal_docker.py

@@ -15,7 +15,7 @@ from blok.tree import YamlFile, Repo
 )
 class InternalDockerBlok:
     def __init__(self) -> None:
-        self.host = "internal_docker"
+        self.host = "deployer"
 
         self.image = "jhnnsrs/deployer:nightly"
         self.instance_id = "INTERNAL_DOCKER"
@@ -32,9 +32,6 @@ class InternalDockerBlok:
 
         deps = init.dependencies
 
-        if self.skip:
-            return
-
         self._socket = socket.register_socket(self.host)
         self.gateway_host = gateway.get_internal_host()
         self.gateway_port = gateway.get_http_port()
@@ -48,8 +45,6 @@ class InternalDockerBlok:
         self.initialized = True
 
     def build(self, context: ExecutionContext):
-        if self.skip:
-            return
         db_service = {
             "image": self.image,
             "command": self.command,

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/livekit.py

@@ -51,10 +51,6 @@ class LocalLiveKitBlok:
         if self.skip:
             return
         db_service = {
-            "labels": [
-                "fakts.service=io.livekit.livekit",
-                "fakts.builder=livekitio.livekit",
-            ],
             "image": self.image,
             "command": self.command,
             "ports": [

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/lok.py

@@ -139,6 +139,13 @@ class LokBlok:
             "read": "A generic read access",
             "write": "A generic write access",
         }
+        self.email_service: str = "smtp"
+        self.email_host: str = "NOT_SET"
+        self.email_port: int = 587
+        self.email_user: str = "NOT_SET"
+        self.email_password: str = "NOT_SET"
+        self.email_from: str = "NOT_SET"
+
         self.buckets = ["media"]
         self.key = None
         self.deployment_name = "default"
@@ -146,6 +153,31 @@ class LokBlok:
         self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
         self.registered_tokens = {}
         self.local_access = None
+        self.registered_instances = [
+            {
+                "identifier": "local-lok",
+                "service": "live.arkitekt.lok",
+                "aliases": [
+                    {
+                        "layer": "public",
+                        "kind": "relative",
+                        "path": "lok",
+                        "challenge": "ht",
+                    }
+                ],
+            },
+            {
+                "identifier": "local-datalayer",
+                "service": "live.arkitekt.s3",
+                "aliases": [
+                    {
+                        "layer": "public",
+                        "kind": "relative",
+                        "challenge": "minio/health/live",
+                    }
+                ],
+            },
+        ]
 
     def retrieve_credentials(self) -> LokCredentials:
         return LokCredentials(
@@ -167,6 +199,21 @@ class LokBlok:
     def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
         self.scopes = self.scopes | scopes_dict
 
+    def register_service_on_subpath(self, service_name: str, subpath: str, htpath: str):
+        registered_instance = {
+            "identifier": f"local-{service_name}",
+            "service": service_name,
+            "aliases": [
+                {
+                    "layer": "public",
+                    "kind": "relative",
+                    "path": subpath,
+                    "challenge": htpath,
+                }
+            ],
+        }
+        self.registered_instances.append(registered_instance)
+
     def preflight(
         self,
         init: InitContext,
@@ -183,7 +230,11 @@ class LokBlok:
         assert self.public_key, "Public key is required"
         assert self.private_key, "Private key is required"
 
-        gateway.expose("lok", 80, self.host, strip_prefix=False)
+        self.exposed_path = gateway.expose_service(
+            "lok", 80, self.host, strip_prefix=False
+        )
+        self.exposed_services = {"live.arkitekt.lok": {}}
+
         gateway.expose_mapped(".well-known", 80, self.host, "lok")
 
         self.secret_blok = secrets
@@ -206,13 +257,8 @@ class LokBlok:
             depends_on.append(self.s3_access.dependency)
 
         db_service = {
-            "labels": [
-                "fakts.service=live.arkitekt.lok",
-                "fakts.builder=arkitekt.lok",
-            ],
             "depends_on": depends_on,
             "volumes": [
-                "/var/run/docker.sock:/var/run/docker.sock",
                 "./configs/lok.yaml:/workspace/config.yaml",
             ],
         }
@@ -255,7 +301,22 @@ class LokBlok:
                 "s3": asdict(self.s3_access),
                 "token_expire_seconds": self.token_expiry_seconds,
                 "force_script_name": "lok",
+                "layers": [
+                    {
+                        "identifier": "public",
+                        "kind": "public",
+                    }
+                ],
+                "instances": self.registered_instances,
                 "csrf_trusted_origins": trusted_origins,
+                "email": {
+                    "service": self.email_service,
+                    "host": self.email_host,
+                    "port": self.email_port,
+                    "user": self.email_user,
+                    "password": self.email_password,
+                    "from": self.email_from,
+                },
             }
         )
 

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/lovekit.py

@@ -64,7 +64,10 @@ class LovekitBlok:
 
         path_name = self.host
 
-        gateway.expose(path_name, 80, self.host)
+        gateway_path = gateway.expose_service(path_name, 80, self.host)
+        lok.register_service_on_subpath(
+            self.get_blok_meta().service_identifier, gateway_path, "ht"
+        )
 
         postgress_access = db.register_db(self.host)
         redis_access = redis.register()

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/minio.py

@@ -66,10 +66,13 @@ class MinioBlok:
         for bucket in buckets:
             bucket_name = self.name_service.retrieve_name()
             bucket_map[bucket] = bucket_name
-            self.gateway_service.expose(bucket_name, 9000, self.host)
+            self.gateway_service.expose_service(bucket_name, 9000, self.host)
 
         self.buckets.extend(bucket_map.values())
 
+        # expose the health check endpoints
+        self.gateway_service.expose_service("minio/health/live", 9000, self.host)
+
         creds = S3Credentials(
             name=self.name_service.retrieve_name(),
             access_key=new_access_key,
@@ -126,7 +129,6 @@ class MinioBlok:
             },
             "image": self.minio_image,
             "volumes": ["./data:/data"],
-            "labels": ["fakts.service=live.arkitekt.s3", "fakts.builder=arkitekt.s3"],
         }
 
         context.file_tree.set_nested("data", {})

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/ollama.py

@@ -38,10 +38,6 @@ class OllamaBlok:
         if self.skip:
             return
         db_service = {
-            "labels": [
-                "fakts.service=io.ollama.ollama",
-                "fakts.builder=ollama.ollama",
-            ],
             "image": self.image,
             "environment": {
                 "OLLAMA_KEEP_ALIVE": "24h",

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/postgres.py

@@ -61,7 +61,6 @@ class PostgresBlok(BaseModel):
                 "POSTGRES_PASSWORD": self.password,
                 "POSTGRES_MULTIPLE_DATABASES": "",
             },
-            "labels": ["fakts.service=live.arkitekt.postgres"],
         }
 
         if self.build_repo or self.dev:
@@ -73,7 +72,6 @@ class PostgresBlok(BaseModel):
             self.build_image["image"] = self.image
 
     def build(self, context: ExecutionContext):
-
         self.build_image["environment"]["POSTGRES_MULTIPLE_DATABASES"] = ",".join(
             self.registered_dbs.keys()
         )

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/services/gateway.py

@@ -8,9 +8,19 @@ from blok import blok, InitContext, service
 
 @service("live.arkitekt.gateway")
 class GatewayService(Protocol):
-    def expose(
+    def expose_service(
         self, path_name: str, port: int, host: str, strip_prefix: bool = True
-    ): ...
+    ) -> str:
+        """
+        Expose a service on the gateway.
+
+        :param path_name: The name of the path to expose.
+        :param port: The port to expose the service on.
+        :param host: The host to expose the service on.
+        :param strip_prefix: Whether to strip the prefix from the path.
+        :return: The name of the exposed service.
+        """
+        ...
 
     def retrieve_gateway_network(self): ...
 

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/arkitekt_next/bloks/services/lok.py

@@ -18,3 +18,7 @@ class LokService(Protocol):
     def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]: ...
 
     def register_scopes(self, scopes_dict: Dict[str, str]): ...
+
+    def register_service_on_subpath(
+        self, service_name: str, subpath: str, htpath: str = ""
+    ) -> None: ...

{arkitekt_next-0.15.0 → arkitekt_next-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkitekt-next"
-version = "0.15.0"
+version = "0.16.0"
 description = "client for the arkitekt_next platform"
 authors = [{ name = "jhnnsrs", email = "jhnnsrs@gmail.com" }]
 requires-python = ">=3.11,<4"
@@ -25,7 +25,7 @@ cli = [
 ]
 alpaka = ["alpaka>=0.2.0"]
 kraph = ["kraph>=0.2.0"]
-mikro = ["mikro-next>=0.4.0"]
+mikro = ["mikro-next>=0.6.0"]
 kabinet = ["kabinet>=0.4.0"]
 elektro = ["elektro>=0.5.0"]
 fluss = ["fluss-next>=0.2.0"]
@@ -39,7 +39,7 @@ all = [
     "semver>=3.0.1",
     "reaktion-next>=0.2.0",
     "rekuest-next>=0.7",
-    "mikro-next>=0.4",
+    "mikro-next>=0.6",
     "kabinet>=0.2.0",
     "fluss-next>=0.2.0",
     "unlok-next>=1.1.1",

arkitekt_next-0.15.0/arkitekt_next/bloks/l.py

@@ -1,136 +0,0 @@
-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