arkitekt-next 0.16.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

arkitekt_next/bloks/base.py

@@ -1,217 +0,0 @@
-from arkitekt_next.bloks.services.channel import ChannelService
-from blok import blok, InitContext, Option
-from blok.tree import YamlFile, Repo
-from typing import Any, Optional, Protocol
-from blok.utils import check_protocol_compliance
-from dataclasses import asdict
-from arkitekt_next.bloks.services import (
-    GatewayService,
-    DBService,
-    RedisService,
-    S3Service,
-    ConfigService,
-    MountService,
-    AdminService,
-    SecretService,
-    LokService,
-)
-
-from blok.bloks.services.dns import DnsService
-
-
-class DefaultService(Protocol):
-    dev: bool
-    repo: str
-    command: str
-    service_name: str
-    host: str
-    buckets: list[str]
-    scopes: dict[str, str]
-    secret_key: str
-    mount_repo: bool
-    build_repo: bool
-
-    def get_blok_meta(self) -> str: ...
-
-    def get_builder(self) -> str: ...
-
-
-def create_default_service_dependencies():
-    return [
-        DnsService,
-        GatewayService,
-        DBService,
-        RedisService,
-        S3Service,
-        ConfigService,
-        MountService,
-        AdminService,
-        SecretService,
-        LokService,
-    ]
-
-
-class BaseArkitektService:
-    def get_additional_config(self):
-        return {}
-
-    def preflight(
-        self,
-        init: InitContext,
-        lok: LokService,
-        db: DBService,
-        redis: RedisService,
-        s3: S3Service,
-        config: ConfigService,
-        mount: MountService,
-        admin: AdminService,
-        secret: SecretService,
-        gateway: GatewayService,
-        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,
-    ):
-        deps = init.dependencies
-
-        lok.register_scopes(self.scopes)
-
-        path_name = self.host
-
-        postgress_access = db.register_db(self.host)
-        redis_access = redis.register()
-        lok_access = lok.retrieve_credentials()
-        admin_access = admin.retrieve()
-        minio_access = s3.create_buckets(self.buckets)
-
-        self.service_identifier = self.get_blok_meta().service_identifier
-
-        gateway_path = gateway.expose_service(
-            path_name, 80, self.host, strip_prefix=False
-        )
-
-        lok_labels = lok.register_service_on_subpath(
-            self.service_identifier, gateway_path, "ht"
-        )
-
-        django_secret = secret.retrieve_secret()
-
-        csrf_trusted_origins = []
-
-        configuration = YamlFile(
-            **{
-                "db": asdict(postgress_access),
-                "django": {
-                    "admin": asdict(admin_access),
-                    "debug": True,
-                    "hosts": ["*"],
-                    "secret_key": django_secret,
-                },
-                "redis": asdict(redis_access),
-                "lok": asdict(lok_access),
-                "s3": asdict(minio_access),
-                "scopes": self.scopes,
-                "force_script_name": path_name,
-                "csrf_trusted_origins": csrf_trusted_origins,
-                **self.get_additional_config(),
-            }
-        )
-
-        config_mount = init.get_service(ConfigService).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 = {
-            "volumes": [f"{config_mount}:/workspace/config.yaml"],
-            "depends_on": depends_on,
-        }
-
-        if mount_repo or dev:
-            mount = init.get_service(MountService).register_mount(self.host, Repo(repo))
-            service["volumes"].extend([f"{mount}:/workspace"])
-
-        if build_repo or dev:
-            mount = init.get_service(MountService).register_mount(self.host, Repo(repo))
-            service["build"] = mount
-        else:
-            service["image"] = image
-
-        service["command"] = command
-
-        self.service = service
-
-    def get_additional_options(self):
-        return []
-
-    def get_options(self):
-        return [
-            Option(
-                subcommand="dev",
-                help="Shoud we run the service in development mode (includes withrepo, mountrepo)?",
-                default=self.dev,
-            ),
-            Option(
-                subcommand="host",
-                help="The name we should use for the host?",
-                default=self.host,
-            ),
-            Option(
-                subcommand="disable",
-                help="Shoud we disable the service?",
-                default=False,
-            ),
-            Option(
-                subcommand="repo",
-                help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
-                default=self.repo,
-            ),
-            Option(
-                subcommand="command",
-                help="Which command should we use when building the service?",
-                default=self.command,
-            ),
-            Option(
-                subcommand="mount_repo",
-                help="Should we mount the repo into the container?",
-                type=bool,
-                default=self.mount_repo,
-            ),
-            Option(
-                subcommand="build_repo",
-                help="Should we build the container from the repo?",
-                type=bool,
-                default=self.build_repo,
-            ),
-            Option(
-                subcommand="host",
-                help="How should the service be named inside the docker-compose file?",
-                default=self.host,
-            ),
-            Option(
-                subcommand="secret_key",
-                help="The secret key to use for the django service",
-                default=self.secret_key,
-            ),
-            Option(
-                subcommand="image",
-                help="The image to use for the service",
-                default=self.image,
-            ),
-            *self.get_additional_options(),
-        ]

arkitekt_next/bloks/channel.py

@@ -1,27 +0,0 @@
-from pydantic import BaseModel
-from typing import Dict, Any
-from blok import blok, InitContext, Option
-from arkitekt_next.bloks.services.channel import ChannelService
-
-
-@blok(ChannelService, description="The current channel of the application")
-class ChannelBlok:
-    def __init__(self) -> None:
-        self.name = "default"
-
-    def preflight(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-    def retrieve(self):
-        return self.name
-
-    def get_options(self):
-        with_name = Option(
-            subcommand="name",
-            help="Which channel name to use",
-            default=self.name,
-            show_default=True,
-        )
-
-        return [with_name]

arkitekt_next/bloks/config.py

@@ -1,43 +0,0 @@
-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/bloks/elektro.py

@@ -1,42 +0,0 @@
-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.base import BaseArkitektService
-
-
-class AccessCredentials(BaseModel):
-    password: str
-    username: str
-    host: str
-    port: str
-    db_name: str
-
-
-@blok("live.arkitekt.elektro", description="Mikro is the bio-image database for arkitekt")
-class ElektroBlok(BaseArkitektService):
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "elektro"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/jhnnsrs/elektro-server"
-        self.scopes = {
-            "mikro_read": "Read image from the database",
-            "mikro_write": "Write image to the database",
-        }
-        self.image = "jhnnsrs/elektro:nightly"
-        self.mount_repo = False
-        self.build_repo = False
-        self.buckets = ["media", "zarr", "parquet"]
-        self.secret_key = secrets.token_hex(16)
-
-    def get_builder(self):
-        return "arkitekt.generic"
-
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)

arkitekt_next/bloks/fluss.py

@@ -1,33 +0,0 @@
-import secrets
-
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from arkitekt_next.bloks.base import BaseArkitektService
-from typing import List
-
-
-DEFAULT_ARKITEKT_URL = "http://localhost:8000"
-
-
-@blok(
-    "live.arkitekt.fluss", description="A service for managing workflows and their data"
-)
-class FlussBlok(BaseArkitektService):
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "fluss"
-        self.command = "bash run-debug.sh"
-        self.image = "jhnnsrs/fluss_next:nightly"
-        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: List[str] = []
-
-    def get_builder(self):
-        return "arkitekt.generic"
-
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)

arkitekt_next/bloks/gateway.py

@@ -1,224 +0,0 @@
-from arkitekt_next.bloks.services.certer import CerterService
-from arkitekt_next.bloks.services.name import NameService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from pydantic import BaseModel
-from typing import Dict, Any, Optional
-
-from blok import blok, InitContext
-from blok.bloks.services.dns import DnsService
-
-DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
-DEFAULT_PUBLIC_HOSTS = ["localhost"]
-
-
-class ExposedHost(BaseModel):
-    host: str
-    port: int
-    stip_prefix: bool = True
-
-
-class ExpostedToHost(BaseModel):
-    port: int
-    host: str
-    to: str
-    tls: bool = False
-
-
-class ExposedPort(BaseModel):
-    port: int
-    host: str
-    tls: bool = False
-    to: int
-
-
-@blok(
-    "live.arkitekt.gateway",
-    description="A gateway for exposing services on the host",
-)
-class CaddyBlok:
-    def __init__(self) -> None:
-        self.exposed_hosts = {}
-        self.exposed_to_hosts = {}
-        self.http_expose_default = None
-        self.exposed_ports = {}
-        self.with_certer = False
-        self.http_port = 80
-        self.https_port = 443
-        self.public_ips = DEFAULT_PUBLIC_URLS
-        self.public_hosts = DEFAULT_PUBLIC_HOSTS
-        self.cert_mount = None
-        self.depends_on = []
-
-    def get_internal_host(self):
-        return "caddy"
-
-    def get_https_port(self):
-        return 443
-
-    def get_http_port(self):
-        return 80
-
-    def retrieve_gateway_network(self):
-        return self.gateway_network
-
-    def preflight(
-        self,
-        init: InitContext,
-        name: NameService,
-    ):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        self.gateway_network = name.retrieve_name().replace("-", "_")
-
-    def build(
-        self,
-        context: ExecutionContext,
-    ):
-        caddyfile = """
-{
-    auto_https off
-}
-        """
-
-        for key, port in self.exposed_ports.items():
-            if port.tls:
-                caddyfile += f"""
-:{port.port} {{
-    reverse_proxy {port.host}:{port.to}
-}}
-                """
-            else:
-                caddyfile += f"""
-:{port.port} {{
-    reverse_proxy {port.host}:{port.to}
-}}
-                """
-
-        for protocol in ["http"]:
-            caddyfile += f"""
-{protocol}:// {{
-"""
-            caddyfile += (
-                """
-    """
-                if protocol == "https" and self.cert_mount
-                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}
-    }}
-                """
-
-            for path_name, exposed_to_host in self.exposed_to_hosts.items():
-                caddyfile += f"""
-    @{path_name} path /{path_name}*
-    handle @{path_name} {{
-        rewrite * /{exposed_to_host.to}{{uri}}
-        reverse_proxy {exposed_to_host.host}:{exposed_to_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 = self.depends_on
-
-        exposed_ports_strings = [
-            f"{port.port}:{port.port}" for port in self.exposed_ports.values()
-        ]
-
-        volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
-
-        caddy_container = {
-            "image": "caddy:latest",
-            "ports": [
-                f"{self.http_port}:80",
-            ]
-            + exposed_ports_strings,
-            "volumes": volumes,
-            "networks": [self.gateway_network, "default"],
-        }
-
-        context.docker_compose.set_nested("services", "caddy", caddy_container)
-
-        context.docker_compose.set_nested(
-            "networks",
-            self.gateway_network,
-            {"driver": "bridge", "name": self.gateway_network},
-        )
-
-    def expose_service(
-        self, path_name: str, port: int, host: str, strip_prefix: bool = False
-    ):
-        self.exposed_hosts[path_name] = ExposedHost(
-            host=host, port=port, stip_prefix=strip_prefix
-        )
-        return path_name
-
-    def expose_mapped(self, path_name: str, port: int, host: str, to: str):
-        self.exposed_to_hosts[path_name] = ExpostedToHost(host=host, port=port, to=to)
-
-    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, to=port)
-
-    def expose_port_to(self, port: int, host: str, to_port: int, tls: bool = False):
-        self.exposed_ports[port] = ExposedPort(
-            port=port, host=host, tls=tls, to=to_port
-        )
-
-    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/bloks/internal_docker.py

@@ -1,90 +0,0 @@
-from typing import Dict, Any
-import secrets
-
-from arkitekt_next.bloks.lok import LokBlok
-from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.socket import DockerSocketBlok
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.bloks.services.dns import DnsService
-from blok.tree import YamlFile, Repo
-
-
-@blok(
-    "live.arkitekt.internal_engine",
-    description="An Arkitekt plugin engine running inside a docker container",
-)
-class InternalDockerBlok:
-    def __init__(self) -> None:
-        self.host = "deployer"
-
-        self.image = "jhnnsrs/deployer:nightly"
-        self.instance_id = "INTERNAL_DOCKER"
-
-    def preflight(
-        self,
-        init: InitContext,
-        gateway: GatewayService,
-        lok: LokBlok,
-        socket: DockerSocketBlok,
-    ):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        deps = init.dependencies
-
-        self._socket = socket.register_socket(self.host)
-        self.gateway_host = gateway.get_internal_host()
-        self.gateway_port = gateway.get_http_port()
-
-        self.token = lok.retrieve_token()
-
-        self.gateway_network = gateway.retrieve_gateway_network()
-
-        self.command = f"arkitekt-next run prod --redeem-token={self.token} --url http://{self.gateway_host}:{self.gateway_port}"
-
-        self.initialized = True
-
-    def build(self, context: ExecutionContext):
-        db_service = {
-            "image": self.image,
-            "command": self.command,
-            "volumes": [f"{self._socket}:/var/run/docker.sock"],
-            "environment": {
-                "INSTANCE_ID": self.instance_id,
-                "ARKITEKT_GATEWAY": f"http://{self.gateway_host}:{self.gateway_port}",
-                "ARKITEKT_NETWORK": self.gateway_network,
-            },
-            "deploy": {
-                "restart_policy": {
-                    "condition": "on-failure",
-                    "delay": "10s",
-                    "max_attempts": 10,
-                    "window": "300s",
-                },
-            },
-        }
-
-        context.docker_compose.set_nested("services", self.host, db_service)
-
-    def get_options(self):
-        with_host = Option(
-            subcommand="host",
-            help="The host of this service",
-            default=self.host,
-        )
-        with_skip = Option(
-            subcommand="skip",
-            help="Should we skip creating this service?",
-            default=False,
-            type=bool,
-        )
-
-        return [
-            with_host,
-            with_skip,
-        ]
-
-    def __str__(self) -> str:
-        return (
-            f"InterDocker(host={self.host}, command={self.command}, image={self.image})"
-        )