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

arkitekt_next/__blok__.py

@@ -0,0 +1,25 @@
+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 LiveKitBlok
+from arkitekt_next.bloks.postgres import PostgresBlok
+from arkitekt_next.bloks.minio import MinioBlok
+from arkitekt_next.bloks.lok import LokBlok
+
+
+def get_bloks():
+    return [
+        AdminBlok(),
+        ArkitektBlok(),
+        MikroBlok(),
+        FlussBlok(),
+        RedisBlok(),
+        GatewayBlok(),
+        LiveKitBlok(),
+        PostgresBlok(),
+        MinioBlok(),
+        LokBlok(),
+    ]

arkitekt_next/bloks/__init__.py

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

arkitekt_next/bloks/admin.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, CLIOption
+
+
+class AdminCredentials(BaseModel):
+    password: str
+    username: str
+    email: str
+
+
+@blok("live.arkitekt.admin")
+class AdminBlok:
+    def __init__(self) -> None:
+        self.password = "admin"
+        self.username = "admin"
+        self.email = "admin@admin.com"
+
+    def init(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, cwd):
+        pass
+
+    def retrieve(self):
+        return AdminCredentials(
+            password=self.password,
+            username=self.username,
+            email=self.email,
+        )
+
+    def get_options(self):
+        with_username = CLIOption(
+            subcommand="username",
+            help="Which admin username to use",
+            default=self.username,
+            show_default=True,
+        )
+        with_username = CLIOption(
+            subcommand="password",
+            help="Which password to use",
+            default=self.password,
+            show_default=True,
+        )
+        with_email = CLIOption(
+            subcommand="password",
+            help="Which password to use",
+            default=self.password,
+            show_default=True,
+        )
+
+        return [with_username, with_username, with_email]

arkitekt_next/bloks/arkitekt.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Renderer, Panel
+
+
+class AdminCredentials(BaseModel):
+    password: str
+    username: str
+    email: str
+
+
+@blok("live.arkitekt")
+class ArkitektBlok:
+    def __init__(self) -> None:
+        pass
+
+    def get_dependencies(self):
+        return [
+            "live.arkitekt.lok",
+            "live.arkitekt.mikro",
+            "live.arkitekt.kabinet",
+            "live.arkitekt.gateway",
+            "io.livekit.livekit",
+        ]
+
+    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 init(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, cwd):
+        pass
+
+    def retrieve(self):
+        return AdminCredentials(
+            password=self.password,
+            username=self.username,
+            email=self.email,
+        )
+
+    def get_options(self):
+        return []

arkitekt_next/bloks/fluss.py

@@ -0,0 +1,138 @@
+import secrets
+from blok import blok, InitContext, ExecutionContext, CLIOption
+from blok.tree import YamlFile, Repo
+
+
+DEFAULT_ARKITEKT_URL = "http://localhost:8000"
+
+
+@blok("live.arkitekt.kabinet")
+class FlussBlok:
+    def __init__(self) -> None:
+        self.host = "fluss"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/jhnnsrs/fluss-server-next"
+        self.scopes = {"read_image": "Read image from the database"}
+        self.mount_repo = True
+        self.build_repo = True
+        self.secret_key = secrets.token_hex(16)
+        self.ensured_repos = []
+
+    def get_dependencies(self):
+        return [
+            "live.arkitekt.gateway",
+            "live.arkitekt.postgres",
+            "live.arkitekt.lok",
+            "live.arkitekt.admin",
+            "live.arkitekt.redis",
+            "live.arkitekt.s3",
+        ]
+
+    def init(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.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.fluss",
+                "fakts.builder=arkitekt.fluss",
+            ],
+            "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", "fluss.yaml", configuration)
+
+        context.docker_compose.set_nested("services", self.host, db_service)
+
+    def get_options(self):
+        with_repo = CLIOption(
+            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 = CLIOption(
+            subcommand="command",
+            help="Which command should be run when starting the service",
+            default=self.command,
+        )
+        mount_repo = CLIOption(
+            subcommand="mount_repo",
+            help="Should we mount the repo into the container?",
+            is_flag=True,
+            default=True,
+        )
+        build_repo = CLIOption(
+            subcommand="build_repo",
+            help="Should we build the container from the repo?",
+            is_flag=True,
+            default=True,
+        )
+        with_host = CLIOption(
+            subcommand="host",
+            help="How should the service be named inside the docker-compose file?",
+            default=self.host,
+        )
+        with_secret_key = CLIOption(
+            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/bloks/gateway.py

@@ -0,0 +1,153 @@
+from blok import blok, InitContext, ExecutionContext, CLIOption
+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.http_port = 80
+        self.https_port = 443
+
+    def get_identifier(self):
+        return "live.arkitekt.gateway"
+
+    def get_dependencies(self):
+        return []
+
+    def init(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}
+}}
+                """
+
+        caddyfile += """
+https:// {
+    tls /certs/caddy.crt /certs/caddy.key
+
+    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} {{
+        uri strip_prefix /{path_name}
+        reverse_proxy {exposed_host.host}:{exposed_host.port}
+    }}
+                """
+            else:
+                caddyfile += f"""
+    @{path_name} path /{path_name}{{
+        reverse_proxy {exposed_host.host}:{exposed_host.port}
+    }}
+                """
+
+        caddyfile += """
+}
+        """
+
+        context.file_tree.set_nested("config", "Caddyfile", caddyfile)
+
+        caddy_depends_on = []
+        if self.with_certer:
+            caddy_depends_on.append("certer")
+
+        caddy_container = {
+            "image": "caddy:latest",
+            "volumes": ["./config/Caddyfile:/etc/caddy/Caddyfile"],
+            "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)
+
+        if self.with_certer:
+            context.file_tree.set_nested("certs", {})
+            caddy_container = {
+                "image": "jhnnsrs/certer:latest",
+                "volumes": ["./certs:/certs"],
+                "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
+                "depends_on": caddy_depends_on,
+            }
+
+    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 = CLIOption(
+            subcommand="public_url",
+            help="Which public urls to use",
+            type=str,
+            multiple=True,
+            default=DEFAULT_PUBLIC_URLS,
+            show_default=True,
+        )
+        with_public_services = CLIOption(
+            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/bloks/kabinet.py

@@ -0,0 +1,143 @@
+from typing import Dict, Any
+import secrets
+
+from blok import blok, InitContext, ExecutionContext
+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 = True
+        self.build_repo = True
+        self.secret_key = secrets.token_hex(16)
+        self.ensured_repos = []
+
+    def get_dependencies(self):
+        return [
+            "live.arkitekt.gateway",
+            "live.arkitekt.postgres",
+            "live.arkitekt.lok",
+            "live.arkitekt.admin",
+            "live.arkitekt.redis",
+            "live.arkitekt.s3",
+        ]
+
+    def init(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.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)
+
+    def get_options(self):
+        with_repo = CLIOptions(
+            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(
+            subcommand="command",
+            help="Which command should be run when starting the service",
+            default=self.command,
+        )
+        mount_repo = CLIOptions(
+            subcommand="mount_repo",
+            help="Should we mount the repo into the container?",
+            is_flag=True,
+            default=True,
+        )
+        build_repo = CLIOptions(
+            subcommand="build_repo",
+            help="Should we build the container from the repo?",
+            is_flag=True,
+            default=True,
+        )
+        with_host = CLIOptions(
+            subcommand="host",
+            help="How should the service be named inside the docker-compose file?",
+            default=self.host,
+        )
+        with_secret_key = CLIOptions(
+            subcommand="secret_key",
+            help="The secret key to use for the django service",
+            default=self.secret_key,
+        )
+        with_repos = CLIOptions(
+            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,
+        ]

arkitekt_next/bloks/livekit.py

@@ -0,0 +1,71 @@
+from typing import Dict, Any
+import secrets
+
+from blok import blok, InitContext, ExecutionContext, CLIOption
+from blok.tree import YamlFile, Repo
+
+
+@blok("io.livekit.livekit")
+class LiveKitBlok:
+    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]
+
+    def get_dependencies(self):
+        return [
+            "live.arkitekt.gateway",
+        ]
+
+    def init(self, init: InitContext):
+        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)
+
+        self.initialized = True
+
+    def build(self, context: ExecutionContext):
+        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 = CLIOption(
+            subcommand="command",
+            help="The fakts url for connection",
+            default=self.command,
+        )
+        with_host = CLIOption(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+
+        return [
+            with_host,
+            with_command,
+        ]
+
+    def __str__(self) -> str:
+        return (
+            f"LiveKitBlok(host={self.host}, command={self.command}, image={self.image})"
+        )