arkitekt-next 0.7.32__tar.gz → 0.7.34__tar.gz

{arkitekt_next-0.7.32 → arkitekt_next-0.7.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.32
+Version: 0.7.34
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs

arkitekt_next-0.7.34/arkitekt_next/__blok__.py

@@ -0,0 +1,37 @@
+from arkitekt_next.bloks.admin import AdminBlok
+from arkitekt_next.bloks.arkitekt import ArkitektBlok
+from arkitekt_next.bloks.mikro import MikroBlok
+from arkitekt_next.bloks.fluss import FlussBlok
+from arkitekt_next.bloks.redis import RedisBlok
+from arkitekt_next.bloks.gateway import GatewayBlok
+from arkitekt_next.bloks.livekit import LocalLiveKitBlok
+from arkitekt_next.bloks.postgres import PostgresBlok
+from arkitekt_next.bloks.minio import MinioBlok
+from arkitekt_next.bloks.kabinet import KabinetBlok
+from arkitekt_next.bloks.lok import LokBlok
+from arkitekt_next.bloks.config import ConfigBlok
+from arkitekt_next.bloks.mount import MountBlok
+from arkitekt_next.bloks.internal_docker import InternalDockerBlok
+from arkitekt_next.bloks.socket import DockerSocketBlok
+from arkitekt_next.bloks.rekuest import RekuestBlok
+
+
+def get_bloks():
+    return [
+        AdminBlok(),
+        ArkitektBlok(),
+        MikroBlok(),
+        FlussBlok(),
+        RedisBlok(),
+        GatewayBlok(),
+        LocalLiveKitBlok(),
+        PostgresBlok(),
+        MinioBlok(),
+        LokBlok(),
+        KabinetBlok(),
+        MountBlok(),
+        ConfigBlok(),
+        InternalDockerBlok(),
+        DockerSocketBlok(),
+        RekuestBlok(),
+    ]

arkitekt_next-0.7.34/arkitekt_next/bloks/__init__.py

@@ -0,0 +1,2 @@
+from .admin import AdminBlok
+

arkitekt_next-0.7.34/arkitekt_next/bloks/admin.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Option
+from arkitekt_next.bloks.services.admin import AdminService, AdminCredentials
+
+
+@blok(AdminService)
+class AdminBlok:
+    def __init__(self) -> None:
+        self.password = "admin"
+        self.username = "admin"
+        self.email = "admin@admin.com"
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def retrieve(self):
+        return AdminCredentials(
+            password=self.password,
+            username=self.username,
+            email=self.email,
+        )
+
+    def get_options(self):
+        with_username = Option(
+            subcommand="username",
+            help="Which admin username to use",
+            default=self.username,
+            show_default=True,
+        )
+        with_username = Option(
+            subcommand="password",
+            help="Which password to use",
+            default=self.password,
+            show_default=True,
+        )
+        with_email = Option(
+            subcommand="password",
+            help="Which password to use",
+            default=self.password,
+            show_default=True,
+        )
+
+        return [with_username, with_username, with_email]

arkitekt_next-0.7.34/arkitekt_next/bloks/arkitekt.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Renderer, Panel
+from .livekit import LocalLiveKitBlok
+from .mikro import MikroBlok
+from .kabinet import KabinetBlok
+from .rekuest import RekuestBlok
+from .fluss import FlussBlok
+from .gateway import GatewayBlok
+from .internal_docker import InternalDockerBlok
+
+
+class AdminCredentials(BaseModel):
+    password: str
+    username: str
+    email: str
+
+
+@blok("live.arkitekt")
+class ArkitektBlok:
+
+    def entry(self, renderer: Renderer):
+        renderer.render(
+            Panel(
+                f"This is the arkitekt build that allows you to setup a full stack arkitekt application. Make sure to understand how bloks work before proceeding.",
+                expand=False,
+                title="Welcome to Arkitekt!",
+                style="bold magenta",
+            )
+        )
+
+    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok):
+        print (lok, mikro, kabinet, rekuest, fluss, gateway, internal_engine)
+
+
+    def build(self, cwd):
+        pass
+

arkitekt_next-0.7.34/arkitekt_next/bloks/config.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Option, ExecutionContext
+from blok.tree import YamlFile
+from arkitekt_next.bloks.services.config import ConfigService
+
+class AdminCredentials(BaseModel):
+    password: str
+    username: str
+    email: str
+
+
+@blok(ConfigService)
+class ConfigBlok:
+    def __init__(self) -> None:
+        self.config_path = "configs"
+        self.registered_configs = {}
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, ex: ExecutionContext):
+        for name, file in self.registered_configs.items():
+            ex.file_tree.set_nested(*f"{self.config_path}/{name}".split("/"), file)
+
+    def register_config(self, name: str, file: YamlFile) -> str:
+        self.registered_configs[name] = file
+        return f"./{self.config_path}/" + name
+
+    def get_path(self, name: str) -> str:
+        return f"./{self.config_path}/" + name
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="config_path",
+            help="Which path to use for configs",
+            default=self.config_path,
+            show_default=True,
+        )
+
+        return [config_path]

arkitekt_next-0.7.34/arkitekt_next/bloks/fluss.py

@@ -0,0 +1,88 @@
+import secrets
+from arkitekt_next.bloks.funcs import create_default_service_yaml
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+DEFAULT_ARKITEKT_URL = "http://localhost:8000"
+
+
+@blok("live.arkitekt.fluss")
+class FlussBlok:
+    def __init__(self) -> None:
+        self.host = "fluss"
+        self.command = "bash run-debug.sh"
+        self.image = "jhnnsrs/fluss:next"
+        self.repo = "https://github.com/jhnnsrs/fluss-server-next"
+        self.scopes = {"read_image": "Read image from the database"}
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+        self.ensured_repos = []
+
+    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="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
+            default=self.repo,
+        )
+        with_command = Option(
+            subcommand="command",
+            help="Which command should be run when starting the service",
+            default=self.command,
+        )
+        mount_repo = Option(
+            subcommand="mount_repo",
+            help="Should we mount the repo into the container?",
+            is_flag=True,
+            default=self.mount_repo,
+        )
+        build_repo = Option(
+            subcommand="build_repo",
+            help="Should we build the container from the repo?",
+            is_flag=True,
+            default=self.build_repo,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="How should the service be named inside the docker-compose file?",
+            default=self.host,
+        )
+        with_secret_key = Option(
+            subcommand="secret_key",
+            help="The secret key to use for the django service",
+            default=self.secret_key,
+        )
+
+        return [
+            with_repo,
+            mount_repo,
+            build_repo,
+            with_host,
+            with_command,
+            with_secret_key,
+        ]

arkitekt_next-0.7.34/arkitekt_next/bloks/funcs.py

@@ -0,0 +1,86 @@
+from blok import blok, InitContext, Option
+from blok.tree import YamlFile, Repo
+from typing import Protocol
+from blok.utils import check_protocol_compliance
+from dataclasses import asdict
+
+class DefaultService(Protocol):
+    service_name: str
+    host: str
+    buckets: list[str]
+    scopes: dict[str, str]
+    secret_key: str
+    mount_repo: bool
+    build_repo: bool
+
+    def get_identifier(self) -> str: ...
+
+
+def create_default_service_yaml(
+    init: InitContext,
+    self: DefaultService,
+) -> YamlFile:
+    check_protocol_compliance(self, DefaultService)
+    deps = init.dependencies
+    deps["live.arkitekt.lok"].register_scopes(self.scopes)
+
+    gateway_access = deps["live.arkitekt.gateway"].expose(self.host, 80, self.host)
+
+    postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
+    redis_access = deps["live.arkitekt.redis"].register()
+    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
+    admin_access = deps["live.arkitekt.admin"].retrieve()
+    minio_access = deps["live.arkitekt.s3"].create_buckets(self.buckets)
+    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
+    lok_labels = deps["live.arkitekt.lok"].retrieve_labels(self.get_identifier())
+
+    configuration = YamlFile(
+        **{
+            "db": asdict(postgress_access),
+            "django": {
+                "admin": asdict(admin_access),
+                "debug": True,
+                "hosts": ["*"],
+                "secret_key": self.secret_key,
+            },
+            "redis": asdict(redis_access),
+            "lok": asdict(lok_access),
+            "s3": asdict(minio_access),
+            "scopes": self.scopes,
+        }
+    )
+
+    config_mount = deps["live.arkitekt.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)
+
+    service = {
+        "labels": lok_labels,
+        "volumes": [f"{config_mount}:/workspace/config.yaml"],
+        "depends_on": depends_on,
+    }
+
+    if self.mount_repo:
+        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        service["volumes"].extend([f"{mount}:/workspace"])
+
+    if self.build_repo:
+        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        service["build"] = mount
+    else:
+        service["image"] = self.image
+
+    service["command"] = self.command
+
+    return service

arkitekt_next-0.7.34/arkitekt_next/bloks/gateway.py

@@ -0,0 +1,173 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from pydantic import BaseModel
+from typing import Dict, Any
+
+from blok import blok, InitContext
+
+
+DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
+DEFAULT_PUBLIC_HOSTS = ["localhost"]
+
+
+class ExposedHost(BaseModel):
+    host: str
+    port: int
+    stip_prefix: bool = True
+
+
+class ExposedPort(BaseModel):
+    port: int
+    host: str
+    tls: bool = False
+
+
+@blok("live.arkitekt.gateway")
+class GatewayBlok:
+    def __init__(self) -> None:
+        self.exposed_hosts = {}
+        self.http_expose_default = None
+        self.exposed_ports = {}
+        self.with_certer = True
+        self.with_tailscale = True
+        self.certer_image = "jhnnsrs/certer:next"
+        self.http_port = 80
+        self.https_port = 443
+        self.public_ips = DEFAULT_PUBLIC_URLS
+        self.public_hosts = DEFAULT_PUBLIC_HOSTS
+
+    def get_dependencies(self):
+        return []
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, context: ExecutionContext):
+        caddyfile = """
+{
+    auto_https off
+}
+        """
+
+        for key, port in self.exposed_ports.items():
+            if port.tls:
+                caddyfile += f"""
+:{port.port} {{
+    tls /certs/caddy.crt /certs/caddy.key
+    reverse_proxy {port.host}:{port.port}
+}}
+                """
+            else:
+                caddyfile += f"""
+:{port.port} {{
+    reverse_proxy {port.host}:{port.port}
+}}
+                """
+
+        for protocol in ["http", "https"]:
+            caddyfile += f"""
+{protocol}:// {{
+"""
+            caddyfile += (
+                """
+    tls /certs/caddy.crt /certs/caddy.key
+    """
+                if protocol == "https"
+                else ""
+            )
+            caddyfile += """
+    header {
+        -Server
+        X-Forwarded-Proto {scheme}
+        X-Forwarded-For {remote}
+        X-Forwarded-Port {server_port}
+        X-Forwarded-Host {host}
+    }
+        """
+
+            for path_name, exposed_host in self.exposed_hosts.items():
+                if exposed_host.stip_prefix:
+                    caddyfile += f"""
+    @{path_name} path /{path_name}* 
+    handle @{path_name} {{
+        uri strip_prefix /{path_name}
+        reverse_proxy {exposed_host.host}:{exposed_host.port}
+    }}
+                """
+                else:
+                    caddyfile += f"""
+    @{path_name} path /{path_name}*
+    handle @{path_name} {{
+        reverse_proxy {exposed_host.host}:{exposed_host.port}
+    }}
+                """
+
+            if self.http_expose_default:
+                caddyfile += f"""
+    handle {{
+        reverse_proxy {self.http_expose_default.host}:{self.http_expose_default.port}
+    }}
+            """
+
+            caddyfile += """
+}
+        """
+
+        context.file_tree.set_nested("configs", "Caddyfile", caddyfile)
+
+        caddy_depends_on = []
+        if self.with_certer:
+            caddy_depends_on.append("certer")
+
+        caddy_container = {
+            "image": "caddy:latest",
+            "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
+            "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
+            "depends_on": caddy_depends_on,
+        }
+
+        context.docker_compose.set_nested("services", "caddy", caddy_container)
+
+        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", "certer", certer_container)
+
+    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
+        self.exposed_hosts[path_name] = ExposedHost(
+            host=host, port=port, stip_prefix=strip_prefix
+        )
+
+    def expose_default(self, port: int, host: str):
+        self.http_expose_default = ExposedHost(host=host, port=port, stip_prefix=False)
+
+    def expose_port(self, port: int, host: str, tls: bool = False):
+        self.exposed_ports[port] = ExposedPort(port=port, host=host, tls=tls)
+
+    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.7.34/arkitekt_next/bloks/internal_docker.py

@@ -0,0 +1,80 @@
+from typing import Dict, Any
+import secrets
+
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+
+
+@blok("live.arkitekt.internal_engine")
+class InternalDockerBlok:
+    def __init__(self) -> None:
+        self.host = "internal_docker"
+        self.command = (
+            "arkitekt-next run prod --redeem-token=mylittletoken --url http://caddy:80"
+        )
+        self.image = "jhnnsrs/deployer:0.0.1-vanilla"
+        self.instance_id = "INTERNAL_DOCKER"
+
+    def get_dependencies(self):
+        return ["live.arkitekt.docker_socket"]
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        deps = init.dependencies
+
+        if self.skip:
+            return
+
+        self._socket = deps["live.arkitekt.docker_socket"].register_socket(self.host)
+
+        self.initialized = True
+
+    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,
+            "volumes": [f"{self._socket}:/var/run/docker.sock"],
+            "environment": {
+                "INSTANCE_ID": self.instance_id,
+            },
+        }
+
+        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"InterDocker(host={self.host}, command={self.command}, image={self.image})"
+        )

arkitekt_next-0.7.34/arkitekt_next/bloks/kabinet.py

@@ -0,0 +1,93 @@
+from typing import Dict, Any
+import secrets
+
+from arkitekt_next.bloks.funcs import create_default_service_yaml
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import Repo, YamlFile
+
+
+@blok("live.arkitekt.kabinet")
+class KabinetBlok:
+    def __init__(self) -> None:
+        self.host = "kabinet"
+        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 = 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",
+            "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="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
+            default=self.repo,
+        )
+        with_command = Option(
+            subcommand="command",
+            help="Which command should be run when starting the service",
+            default=self.command,
+        )
+        mount_repo = Option(
+            subcommand="mount_repo",
+            help="Should we mount the repo into the container?",
+            is_flag=True,
+            default=self.mount_repo,
+        )
+        build_repo = Option(
+            subcommand="build_repo",
+            help="Should we build the container from the repo?",
+            is_flag=True,
+            default=self.build_repo,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="How should the service be named inside the docker-compose file?",
+            default=self.host,
+        )
+        with_secret_key = Option(
+            subcommand="secret_key",
+            help="The secret key to use for the django service",
+            default=self.secret_key,
+        )
+        with_repos = Option(
+            subcommand="repos",
+            help="The default repos to enable for the service",
+            default=self.secret_key,
+        )
+
+        return [
+            with_repo,
+            mount_repo,
+            build_repo,
+            with_host,
+            with_command,
+            with_secret_key,
+            with_repos,
+        ]