arkitekt-next 0.7.33__py3-none-any.whl → 0.7.34__py3-none-any.whl

arkitekt_next/bloks/kabinet.py

@@ -1,7 +1,8 @@
 from typing import Dict, Any
 import secrets
 
-from blok import blok, InitContext, ExecutionContext
+from arkitekt_next.bloks.funcs import create_default_service_yaml
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
 
 
@@ -12,13 +13,17 @@ class KabinetBlok:
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/jhnnsrs/kabinet-server"
         self.scopes = {"read_image": "Read image from the database"}
-        self.mount_repo = True
-        self.build_repo = True
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
         self.secret_key = secrets.token_hex(16)
         self.ensured_repos = []
+        self.image = "jhnnsrs/kabinet:next"
 
     def get_dependencies(self):
         return [
+            "live.arkitekt.mount",
+            "live.arkitekt.config",
             "live.arkitekt.gateway",
             "live.arkitekt.postgres",
             "live.arkitekt.lok",
@@ -27,106 +32,51 @@ class KabinetBlok:
             "live.arkitekt.s3",
         ]
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        deps = init.dependencies
+        self.service = create_default_service_yaml(init, self)
 
-        deps["live.arkitekt.lok"].register_scopes(self.scopes)
-
-        self.gateway_access = deps["live.arkitekt.gateway"].expose(
-            self.host, 80, self.host
-        )
-
-        self.postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
-        self.redis_access = deps["live.arkitekt.redis"].register()
-        self.lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
-        self.admin_access = deps["live.arkitekt.admin"].retrieve()
-        self.minio_access = deps["live.arkitekt.s3"].retrieve_credentials(["media"])
         self.initialized = True
 
     def build(self, context: ExecutionContext):
-        depends_on = []
-
-        if self.redis_access.dependency:
-            depends_on.append(self.redis_access.dependency)
-
-        if self.postgress_access.dependency:
-            depends_on.append(self.postgress_access.dependency)
-
-        db_service = {
-            "labels": [
-                "fakts.service=live.arkitekt.mikro",
-                "fakts.builder=arkitekt.mikro",
-            ],
-            "depends_on": depends_on,
-        }
-
-        if self.mount_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["volumes"] = [f"./mounts/{self.host}:/workspace"]
-
-        if self.build_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["build"] = f"./mounts/{self.host}"
-
-        db_service["command"] = self.command
-
-        configuration = YamlFile(
-            **{
-                "db": self.postgress_access.dict(),
-                "django": {
-                    "admin": self.admin_access.dict(),
-                    "debug": True,
-                    "hosts": ["*"],
-                    "secret_key": self.secret_key,
-                },
-                "redis": self.redis_access.dict(),
-                "lok": self.lok_access.dict(),
-                "s3": self.minio_access.dict(),
-                "scopes": self.scopes,
-            }
-        )
-
-        context.file_tree.set_nested("configs", "kabinet.yaml", configuration)
-
-        context.docker_compose.set_nested("services", self.host, db_service)
+        context.docker_compose.set_nested("services", self.host, self.service)
 
     def get_options(self):
-        with_repo = CLIOptions(
+        with_repo = Option(
             subcommand="with_repo",
             help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
             default=self.repo,
         )
-        with_command = CLIOptions(
+        with_command = Option(
             subcommand="command",
             help="Which command should be run when starting the service",
             default=self.command,
         )
-        mount_repo = CLIOptions(
+        mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
             is_flag=True,
-            default=True,
+            default=self.mount_repo,
         )
-        build_repo = CLIOptions(
+        build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
             is_flag=True,
-            default=True,
+            default=self.build_repo,
         )
-        with_host = CLIOptions(
+        with_host = Option(
             subcommand="host",
             help="How should the service be named inside the docker-compose file?",
             default=self.host,
         )
-        with_secret_key = CLIOptions(
+        with_secret_key = Option(
             subcommand="secret_key",
             help="The secret key to use for the django service",
             default=self.secret_key,
         )
-        with_repos = CLIOptions(
+        with_repos = Option(
             subcommand="repos",
             help="The default repos to enable for the service",
             default=self.secret_key,

arkitekt_next/bloks/livekit.py

@@ -1,12 +1,14 @@
 from typing import Dict, Any
 import secrets
 
-from blok import blok, InitContext, ExecutionContext, CLIOption
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.livekit import LivekitService, LivekitCredentials
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
 
-@blok("io.livekit.livekit")
-class LiveKitBlok:
+@blok(LivekitService)
+class LocalLiveKitBlok:
     def __init__(self) -> None:
         self.host = "livekit"
         self.command = ["--dev", "--bind", "0.0.0.0"]
@@ -16,24 +18,35 @@ class LiveKitBlok:
         self.secret_key = secrets.token_hex(16)
         self.ensured_repos = []
         self.port_range = [50000, 50030]
+        self.api_key = "devkey"
+        self.api_secret = "secret"
+        self.skip = False
 
-    def get_dependencies(self):
-        return [
-            "live.arkitekt.gateway",
-        ]
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext, gateway: GatewayService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
         deps = init.dependencies
 
-        deps["live.arkitekt.gateway"].expose_port(7880, self.host, True)
-        deps["live.arkitekt.gateway"].expose_port(7881, self.host, True)
+        if self.skip:
+            return
+
+        gateway.expose_port(7880, self.host, True)
+        gateway.expose_port(7881, self.host, True)
 
         self.initialized = True
 
+    def retrieve_access(self):
+        return LivekitCredentials(**{
+            "api_key": self.api_key,
+            "api_secret": self.api_secret,
+            "api_url": f"http://{self.host}:7880",
+        })
+
     def build(self, context: ExecutionContext):
+        if self.skip:
+            return
         db_service = {
             "labels": [
                 "fakts.service=io.livekit.livekit",
@@ -49,20 +62,28 @@ class LiveKitBlok:
         context.docker_compose.set_nested("services", self.host, db_service)
 
     def get_options(self):
-        with_command = CLIOption(
+        with_command = Option(
             subcommand="command",
             help="The fakts url for connection",
             default=self.command,
         )
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="The fakts url for connection",
             default=self.host,
         )
+        with_skip = Option(
+            subcommand="skip",
+            help="The fakts url for connection",
+            default=False,
+            type=bool,
+            is_flag=True,
+        )
 
         return [
             with_host,
             with_command,
+            with_skip,
         ]
 
     def __str__(self) -> str:

arkitekt_next/bloks/lok.py

@@ -5,21 +5,23 @@ 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
+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 blok import blok, InitContext, ExecutionContext, CLIOption
+from arkitekt_next.bloks.services.redis import RedisService
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from blok import blok, InitContext
 
 
-DEFAULT_ARKITEKT_URL = "http://localhost:8000"
-
 
-class LokCredentials(BaseModel):
-    issuer: str
-    key_type: str
-    public_key: str
+DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 
 
 # Define a custom user type that will parse and validate the user input
@@ -110,7 +112,7 @@ class ScopeParamType(click.ParamType):
 SCOPE = ScopeParamType()
 
 
-@blok("live.arkitekt.lok")
+@blok(LokService)
 class LokBlok:
     db_name: str
 
@@ -124,15 +126,29 @@ class LokBlok:
         self.with_repo = False
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/jhnnsrs/lok-server-next"
+        self.image = "jhnnsrs/lok:next"
         self.users = []
         self.tokens = []
         self.groups = []
         self.secret_key = secrets.token_hex(16)
         self.scopes = {"hallo": "welt"}
         self.key = None
+        self.deployment_name = "default"
+        self.base_routes = [
+            "ht",
+            "o",
+            "graphql",
+            ".well-known",
+            "f",
+            "admin",
+            "static",
+            "accounts",
+        ]
+        self.token_expiry_seconds = 700000
 
     def get_dependencies(self):
         return [
+            "io.livekit.livekit",
             "live.arkitekt.postgres",
             "live.arkitekt.redis",
             "live.arkitekt.admin",
@@ -144,24 +160,33 @@ class LokBlok:
             public_key=self.public_key, key_type="RS256", issuer="lok"
         )
 
+    def retrieve_labels(self, service_name: str) -> list[str]:
+        return [
+            f"fakts.service={service_name}",
+            f"fakts.builder=arkitekt.{service_name}",
+        ]
+
     def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
         self.scopes = self.scopes | scopes_dict
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, livekit: LivekitService, scopes: list[Dict[str, str]]):
         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"
 
-        kwargs = init.kwargs
-        deps = init.dependencies
-        scopes = kwargs.get("scopes", [])
         self.scopes = {scope["scope"]: scope["description"] for scope in scopes}
 
-        self.postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
-        self.redis_access = deps["live.arkitekt.redis"].register()
-        self.admin_access = deps["live.arkitekt.admin"].retrieve()
+        for i in self.base_routes:
+             gateway.expose(
+                i, 80, self.host, strip_prefix=False
+            )
+
+        self.postgress_access = db.register_db(self.host)
+        self.redis_access = redis.register()
+        self.admin_access = admin.retrieve()
+        self.local_access = livekit.retrieve_access()
         self.initialized = True
 
     def build(self, context: ExecutionContext):
@@ -176,35 +201,46 @@ class LokBlok:
         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",
+                "./certs:/certs",
+            ],
         }
 
         if self.mount_repo:
             context.file_tree.set_nested("mounts", "lok", Repo(self.repo))
-            db_service["volumes"] = ["./mounts/lok:/lok"]
+            db_service["volumes"].append("./mounts/lok:/lok")
 
         if self.build_repo:
             context.file_tree.set_nested("mounts", "lok", Repo(self.repo))
             db_service["build"] = "./mounts/lok"
+        else:
+            db_service["image"] = self.image
 
         db_service["command"] = self.command
 
         configuration = YamlFile(
             **{
-                "db": self.postgress_access.dict(),
+                "db": asdict(self.postgress_access),
                 "users": [user for user in self.users],
                 "django": {
-                    "admin": self.admin_access.dict(),
+                    "admin": asdict(self.admin_access),
                     "debug": True,
                     "hosts": ["*"],
                     "secret_key": self.secret_key,
                 },
-                "redis": self.redis_access.dict(),
-                "lok": self.retrieve_credentials().dict(),
+                "redis":  asdict(self.redis_access),
+                "lok": asdict(self.retrieve_credentials()),
                 "private_key": self.private_key,
                 "public_key": self.public_key,
                 "scopes": self.scopes,
                 "redeem_tokens": [token for token in self.tokens],
                 "groups": [group for group in self.groups],
+                "deployment": {"name": self.deployment_name},
+                "livekit": asdict(self.local_access),
+                "token_expire_seconds": self.token_expiry_seconds,
+                "apps": [],
             }
         )
 
@@ -232,82 +268,82 @@ class LokBlok:
             .decode()
         )
 
-        with_fakts_url = CLIOption(
+        with_fakts_url = Option(
             subcommand="db_name",
             help="The fakts url for connection",
             default="db_name",
         )
-        with_users = CLIOption(
+        with_users = Option(
             subcommand="users",
             help="The fakts url for connection",
             default=["admin:admin"],
             multiple=True,
             type=USER,
         )
-        with_groups = CLIOption(
+        with_groups = Option(
             subcommand="groups",
             help="The fakts url for connection",
             default=["admin:admin_group"],
             multiple=True,
             type=GROUP,
         )
-        with_redeem_token = CLIOption(
+        with_redeem_token = Option(
             subcommand="tokens",
             help="The fakts url for connection",
             default=[],
             multiple=True,
             type=TOKEN,
         )
-        with_scopes = CLIOption(
+        with_scopes = Option(
             subcommand="scopes",
             help="The scopes",
             default=[f"{key}:{value}" for key, value in self.scopes.items()],
             multiple=True,
             type=SCOPE,
         )
-        with_repo = CLIOption(
+        with_repo = Option(
             subcommand="with_repo",
             help="The fakts url for connection",
             default=self.repo,
         )
-        with_repo = CLIOption(
+        with_repo = Option(
             subcommand="command",
             help="The fakts url for connection",
             default=self.command,
         )
-        mount_repo = CLIOption(
+        mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
             is_flag=True,
             default=False,
         )
-        build_repo = CLIOption(
+        build_repo = Option(
             subcommand="build_repo",
             help="The fakts url for connection",
             is_flag=True,
             default=False,
         )
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="The fakts url for connection",
             default=self.host,
         )
         #
-        with_public_key = CLIOption(
+        with_public_key = Option(
             subcommand="public_key",
             help="The fakts url for connection",
             default=public_key,
             required=True,
             callback=validate_public_key,
         )
-        with_private_key = CLIOption(
+        with_private_key = Option(
             subcommand="private_key",
             help="The fakts url for connection",
             default=private_key,
             callback=validate_private_key,
             required=True,
         )
-        with_secret_key = CLIOption(
+        with_secret_key = Option(
             subcommand="secret_key",
             help="The fakts url for connection",
             default=self.secret_key,

arkitekt_next/bloks/mikro.py

@@ -5,8 +5,9 @@ import yaml
 import secrets
 from blok import blok, InitContext
 
-from blok import blok, InitContext, ExecutionContext, CLIOption
+from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
+from arkitekt_next.bloks.funcs import create_default_service_yaml
 
 
 class AccessCredentials(BaseModel):
@@ -24,15 +25,16 @@ class MikroBlok:
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/jhnnsrs/mikro-server-next"
         self.scopes = {"read_image": "Read image from the database"}
-        self.mount_repo = True
-        self.build_repo = True
+        self.image = "jhnnsrs/mikro:next"
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media", "zarr", "parquet"]
         self.secret_key = secrets.token_hex(16)
 
-    def get_identifier(self):
-        return "live.arkitekt.mikro"
-
     def get_dependencies(self):
         return [
+            "live.arkitekt.mount",
+            "live.arkitekt.config",
             "live.arkitekt.gateway",
             "live.arkitekt.postgres",
             "live.arkitekt.lok",
@@ -41,102 +43,46 @@ class MikroBlok:
             "live.arkitekt.s3",
         ]
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        deps = init.dependencies
-        deps["live.arkitekt.lok"].register_scopes(self.scopes)
-
-        self.gateway_access = deps["live.arkitekt.gateway"].expose(
-            self.host, 80, self.host
-        )
+        self.service = create_default_service_yaml(init, self)
 
-        self.postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
-        self.redis_access = deps["live.arkitekt.redis"].register()
-        self.lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
-        self.admin_access = deps["live.arkitekt.admin"].retrieve()
-        self.minio_access = deps["live.arkitekt.s3"].retrieve_credentials(
-            ["zarr", "media"]
-        )
         self.initialized = True
 
     def build(self, context: ExecutionContext):
-        depends_on = []
-
-        if self.redis_access.dependency:
-            depends_on.append(self.redis_access.dependency)
-
-        if self.postgress_access.dependency:
-            depends_on.append(self.postgress_access.dependency)
-
-        db_service = {
-            "labels": [
-                "fakts.service=live.arkitekt.mikro",
-                "fakts.builder=arkitekt.mikro",
-            ],
-            "depends_on": depends_on,
-        }
-
-        if self.mount_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["volumes"] = [f"./mounts/{self.host}:/workspace"]
-
-        if self.build_repo:
-            context.file_tree.set_nested("mounts", self.host, Repo(self.repo))
-            db_service["build"] = f"./mounts/{self.host}"
-
-        db_service["command"] = self.command
-
-        configuration = YamlFile(
-            **{
-                "db": self.postgress_access.dict(),
-                "django": {
-                    "admin": self.admin_access.dict(),
-                    "debug": True,
-                    "hosts": ["*"],
-                    "secret_key": self.secret_key,
-                },
-                "redis": self.redis_access.dict(),
-                "lok": self.lok_access.dict(),
-                "s3": self.minio_access.dict(),
-                "scopes": self.scopes,
-            }
-        )
-
-        context.file_tree.set_nested("configs", "mikro.yaml", configuration)
-
-        context.docker_compose.set_nested("services", self.host, db_service)
+        context.docker_compose.set_nested("services", self.host, self.service)
 
     def get_options(self):
-        with_repo = CLIOption(
+        with_repo = Option(
             subcommand="with_repo",
             help="The fakts url for connection",
             default=self.repo,
         )
-        with_command = CLIOption(
+        with_command = Option(
             subcommand="command",
             help="The fakts url for connection",
             default=self.command,
         )
-        mount_repo = CLIOption(
+        mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
             is_flag=True,
-            default=True,
+            default=self.mount_repo,
         )
-        build_repo = CLIOption(
+        build_repo = Option(
             subcommand="build_repo",
             help="The fakts url for connection",
             is_flag=True,
-            default=True,
+            default=self.build_repo,
         )
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="The fakts url for connection",
             default=self.host,
         )
-        with_secret_key = CLIOption(
+        with_secret_key = Option(
             subcommand="secret_key",
             help="The fakts url for connection",
             default=self.secret_key,