arkitekt-next 0.12.1__tar.gz → 0.12.2__tar.gz

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkitekt-next
-Version: 0.12.1
+Version: 0.12.2
 Summary: client for the arkitekt_next platform
 Author-email: jhnnsrs <jhnnsrs@gmail.com>
 License-Expression: MIT
@@ -20,12 +20,12 @@ 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.3.1; extra == 'all'
+Requires-Dist: mikro-next>=0.4; 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'
 Requires-Dist: semver>=3.0.1; extra == 'all'
-Requires-Dist: turms>=0.8.2; extra == 'all'
+Requires-Dist: turms>=0.9; extra == 'all'
 Requires-Dist: unlok-next>=0.2.0; extra == 'all'
 Requires-Dist: watchfiles>=0.18.1; extra == 'all'
 Provides-Extra: alpaka
@@ -33,7 +33,7 @@ Requires-Dist: alpaka>=0.2.0; extra == 'alpaka'
 Provides-Extra: blok
 Requires-Dist: blok>=0.1.0; extra == 'blok'
 Provides-Extra: cli
-Requires-Dist: turms>=0.8.2; extra == 'cli'
+Requires-Dist: turms>=0.9.0; extra == 'cli'
 Provides-Extra: elektro
 Requires-Dist: elektro>=0.5.0; extra == 'elektro'
 Provides-Extra: extended
@@ -48,7 +48,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.3.1; extra == 'mikro'
+Requires-Dist: mikro-next>=0.4.0; extra == 'mikro'
 Provides-Extra: reaktion
 Requires-Dist: reaktion-next>=0.2.0; extra == 'reaktion'
 Provides-Extra: unlok

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/__blok__.py

@@ -21,7 +21,6 @@ from arkitekt_next.bloks.namegen import PreformedNamesBlok
 from arkitekt_next.bloks.ollama import OllamaBlok
 from arkitekt_next.bloks.self_signed import SelfSignedBlok
 from arkitekt_next.bloks.kraph import KraphBlok
-from arkitekt_next.bloks.local_sign import LocalSignBlok
 from arkitekt_next.bloks.elektro import ElektroBlok
 from blok.blok import Blok
 
@@ -51,6 +50,5 @@ def get_bloks() -> list[Blok]:
         SecretBlok(),
         PreformedNamesBlok(),
         OrkestratorBlok(),
-        LocalSignBlok(),
         ElektroBlok(),
     ]

arkitekt_next-0.12.2/arkitekt_next/bloks/alpaka.py

@@ -0,0 +1,104 @@
+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.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 __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 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,
+        mount: MountService,
+        admin: AdminService,
+        secret: SecretService,
+        gateway: GatewayService | None = None,
+        dns: DnsService = None,
+        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,
+    ):
+        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,
+        )
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    def get_additional_options(self):
+        with_repos = Option(
+            subcommand="repos",
+            help="The default repos to enable for the service",
+            default=self.secret_key,
+        )
+
+        return [
+            with_repos,
+        ]

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/bloks/arkitekt.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, Optional
 from pydantic import BaseModel
 
 from arkitekt_next.bloks.kraph import KraphBlok
+from arkitekt_next.bloks.lok import LokBlok
 from arkitekt_next.bloks.tailscale import TailscaleBlok
 from blok import InitContext, Panel, Renderer, blok
 
@@ -26,21 +27,17 @@ class AdminCredentials(BaseModel):
 @blok(
     "live.arkitekt",
     dependencies=[
+        LokBlok.as_dependency(True, True),
         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),
-        LocalLiveKitBlok.as_dependency(True, True),
-        OrkestratorBlok.as_dependency(True, False),
-        KraphBlok.as_dependency(True, False),
-        TailscaleBlok.as_dependency(True, False),
-        OllamaBlok.as_dependency(True, False),
-        ElektroBlok.as_dependency(True, False),
+        KraphBlok.as_dependency(True, True),
+        ElektroBlok.as_dependency(True, True),
     ],
 )
 class ArkitektBlok:
-
     def entry(self, renderer: Renderer):
         renderer.render(
             Panel(

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/bloks/base.py

@@ -63,12 +63,10 @@ class BaseArkitektService:
         redis: RedisService,
         s3: S3Service,
         config: ConfigService,
-        channel: ChannelService,
         mount: MountService,
         admin: AdminService,
         secret: SecretService,
-        gateway: Optional[GatewayService] = None,
-        dns: DnsService = None,
+        gateway: GatewayService,
         mount_repo: bool = False,
         host: str = "",
         image: str = "",
@@ -100,12 +98,7 @@ class BaseArkitektService:
 
         django_secret = secret.retrieve_secret()
 
-        dns_result = dns.get_dns_result()
-
         csrf_trusted_origins = []
-        for hostname in dns_result.hostnames:
-            csrf_trusted_origins.append(f"http://{hostname}")
-            csrf_trusted_origins.append(f"https://{hostname}")
 
         configuration = YamlFile(
             **{

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/bloks/gateway.py

@@ -67,20 +67,13 @@ class CaddyBlok:
     def preflight(
         self,
         init: InitContext,
-        dns: DnsService,
         name: NameService,
-        certer: CerterService,
     ):
         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
         self.gateway_network = name.retrieve_name().replace("-", "_")
 
-        self.cert_mount = certer.retrieve_certs_mount()
-        self.depends_on = certer.retrieve_depends_on()
-
     def build(
         self,
         context: ExecutionContext,
@@ -95,7 +88,6 @@ class CaddyBlok:
             if port.tls:
                 caddyfile += f"""
 :{port.port} {{
-    tls /certs/caddy.crt /certs/caddy.key
     reverse_proxy {port.host}:{port.to}
 }}
                 """
@@ -112,7 +104,6 @@ class CaddyBlok:
 """
             caddyfile += (
                 """
-    tls /certs/caddy.crt /certs/caddy.key
     """
                 if protocol == "https" and self.cert_mount
                 else ""
@@ -173,8 +164,6 @@ class CaddyBlok:
         ]
 
         volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
-        if self.cert_mount:
-            volumes.append(f"{self.cert_mount}:/certs")
 
         caddy_container = {
             "image": "caddy:latest",
@@ -184,7 +173,6 @@ class CaddyBlok:
             ]
             + exposed_ports_strings,
             "volumes": volumes,
-            "depends_on": caddy_depends_on,
             "networks": [self.gateway_network, "default"],
         }
 

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/bloks/lok.py

@@ -35,7 +35,7 @@ class UserParamType(click.ParamType):
             return value
         try:
             name, password = value.split(":")
-            return {"name": name, "password": password}
+            return {"username": name, "password": password}
         except ValueError:
             self.fail(
                 f"User '{value}' is not in the correct format. It should be 'name:password'.",
@@ -176,8 +176,6 @@ class LokBlok:
         admin: AdminService,
         secrets: SecretBlok,
         s3: S3Service,
-        dns: DnsService,
-        livekit: Optional[LivekitService] = None,
     ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
@@ -193,9 +191,6 @@ class LokBlok:
         self.redis_access = redis.register()
         self.admin_access = admin.retrieve()
         self.s3_access = s3.create_buckets(self.buckets)
-        if livekit:
-            self.local_access = livekit.retrieve_access()
-        self.dns_result = dns.get_dns_result()
         self.initialized = True
 
     def build(self, context: ExecutionContext):
@@ -206,7 +201,7 @@ class LokBlok:
 
         if self.postgress_access.dependency:
             depends_on.append(self.postgress_access.dependency)
-            
+
         if self.s3_access.dependency:
             depends_on.append(self.s3_access.dependency)
 
@@ -219,7 +214,6 @@ class LokBlok:
             "volumes": [
                 "/var/run/docker.sock:/var/run/docker.sock",
                 "./configs/lok.yaml:/workspace/config.yaml",
-                "./certs:/certs",
             ],
         }
 
@@ -237,10 +231,6 @@ class LokBlok:
 
         trusted_origins = []
 
-        for i in self.dns_result.hostnames:
-            trusted_origins.append(f"http://{i}")
-            trusted_origins.append(f"https://{i}")
-
         configuration = YamlFile(
             **{
                 "db": asdict(self.postgress_access),
@@ -262,14 +252,8 @@ class LokBlok:
                 ],
                 "groups": [group for group in self.groups],
                 "deployment": {"name": self.deployment_name},
-                "livekit": (
-                    asdict(self.local_access)
-                    if self.local_access
-                    else {"api_key": "dev", "api_secret": "secret", "api_url": None}
-                ),
                 "s3": asdict(self.s3_access),
                 "token_expire_seconds": self.token_expiry_seconds,
-                "apps": [],
                 "force_script_name": "lok",
                 "csrf_trusted_origins": trusted_origins,
             }

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/arkitekt_next/protocols.py

@@ -16,6 +16,7 @@ from koil import unkoil
 from koil.composition import KoiledModel
 from arkitekt_next.base_models import Manifest
 from fakts_next import Fakts
+from herre_next import Herre
 
 
 if TYPE_CHECKING:

{arkitekt_next-0.12.1 → arkitekt_next-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkitekt-next"
-version = "0.12.1"
+version = "0.12.2"
 description = "client for the arkitekt_next platform"
 authors = [{ name = "jhnnsrs", email = "jhnnsrs@gmail.com" }]
 requires-python = ">=3.11,<4"
@@ -22,11 +22,11 @@ dependencies = [
 
 [project.optional-dependencies]
 cli = [
-    "turms>=0.8.2",
+    "turms>=0.9.0",
 ]
 alpaka = ["alpaka>=0.2.0"]
 kraph = ["kraph>=0.2.0"]
-mikro = ["mikro-next>=0.3.1"]
+mikro = ["mikro-next>=0.4.0"]
 kabinet = ["kabinet>=0.4.0"]
 elektro = ["elektro>=0.5.0"]
 fluss = ["fluss-next>=0.2.0"]
@@ -36,11 +36,11 @@ unlok = ["unlok-next>=0.2.0"]
 all = [
     "rich-click>=1.6.1",
     "watchfiles>=0.18.1",
-    "turms>=0.8.2",
+    "turms>=0.9",
     "semver>=3.0.1",
     "reaktion-next>=0.2.0",
     "rekuest-next>=0.7",
-    "mikro-next>=0.3.1",
+    "mikro-next>=0.4",
     "kabinet>=0.2.0",
     "fluss-next>=0.2.0",
     "unlok-next>=0.2.0",

arkitekt_next-0.12.1/arkitekt_next/bloks/alpaka.py

@@ -1,45 +0,0 @@
-from typing import Dict, Any
-import secrets
-
-
-from blok import blok, InitContext, ExecutionContext, Option
-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 __init__(self) -> None:
-        self.dev = False
-        self.host = "alpaka"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/jhnnsrs/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:next"
-
-    def get_additional_config(self):
-        return {"ensured_repos": self.ensured_repos}
-
-    def get_builder(self):
-        return "arkitekt.generic"
-
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)
-
-    def get_additional_options(self):
-        with_repos = Option(
-            subcommand="repos",
-            help="The default repos to enable for the service",
-            default=self.secret_key,
-        )
-
-        return [
-            with_repos,
-        ]

arkitekt_next-0.12.1/arkitekt_next/bloks/local_sign.py

@@ -1,261 +0,0 @@
-import click
-
-from pydantic import BaseModel
-from cryptography.hazmat.primitives import serialization as crypto_serialization
-from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.hazmat.backends import default_backend as crypto_default_backend
-from typing import Dict, Optional
-from arkitekt_next.bloks.secret import SecretBlok
-from arkitekt_next.bloks.services.admin import AdminService
-from arkitekt_next.bloks.services.db import DBService
-from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.services.livekit import LivekitService
-from arkitekt_next.bloks.services.lok import LokCredentials, LokService
-import yaml
-import secrets
-from dataclasses import asdict
-
-from arkitekt_next.bloks.services.redis import RedisService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.bloks.services.dns import DnsService
-from blok.tree import YamlFile, Repo
-from blok import blok, InitContext
-
-
-DEFAULT_ARKITEKT_URL = "http://localhost:8000"
-
-
-# Define a custom user type that will parse and validate the user input
-class UserParamType(click.ParamType):
-    name = "user"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            return value
-        try:
-            name, password = value.split(":")
-            return {"name": name, "password": password}
-        except ValueError:
-            self.fail(
-                f"User '{value}' is not in the correct format. It should be 'name:password'.",
-                param,
-                ctx,
-            )
-
-
-USER = UserParamType()
-
-
-# Define a custom user type that will parse and validate the user input
-class GroupParamType(click.ParamType):
-    name = "group"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            return value
-        try:
-            name, description = value.split(":")
-            return {"name": name, "description": description}
-        except ValueError:
-            self.fail(
-                f"User '{value}' is not in the correct format. It should be 'name:password'.",
-                param,
-                ctx,
-            )
-
-
-GROUP = GroupParamType()
-
-
-class RedeemTokenParamType(click.ParamType):
-    name = "redeem_token"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            assert "user" in value, f"scope is required {value}"
-            assert "token" in value, f"description is required {value}"
-            return value
-
-        try:
-            user, token = value.split(":")
-            return {"user": user, "token": token}
-        except ValueError:
-            self.fail(
-                f"RedeemToken '{value}' is not in the correct format. It should be 'username:token'.",
-                param,
-                ctx,
-            )
-
-
-TOKEN = RedeemTokenParamType()
-
-
-class ScopeParamType(click.ParamType):
-    name = "scope"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            assert "scope" in value, f"scope is required {value}"
-            assert "description" in value, f"description is required {value}"
-            return value
-
-        try:
-            name, description = value.split(":")
-            return {"scope": name, "description": description}
-        except ValueError:
-            self.fail(
-                f"Scopes '{value}' is not in the correct format. It should be 'scope:description'.",
-                param,
-                ctx,
-            )
-
-
-SCOPE = ScopeParamType()
-
-
-@blok(LokService, description="A local sign service")
-class LocalSignBlok:
-    db_name: str
-
-    def __init__(self) -> None:
-        self.db_name = "lok_db"
-        self.mount_repo = False
-        self.build_repo = False
-        self.private_key = None
-        self.public_key = None
-        self.host = "lok"
-        self.dev = False
-        self.with_repo = False
-        self.users = []
-        self.tokens = []
-        self.groups = []
-        self.scopes = {}
-        self.key = None
-        self.deployment_name = "default"
-        self.token_expiry_seconds = 700000
-        self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
-        self.registered_tokens = {}
-        self.local_access = None
-
-    def retrieve_credentials(self) -> LokCredentials:
-        return LokCredentials(
-            public_key=self.public_key, key_type="RS256", issuer="lok"
-        )
-
-    def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]:
-        return [
-            f"fakts.service={service_name}",
-            f"fakts.builder={builder_name}",
-        ]
-
-    def retrieve_token(self, user: str = "admin") -> str:
-        pass 
-        return "fake-token"
-
-    def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
-        self.scopes = self.scopes | scopes_dict
-
-    def preflight(
-        self,
-        init: InitContext
-    ):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        assert self.public_key, "Public key is required"
-        assert self.private_key, "Private key is required"
-
-
-    def build(self, context: ExecutionContext):
-        context.file_tree.set_nested("secrets", "public_key.pem", self.public_key)
-        context.file_tree.set_nested("secrets", "private_key.pem", self.private_key)
-
-    def get_options(self):
-        key = rsa.generate_private_key(
-            public_exponent=65537, key_size=2048, backend=crypto_default_backend()
-        )
-
-        private_key = key.private_bytes(
-            crypto_serialization.Encoding.PEM,
-            crypto_serialization.PrivateFormat.PKCS8,
-            crypto_serialization.NoEncryption(),
-        ).decode()
-
-        public_key = (
-            key.public_key()
-            .public_bytes(
-                crypto_serialization.Encoding.OpenSSH,
-                crypto_serialization.PublicFormat.OpenSSH,
-            )
-            .decode()
-        )
-
-        with_dev = Option(
-            subcommand="dev",
-            help="Run the service in development mode",
-            type=bool,
-            default=self.dev,
-            show_default=True,
-        )
-
-        with_fakts_url = Option(
-            subcommand="db_name",
-            help="The name of the database",
-            default="db_name",
-            show_default=True,
-        )
-        with_users = Option(
-            subcommand="users",
-            help="Users that should be greated by default. Format is name:password",
-            default=["admin:admin"],
-            multiple=True,
-            type=USER,
-            show_default=True,
-        )
-        with_groups = Option(
-            subcommand="groups",
-            help="Groups that should be greated by default. Format is name:description",
-            default=["admin:admin_group"],
-            multiple=True,
-            type=GROUP,
-            show_default=True,
-        )
-        with_public_key = Option(
-            subcommand="public_key",
-            help="The public key for the JWT creation",
-            default=public_key,
-            required=True,
-            callback=validate_public_key,
-        )
-        with_private_key = Option(
-            subcommand="private_key",
-            help="The corresponding private key for the JWT creation",
-            default=private_key,
-            callback=validate_private_key,
-            required=True,
-        )
-
-        return [
-            with_dev,
-            with_fakts_url,
-            with_users,
-            with_groups,
-            with_private_key,
-            with_public_key,
-        ]
-
-
-def validate_public_key(ctx, param, value):
-    if not value.startswith("ssh-rsa"):
-        raise click.BadParameter(
-            f"Public key must be in ssh-rsa format. Started with {value}"
-        )
-    return value
-
-
-def validate_private_key(ctx, param, value):
-    if not value.startswith("-----BEGIN PRIVATE KEY-----"):
-        raise click.BadParameter(
-            f"Private key must be in PEM format. Started with {value}"
-        )
-    return value