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

arkitekt_next/bloks/livekit.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.livekit import LivekitService, LivekitCredentials
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+@blok(LivekitService)
+class LocalLiveKitBlok:
+    def __init__(self) -> None:
+        self.host = "livekit"
+        self.command = ["--dev", "--bind", "0.0.0.0"]
+        self.image = "livekit/livekit-server:latest"
+        self.mount_repo = True
+        self.build_repo = True
+        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 preflight(self, init: InitContext, gateway: GatewayService):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        deps = init.dependencies
+
+        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",
+                "fakts.builder=livekitio.livekit",
+            ],
+            "image": self.image,
+            "command": self.command,
+            "ports": [
+                f"{self.port_range[0]}-{self.port_range[1]}:{self.port_range[0]}-{self.port_range[1]}"
+            ],
+        }
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    def get_options(self):
+        with_command = Option(
+            subcommand="command",
+            help="The fakts url for connection",
+            default=self.command,
+        )
+        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:
+        return (
+            f"LiveKitBlok(host={self.host}, command={self.command}, image={self.image})"
+        )

arkitekt_next/bloks/lok.py

@@ -0,0 +1,381 @@
+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
+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.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)
+class LokBlok:
+    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.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",
+            "live.arkitekt.gateway",
+        ]
+
+    def retrieve_credentials(self) -> LokCredentials:
+        return LokCredentials(
+            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 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"
+
+        self.scopes = {scope["scope"]: scope["description"] for scope in scopes}
+
+        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):
+        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.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"].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": asdict(self.postgress_access),
+                "users": [user for user in self.users],
+                "django": {
+                    "admin": asdict(self.admin_access),
+                    "debug": True,
+                    "hosts": ["*"],
+                    "secret_key": self.secret_key,
+                },
+                "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": [],
+            }
+        )
+
+        context.file_tree.set_nested("configs", "lok.yaml", configuration)
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    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_fakts_url = Option(
+            subcommand="db_name",
+            help="The fakts url for connection",
+            default="db_name",
+        )
+        with_users = Option(
+            subcommand="users",
+            help="The fakts url for connection",
+            default=["admin:admin"],
+            multiple=True,
+            type=USER,
+        )
+        with_groups = Option(
+            subcommand="groups",
+            help="The fakts url for connection",
+            default=["admin:admin_group"],
+            multiple=True,
+            type=GROUP,
+        )
+        with_redeem_token = Option(
+            subcommand="tokens",
+            help="The fakts url for connection",
+            default=[],
+            multiple=True,
+            type=TOKEN,
+        )
+        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 = Option(
+            subcommand="with_repo",
+            help="The fakts url for connection",
+            default=self.repo,
+        )
+        with_repo = Option(
+            subcommand="command",
+            help="The fakts url for connection",
+            default=self.command,
+        )
+        mount_repo = Option(
+            subcommand="mount_repo",
+            help="The fakts url for connection",
+            is_flag=True,
+            default=False,
+        )
+        build_repo = Option(
+            subcommand="build_repo",
+            help="The fakts url for connection",
+            is_flag=True,
+            default=False,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        #
+        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 = Option(
+            subcommand="private_key",
+            help="The fakts url for connection",
+            default=private_key,
+            callback=validate_private_key,
+            required=True,
+        )
+        with_secret_key = Option(
+            subcommand="secret_key",
+            help="The fakts url for connection",
+            default=self.secret_key,
+        )
+
+        return [
+            with_fakts_url,
+            with_users,
+            with_repo,
+            mount_repo,
+            with_groups,
+            build_repo,
+            with_host,
+            with_redeem_token,
+            with_private_key,
+            with_public_key,
+            with_scopes,
+            with_secret_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

arkitekt_next/bloks/mikro.py

@@ -0,0 +1,98 @@
+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.funcs import create_default_service_yaml
+
+
+class AccessCredentials(BaseModel):
+    password: str
+    username: str
+    host: str
+    port: str
+    db_name: str
+
+
+@blok("live.arkitekt.mikro")
+class MikroBlok:
+    def __init__(self) -> None:
+        self.host = "mikro"
+        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.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_dependencies(self):
+        return [
+            "live.arkitekt.mount",
+            "live.arkitekt.config",
+            "live.arkitekt.gateway",
+            "live.arkitekt.postgres",
+            "live.arkitekt.lok",
+            "live.arkitekt.admin",
+            "live.arkitekt.redis",
+            "live.arkitekt.s3",
+        ]
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.service = create_default_service_yaml(init, self)
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    def get_options(self):
+        with_repo = Option(
+            subcommand="with_repo",
+            help="The fakts url for connection",
+            default=self.repo,
+        )
+        with_command = Option(
+            subcommand="command",
+            help="The fakts url for connection",
+            default=self.command,
+        )
+        mount_repo = Option(
+            subcommand="mount_repo",
+            help="The fakts url for connection",
+            is_flag=True,
+            default=self.mount_repo,
+        )
+        build_repo = Option(
+            subcommand="build_repo",
+            help="The fakts url for connection",
+            is_flag=True,
+            default=self.build_repo,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        with_secret_key = Option(
+            subcommand="secret_key",
+            help="The fakts url for connection",
+            default=self.secret_key,
+        )
+
+        return [
+            with_repo,
+            mount_repo,
+            build_repo,
+            with_host,
+            with_command,
+            with_secret_key,
+        ]