arkitekt-next 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

arkitekt_next/bloks/lovekit.py

@@ -1,199 +0,0 @@
-from dataclasses import asdict
-from typing import Dict, Any
-import secrets
-
-
-from arkitekt_next.bloks.services.admin import AdminService
-from arkitekt_next.bloks.services.channel import ChannelService
-from arkitekt_next.bloks.services.config import ConfigService
-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 LokService
-from arkitekt_next.bloks.services.mount import MountService
-from arkitekt_next.bloks.services.ollama import OllamaService
-from arkitekt_next.bloks.services.redis import RedisService
-from arkitekt_next.bloks.services.s3 import S3Service
-from arkitekt_next.bloks.services.secret import SecretService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.bloks.services.dns import DnsService
-from blok.tree import Repo, YamlFile
-from arkitekt_next.bloks.base import BaseArkitektService
-
-
-@blok("live.arkitekt.lovekit", description="Stream live video and audio with Arkitekt")
-class LovekitBlok:
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "lovekit"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/arkitektio/lovekit-server"
-        self.scopes = {
-            "alpaka_pull": "Pull new Models",
-            "alpaka_chat": "Add repositories to the database",
-        }
-        self.mount_repo = False
-        self.build_repo = False
-        self.buckets = ["media"]
-        self.secret_key = secrets.token_hex(16)
-        self.image = "jhnnsrs/lovekit:nightly"
-
-    def preflight(
-        self,
-        lok: LokService,
-        db: DBService,
-        redis: RedisService,
-        s3: S3Service,
-        config: ConfigService,
-        livekit: LivekitService,
-        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,
-    ):
-        lok.register_scopes(self.scopes)
-
-        path_name = self.host
-
-        gateway.expose(path_name, 80, 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)
-        lok_labels = lok.retrieve_labels("live.arkitekt.alpaka", self.get_builder())
-
-        livekit_access = livekit.get_access()
-
-        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,
-                "livekit": {
-                    "host": livekit_access.host,
-                    "port": livekit_access.port,
-                    "api_key": livekit_access.api_key,
-                    "api_secret": livekit_access.api_secret,
-                },
-            }
-        )
-
-        config_mount = 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 mount_repo or dev:
-            mount = mount.register_mount(self.host, Repo(repo))
-            service["volumes"].extend([f"{mount}:/workspace"])
-
-        if build_repo or dev:
-            mount = mount.register_mount(self.host, Repo(repo))
-            service["build"] = mount
-        else:
-            service["image"] = image
-
-        service["command"] = command
-
-        self.service = service
-
-    def get_builder(self):
-        return "arkitekt.generic"
-
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)
-
-    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,
-            ),
-        ]

arkitekt_next/bloks/mikro.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.mikro", description="Mikro is the bio-image database for arkitekt")
-class MikroBlok(BaseArkitektService):
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "mikro"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/arkitektio/mikro-server-next"
-        self.scopes = {
-            "mikro_read": "Read image from the database",
-            "mikro_write": "Write image to the database",
-        }
-        self.image = "jhnnsrs/mikro_next: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/minio.py

@@ -1,176 +0,0 @@
-import click
-
-from arkitekt_next.bloks.services.config import ConfigService
-from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.services.name import NameService
-from arkitekt_next.bloks.services.secret import SecretService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from pydantic import BaseModel
-from typing import Dict, Optional
-import secrets
-from blok import blok, InitContext
-from arkitekt_next.bloks.services.s3 import S3Credentials, S3Service
-
-
-class BucketMapParamType(click.ParamType):
-    name = "redeem_token"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            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 = BucketMapParamType()
-
-
-@blok(
-    S3Service,
-    description="Minio is an easy use self-hosted object storage service",
-)
-class MinioBlok:
-    db_name: str
-
-    def __init__(self) -> None:
-        self.users = []
-        self.username = secrets.token_hex(16)
-        self.password = secrets.token_hex(16)
-        self.protocol = "http"
-        self.host = "minio"
-        self.port = 9000
-        self.skip = False
-        self.scopes = {}
-        self.init_image = "jhnnsrs/init:nightly"
-        self.minio_image = "minio/minio:RELEASE.2025-02-18T16-25-55Z"
-        self.buckets = []
-        self.registered_clients = []
-        self.preformed_bucket_names = [secrets.token_hex(16) for i in range(100)]
-        self.preformed_access_keys = [secrets.token_hex(16) for i in range(100)]
-        self.preformed_secret_keys = [secrets.token_hex(16) for i in range(100)]
-
-    def create_buckets(self, buckets: list[str]) -> S3Credentials:
-        new_access_key = self.secret_service.retrieve_secret()
-        new_secret_key = self.secret_service.retrieve_secret()
-
-        bucket_map = {}
-
-        for bucket in buckets:
-            bucket_name = self.name_service.retrieve_name()
-            bucket_map[bucket] = bucket_name
-            self.gateway_service.expose(bucket_name, 9000, self.host)
-
-        self.buckets.extend(bucket_map.values())
-
-        creds = S3Credentials(
-            name=self.name_service.retrieve_name(),
-            access_key=new_access_key,
-            buckets=bucket_map,
-            host=self.host,
-            port=self.port,
-            secret_key=new_secret_key,
-            protocol=self.protocol,
-            dependency=self.host if not self.skip else None,
-        )
-
-        self.registered_clients.append(creds)
-
-        return creds
-
-    def preflight(
-        self,
-        init: InitContext,
-        secret: SecretService,
-        name: NameService,
-        gateway: GatewayService,
-        config: ConfigService,
-    ):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        self.secret_service = secret
-        self.name_service = name
-        self.gateway_service = gateway
-
-        self.config_path = config.get_path(self.host + ".yaml")
-
-    def build(self, context: ExecutionContext):
-        minio_service_init = {
-            "depends_on": {
-                "minio": {
-                    "condition": "service_started",
-                },
-            },
-            "environment": {
-                "MINIO_ROOT_PASSWORD": self.password,
-                "MINIO_ROOT_USER": self.username,
-                "MINIO_HOST": f"http://{self.host}:9000",
-            },
-            "image": self.init_image,
-            "volumes": [f"{self.config_path}:/workspace/config.yaml"],
-        }
-
-        minio_service = {
-            "command": ["server", "/data"],
-            "environment": {
-                "MINIO_ROOT_PASSWORD": self.password,
-                "MINIO_ROOT_USER": self.username,
-            },
-            "image": self.minio_image,
-            "volumes": ["./data:/data"],
-            "labels": ["fakts.service=live.arkitekt.s3", "fakts.builder=arkitekt.s3"],
-        }
-
-        context.file_tree.set_nested("data", {})
-
-        context.docker_compose.set_nested("services", self.host, minio_service)
-        context.docker_compose.set_nested(
-            "services", f"{self.host}_init", minio_service_init
-        )
-
-        context.file_tree.set_nested(
-            *self.config_path.split("/"),
-            YamlFile(
-                buckets=[{"name": i} for i in self.buckets],
-                users=[
-                    {
-                        "access_key": i.access_key,
-                        "secret_key": i.secret_key,
-                        "name": i.name,
-                        "policies": ["readwrite"],
-                    }
-                    for i in self.registered_clients
-                ],
-            ),
-        )
-
-    def get_options(self):
-        with_host = Option(
-            subcommand="host",
-            help="The fakts_next url for connection",
-            default=self.host,
-        )
-        with_username = Option(
-            subcommand="username",
-            help="The fakts_next url for connection",
-            default=self.username,
-        )
-        with_password = Option(
-            subcommand="password",
-            help="The fakts_next url for connection",
-            default=self.password,
-        )
-
-        return [
-            with_host,
-            with_password,
-            with_username,
-        ]

arkitekt_next/bloks/mount.py

@@ -1,34 +0,0 @@
-from pydantic import BaseModel
-from typing import Dict, Any
-from arkitekt_next.bloks.services.mount import MountService
-from blok import blok, InitContext, Option, ExecutionContext
-
-from blok.tree import YamlFile
-
-
-@blok(MountService, description="Mounting files into the file tree for use")
-class MountBlok:
-    def __init__(self) -> None:
-        self.mount_path = "mounts"
-        self.registered_configs = {}
-
-    def preflight(self, mount_path: str):
-        self.mount_path = mount_path
-
-    def build(self, ex: ExecutionContext):
-        for name, file in self.registered_configs.items():
-            ex.file_tree.set_nested(*f"{self.mount_path}/{name}".split("/"), file)
-
-    def register_mount(self, name: str, file: YamlFile) -> str:
-        self.registered_configs[name] = file
-        return f"./{self.mount_path}/" + name
-
-    def get_options(self):
-        config_path = Option(
-            subcommand="mount_path",
-            help="Which path to use for configs",
-            default=self.mount_path,
-            show_default=True,
-        )
-
-        return [config_path]

arkitekt_next/bloks/namegen.py

@@ -1,34 +0,0 @@
-from pydantic import BaseModel
-from typing import Dict, Any
-from arkitekt_next.bloks.services.name import NameService
-from blok import blok, InitContext, Option, ExecutionContext
-from blok.tree import YamlFile
-from arkitekt_next.bloks.services.secret import SecretService
-import secrets
-import namegenerator
-
-
-@blok(NameService, description="Preformed names that will not change")
-class PreformedNamesBlok:
-    def __init__(self) -> None:
-        self.preformed_names = [namegenerator.gen() for _ in range(100)]
-        self.used_names = []
-
-    def preflight(self, init: InitContext, preformed_names: list[str]):
-        self.preformed_names = list(preformed_names)
-        self.used_names = []
-
-    def retrieve_name(self) -> str:
-        name = self.preformed_names.pop()
-        self.used_names.append(name)
-        return name
-
-    def get_options(self):
-        config_path = Option(
-            subcommand="preformed_names",
-            help="A list of preformed names",
-            default=self.preformed_names,
-            multiple=True,
-        )
-
-        return [config_path]

arkitekt_next/bloks/ollama.py

@@ -1,94 +0,0 @@
-from typing import Dict, Any
-import secrets
-
-from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.services.ollama import OllamaService, OllamaAccess
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-
-
-@blok(OllamaService, description="a self-hosted Ollama LLM server")
-class OllamaBlok:
-    def __init__(self) -> None:
-        self.host = "ollama"
-        self.image = "ollama/ollama:latest"
-        self.port = 11434
-        self.skip = False
-        self.gpu = bool
-
-    def get_access(self) -> OllamaAccess:
-        """Get the credentials for the Ollama service."""
-        return OllamaAccess(
-            api_key="",
-            api_secret="",
-            api_url=f"http://{self.host}:{self.port}",
-            dependency=self.host,
-        )
-
-    def preflight(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        if self.skip:
-            return
-
-        self.initialized = True
-
-    def build(self, context: ExecutionContext):
-        if self.skip:
-            return
-        db_service = {
-            "labels": [
-                "fakts.service=io.ollama.ollama",
-                "fakts.builder=ollama.ollama",
-            ],
-            "image": self.image,
-            "environment": {
-                "OLLAMA_KEEP_ALIVE": "24h",
-            },
-        }
-
-        if self.gpu:
-            db_service["deploy"] = {
-                "resources": {
-                    "reservations": {
-                        "devices": [
-                            {
-                                "driver": "nvidia",
-                                "count": 1,
-                                "capabilities": ["gpu"],
-                            }
-                        ]
-                    }
-                }
-            }
-
-        context.docker_compose.set_nested("services", self.host, db_service)
-
-    def get_options(self):
-        with_host = Option(
-            subcommand="host",
-            help="The fakts url for connection",
-            default=self.host,
-        )
-        with_skip = Option(
-            subcommand="skip",
-            help="The fakts_next url for connection",
-            default=False,
-            type=bool,
-        )
-        with_gpu = Option(
-            subcommand="gpu",
-            help="Whether to use a gpu",
-            default=False,
-            type=self.gpu,
-        )
-
-        return [
-            with_host,
-            with_skip,
-            with_gpu,
-        ]
-
-    def __str__(self) -> str:
-        return f"Ollama(host={self.host}, command={self.command}, image={self.image})"

arkitekt_next/bloks/orkestrator.py

@@ -1,122 +0,0 @@
-from typing import Dict, Any
-import secrets
-from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.services.mount import MountService
-from blok import blok, InitContext, ExecutionContext, Option, Command
-from blok.bloks.services.dns import DnsService
-from blok.bloks.services.vscode import VsCodeService
-from blok.tree import Repo, YamlFile
-
-
-@blok(
-    "live.arkitekt.orkestrator",
-    description="Orkestrator in its web-based UI",
-)
-class OrkestratorBlok:
-    def __init__(self) -> None:
-        self.dev = False
-        self.disable = False
-        self.host = "orkestrator"
-        self.path_name = "orkestrator"
-        self.repo = "https://github.com/arkitektio/orkestrator-next"
-        self.build_command = ["yarn"]
-        self.up_command = ["yarn", "start"]
-
-    def preflight(
-        self,
-        init: InitContext,
-        gateway: GatewayService,
-        mount: MountService,
-        vscode: VsCodeService | None = None,
-    ):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        if self.disable:
-            return
-
-        if not self.dev:
-            gateway.expose(self.path_name, 80, self.host)
-
-            self.service = {
-                "image": "jhnnsrs/orkestrator_next:nightly",
-                "environment": {
-                    "PATH_NAME": self.path_name,
-                },
-            }
-
-            return
-
-        else:
-
-            self.mount = mount.register_mount("orkestrator", Repo(self.repo))
-
-            if vscode is not None:
-                vscode.register_task(
-                    "Run Orkestrator",
-                    "shell",
-                    "yarn",
-                    ["start"],
-                    {"cwd": f"{self.mount}"},
-                )
-                vscode.register_task(
-                    "Build Orkestrator",
-                    "shell",
-                    "yarn",
-                    [],
-                    {"cwd": f"{self.mount}"},
-                )
-
-            self.initialized = True
-
-    def build(self, context: ExecutionContext):
-        if self.disable:
-            return
-
-        if self.dev:
-
-            context.install_commands.set_nested(
-                "orkestrator", Command(self.build_command, cwd=self.mount)
-            )
-            context.up_commands.set_nested(
-                "orkestrator", Command(self.up_command, cwd=self.mount)
-            )
-            return
-
-        context.docker_compose.set_nested("services", self.host, self.service)
-        pass
-
-    def get_options(self):
-        with_repos = Option(
-            subcommand="repo",
-            help="The default repo to use for the orkestrator",
-            default=self.repo,
-        )
-        with_disable = Option(
-            subcommand="disable",
-            help="Should we disable the orkestrator service?",
-            default=self.disable,
-        )
-        with_dev = Option(
-            subcommand="dev",
-            help="Should we mount orkestrator as dev?",
-            default=self.dev,
-        )
-        with_path_name = Option(
-            subcommand="path_name",
-            help="The path name for the orkestrator service",
-            default=self.path_name,
-        )
-        with_host = Option(
-            subcommand="host",
-            help="The host for the orkestrator service",
-            default=self.host,
-        )
-
-        return [
-            with_dev,
-            with_repos,
-            with_path_name,
-            with_disable,
-            with_host,
-        ]