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

arkitekt_next/bloks/minio.py

@@ -0,0 +1,180 @@
+import click
+
+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)
+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:paper"
+        self.minio_image = "minio/minio:RELEASE.2023-02-10T18-48-39Z"
+        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 get_identifier(self):
+        return "live.arkitekt.s3"
+
+    def get_dependencies(self):
+        return ["live.arkitekt.config", "live.arkitekt.gateway"]
+
+    def create_buckets(self, buckets: list[str]) -> S3Credentials:
+        new_access_key = self.preformed_access_keys.pop()
+        new_secret_key = self.preformed_secret_keys.pop()
+
+        bucket_map = {}
+
+        for bucket in buckets:
+            bucket_map[bucket] = self.preformed_bucket_names.pop()
+
+        self.buckets.extend(bucket_map.values())
+
+        creds = S3Credentials(
+            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):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+        self.preformed_bucket_names = list(
+            init.kwargs.get("preformed_bucket_names", [])
+        )
+        self.preformed_access_keys = list(init.kwargs.get("preformed_access_keys", []))
+        self.preformed_secret_keys = list(init.kwargs.get("preformed_secret_keys", []))
+
+        init.dependencies["live.arkitekt.gateway"].expose_default(9000, self.host)
+
+        self.config_path = init.dependencies["live.arkitekt.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"{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": list(self.buckets)})
+        )
+
+    def get_options(self):
+        with_host = Option(
+            subcommand="host",
+            help="The fakts url for connection",
+            default=self.host,
+        )
+        with_username = Option(
+            subcommand="username",
+            help="The fakts url for connection",
+            default=self.username,
+        )
+        with_password = Option(
+            subcommand="password",
+            help="The fakts url for connection",
+            default=self.password,
+        )
+        with_preformed_bucket_names = Option(
+            subcommand="preformed_bucket_names",
+            help="The fakts url for connection",
+            multiple=True,
+            default=self.preformed_bucket_names,
+        )
+        with_preformed_acces_key = Option(
+            subcommand="preformed_access_keys",
+            help="The fakts url for connection",
+            multiple=True,
+            default=self.preformed_access_keys,
+        )
+        with_preformed_secret_keys = Option(
+            subcommand="preformed_secret_keys",
+            help="The fakts url for connection",
+            multiple=True,
+            default=self.preformed_secret_keys,
+        )
+
+        return [
+            with_host,
+            with_password,
+            with_username,
+            with_preformed_bucket_names,
+            with_preformed_acces_key,
+            with_preformed_secret_keys,
+        ]

arkitekt_next/bloks/mount.py

@@ -0,0 +1,35 @@
+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)
+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/postgres.py

@@ -0,0 +1,86 @@
+from typing import Optional
+
+from arkitekt_next.bloks.services.db import DBService, DBCredentials
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from pydantic import BaseModel
+import pydantic
+import namegenerator
+import secrets
+from blok import blok, InitContext
+
+
+
+
+@blok(DBService)
+class PostgresBlok(BaseModel):
+    host: str = "db"
+    port: int = 5432
+    skip: bool = False
+    password: str = pydantic.Field(default_factory=lambda: secrets.token_hex(16))
+    user: str = pydantic.Field(default_factory=lambda: namegenerator.gen(separator=""))
+    image: str = "jhnnsrs/daten:next"
+
+    registered_dbs: dict[str, DBCredentials] = {}
+
+    def get_dependencies(self):
+        return []
+
+    def get_identifier(self):
+        return "live.arkitekt.postgres"
+
+    def register_db(self, db_name: str) -> DBCredentials:
+        if db_name in self.registered_dbs:
+            return self.registered_dbs[db_name]
+        else:
+            access_credentials = DBCredentials(
+                password=self.password,
+                username=self.user,
+                host=self.host,
+                port=self.port,
+                db_name=db_name,
+                dependency=self.host if not self.skip else None,
+            )
+            self.registered_dbs[db_name] = access_credentials
+            return access_credentials
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, context: ExecutionContext):
+        db_service = {
+            "environment": {
+                "POSTGRES_USER": self.user,
+                "POSTGRES_PASSWORD": self.password,
+                "POSTGRES_MULTIPLE_DATABASES": ",".join(self.registered_dbs.keys()),
+            },
+            "image": self.image,
+            "labels": ["fakts.service=live.arkitekt.postgres"],
+        }
+
+        context.docker_compose.set_nested(f"services", self.host, db_service)
+
+    def get_options(self):
+        with_postgres_password = Option(
+            subcommand="password",
+            help="The postgres password for connection",
+            default=self.password,
+        )
+        with_user_password = Option(
+            subcommand="user",
+            help="The postgress user_name",
+            default=self.user,
+        )
+        skip_build = Option(
+            subcommand="skip",
+            help="Should the service not be created? E.g when pointing outwards?",
+            default=self.skip,
+        )
+        with_image = Option(
+            subcommand="image",
+            help="The image to use for the service",
+            default=self.image,
+        )
+
+        return [with_postgres_password, skip_build, with_user_password, with_image]

arkitekt_next/bloks/redis.py

@@ -0,0 +1,77 @@
+import click
+
+from arkitekt_next.bloks.services.redis import RedisService, RedisConnection
+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
+
+
+
+@blok(RedisService)
+class RedisBlok:
+    def __init__(self) -> None:
+        self.host = "redis"
+        self.port = 6379
+        self.skip = False
+        self.image = "redis"
+
+    def get_identifier(self):
+        return "live.arkitekt.redis"
+
+    def get_dependencies(self):
+        return []
+
+    def register(self) -> RedisConnection:
+        return RedisConnection(
+            host=self.host,
+            port=self.port,
+            dependency=self.host if not self.skip else None,
+        )
+
+    def preflight(self, init: InitContext):
+        for key, value in init.kwargs.items():
+            setattr(self, key, value)
+
+    def build(self, context: ExecutionContext):
+        redis_service = {
+            "environment": {
+                "REDIS_HOST": self.host,
+                "REDIS_PORT": self.port,
+            },
+            "image": self.image,
+            "ports": [f"{self.port}:{self.port}"],
+        }
+
+        context.docker_compose.set_nested(f"services", self.host, redis_service)
+
+    def get_options(self):
+        with_port = Option(
+            subcommand="port",
+            help="Which port to use",
+            type=int,
+            default=self.port,
+            show_default=True,
+        )
+        with_host = Option(
+            subcommand="host",
+            help="Which public hosts to use",
+            type=str,
+            default=self.host,
+            show_default=True,
+        )
+        with_skip = Option(
+            subcommand="skip",
+            help="Skip docker creation (if using external redis?)",
+            is_flag=True,
+            default=self.skip,
+        )
+        with_image = Option(
+            subcommand="image",
+            help="The image to use for the service",
+            default=self.image,
+        )
+
+        return [with_port, with_host, with_skip, with_image]

arkitekt_next/bloks/rekuest.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.rekuest")
+class RekuestBlok:
+    def __init__(self) -> None:
+        self.host = "rekuest"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/jhnnsrs/rekuest-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 = []
+        self.image = "jhnnsrs/rekuest: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,
+        ]

arkitekt_next/bloks/services/admin.py

@@ -0,0 +1,22 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class AdminCredentials:
+    password: str
+    username: str
+    email: str
+
+
+@service("live.arkitekt.admin")
+class AdminService(Protocol):
+
+    def retrieve(self):
+        return AdminCredentials(
+            password=self.password,
+            username=self.username,
+            email=self.email,
+        )
+

arkitekt_next/bloks/services/config.py

@@ -0,0 +1,18 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option, ExecutionContext, service
+from blok.tree import YamlFile
+
+
+
+
+@service("live.arkitekt.config")
+class ConfigService(Protocol):
+
+    def register_config(self, name: str, file: YamlFile) -> str:
+        ...
+
+    def get_path(self, name: str) -> str:
+        ...
+        return f"./{self.config_path}/" + name
+
+   

arkitekt_next/bloks/services/db.py

@@ -0,0 +1,27 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from dataclasses import dataclass
+from typing import Dict, Any, Protocol, Optional
+
+from blok import blok, InitContext, service
+from dataclasses import dataclass
+
+@dataclass
+class DBCredentials:
+    password: str
+    username: str
+    host: str
+    port: int
+    db_name: str
+    engine: str = "django.db.backends.postgresql"
+    dependency: Optional[str] = None
+
+
+
+@blok("live.arkitekt.postgres")
+class DBService(Protocol):
+
+
+    def register_db(self, db_name: str) -> DBCredentials:
+        ...
+    

arkitekt_next/bloks/services/gateway.py

@@ -0,0 +1,20 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from dataclasses import dataclass
+from typing import Dict, Any, Protocol
+
+from blok import blok, InitContext, service
+
+
+@blok("live.arkitekt.gateway")
+class GatewayService(Protocol):
+
+    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
+       ...
+
+    def expose_default(self, port: int, host: str):
+        ...
+
+    def expose_port(self, port: int, host: str, tls: bool = False):
+        ...
+    

arkitekt_next/bloks/services/livekit.py

@@ -0,0 +1,19 @@
+
+
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class LivekitCredentials:
+    api_key: str
+    api_secret: str
+    api_url: str
+
+@service("io.livekit.livekit")
+class LivekitService(Protocol):
+
+    def retrieve_access(self) -> LivekitCredentials:
+        ...
+

arkitekt_next/bloks/services/lok.py

@@ -0,0 +1,27 @@
+
+
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class LokCredentials:
+    issuer: str
+    key_type: str
+    public_key: str
+
+
+@service("live.arkitekt.lok")
+class LokService(Protocol):
+
+    def retrieve_credentials(self) -> LokCredentials:
+        ...
+
+    def retrieve_labels(self, service_name: str) -> list[str]:
+        ...
+
+    def register_scopes(self, scopes_dict: Dict[str, str]):
+        ...
+        
+

arkitekt_next/bloks/services/mount.py

@@ -0,0 +1,15 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option, ExecutionContext, service
+from blok.tree import YamlFile
+
+
+
+
+@service("live.arkitekt.mount")
+class MountService(Protocol):
+
+    def register_mount(self, name: str, file: YamlFile) -> str:
+        ...
+
+
+   

arkitekt_next/bloks/services/redis.py

@@ -0,0 +1,28 @@
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.tree import YamlFile, Repo
+from dataclasses import dataclass
+from typing import Dict, Any, Protocol, Optional
+
+from blok import blok, InitContext, service
+from dataclasses import dataclass
+
+@dataclass
+class RedisConnection:
+    host: str
+    port: int
+    dependency: Optional[str] = None
+
+
+
+@blok("live.arkitekt.redis")
+class RedisService(Protocol):
+
+
+     def register(self) -> RedisConnection:
+        return RedisConnection(
+            host=self.host,
+            port=self.port,
+            dependency=self.host if not self.skip else None,
+        )
+
+    

arkitekt_next/bloks/services/s3.py

@@ -0,0 +1,26 @@
+
+
+from typing import Dict, Any, List, Protocol, Optional
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class S3Credentials:
+    access_key: str
+    buckets: Dict[str, str]
+    host: str
+    port: int
+    secret_key: str
+    protocol: str
+    dependency: Optional[str] = None
+
+
+@service("live.arkitekt.s3")
+class S3Service(Protocol):
+
+    def create_buckets(self, buckets: List[str]) -> S3Credentials:
+        ...
+
+        
+