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

arkitekt_next/bloks/minio.py

@@ -1,21 +1,12 @@
 import click
 
-from blok import blok, InitContext, ExecutionContext, CLIOption
+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
-
-
-class S3Credentials(BaseModel):
-    access_key: str
-    buckets: Dict[str, str]
-    host: str
-    port: int
-    secret_key: str
-    protocol: str
-    dependency: Optional[str] = None
+from arkitekt_next.bloks.services.s3 import S3Credentials, S3Service
 
 
 class BucketMapParamType(click.ParamType):
@@ -38,7 +29,7 @@ class BucketMapParamType(click.ParamType):
 TOKEN = BucketMapParamType()
 
 
-@blok("live.arkitekt.s3")
+@blok(S3Service)
 class MinioBlok:
     db_name: str
 
@@ -51,6 +42,8 @@ class MinioBlok:
         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)]
@@ -61,9 +54,9 @@ class MinioBlok:
         return "live.arkitekt.s3"
 
     def get_dependencies(self):
-        return []
+        return ["live.arkitekt.config", "live.arkitekt.gateway"]
 
-    def retrieve_credentials(self, buckets: list[str]) -> S3Credentials:
+    def create_buckets(self, buckets: list[str]) -> S3Credentials:
         new_access_key = self.preformed_access_keys.pop()
         new_secret_key = self.preformed_secret_keys.pop()
 
@@ -88,7 +81,7 @@ class MinioBlok:
 
         return creds
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -98,6 +91,12 @@ class MinioBlok:
         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": {
@@ -110,17 +109,18 @@ class MinioBlok:
                 "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": "minio/minio:RELEASE.2023-02-10T18-48-39Z",
-            "volumes": {
-                "./data": "/data",
-            },
+            "image": self.minio_image,
+            "volumes": ["./data:/data"],
             "labels": ["fakts.service=live.arkitekt.s3", "fakts.builder=arkitekt.s3"],
         }
 
@@ -131,39 +131,39 @@ class MinioBlok:
             "services", f"{self.host}_init", minio_service_init
         )
 
-        configuration = YamlFile(**{"buckets": list(self.buckets)})
-
-        context.file_tree.set_nested("configs", "minio.yaml", configuration)
+        context.file_tree.set_nested(
+            *self.config_path.split("/"), YamlFile(**{"buckets": list(self.buckets)})
+        )
 
     def get_options(self):
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="The fakts url for connection",
             default=self.host,
         )
-        with_username = CLIOption(
+        with_username = Option(
             subcommand="username",
             help="The fakts url for connection",
             default=self.username,
         )
-        with_password = CLIOption(
+        with_password = Option(
             subcommand="password",
             help="The fakts url for connection",
             default=self.password,
         )
-        with_preformed_bucket_names = CLIOption(
+        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 = CLIOption(
+        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 = CLIOption(
+        with_preformed_secret_keys = Option(
             subcommand="preformed_secret_keys",
             help="The fakts url for connection",
             multiple=True,

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

@@ -1,6 +1,7 @@
 from typing import Optional
 
-from blok import blok, InitContext, ExecutionContext, CLIOption
+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
@@ -9,16 +10,9 @@ import secrets
 from blok import blok, InitContext
 
 
-class AccessCredentials(BaseModel):
-    password: str
-    username: str
-    host: str
-    port: str
-    db_name: str
-    dependency: Optional[str] = None
 
 
-@blok("live.arkitekt.postgres")
+@blok(DBService)
 class PostgresBlok(BaseModel):
     host: str = "db"
     port: int = 5432
@@ -27,7 +21,7 @@ class PostgresBlok(BaseModel):
     user: str = pydantic.Field(default_factory=lambda: namegenerator.gen(separator=""))
     image: str = "jhnnsrs/daten:next"
 
-    registered_dbs: dict[str, AccessCredentials] = {}
+    registered_dbs: dict[str, DBCredentials] = {}
 
     def get_dependencies(self):
         return []
@@ -35,11 +29,11 @@ class PostgresBlok(BaseModel):
     def get_identifier(self):
         return "live.arkitekt.postgres"
 
-    def register_db(self, db_name: str) -> AccessCredentials:
+    def register_db(self, db_name: str) -> DBCredentials:
         if db_name in self.registered_dbs:
             return self.registered_dbs[db_name]
         else:
-            access_credentials = AccessCredentials(
+            access_credentials = DBCredentials(
                 password=self.password,
                 username=self.user,
                 host=self.host,
@@ -50,7 +44,7 @@ class PostgresBlok(BaseModel):
             self.registered_dbs[db_name] = access_credentials
             return access_credentials
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -61,29 +55,29 @@ class PostgresBlok(BaseModel):
                 "POSTGRES_PASSWORD": self.password,
                 "POSTGRES_MULTIPLE_DATABASES": ",".join(self.registered_dbs.keys()),
             },
-            "image": "jhnnsrs/daten-next",
+            "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 = CLIOption(
+        with_postgres_password = Option(
             subcommand="password",
             help="The postgres password for connection",
             default=self.password,
         )
-        with_user_password = CLIOption(
+        with_user_password = Option(
             subcommand="user",
             help="The postgress user_name",
-            default=self.password,
+            default=self.user,
         )
-        skip_build = CLIOption(
+        skip_build = Option(
             subcommand="skip",
             help="Should the service not be created? E.g when pointing outwards?",
             default=self.skip,
         )
-        with_image = CLIOption(
+        with_image = Option(
             subcommand="image",
             help="The image to use for the service",
             default=self.image,

arkitekt_next/bloks/redis.py

@@ -1,6 +1,7 @@
 import click
 
-from blok import blok, InitContext, ExecutionContext, CLIOption
+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
@@ -8,17 +9,8 @@ from typing import Dict, Any, Optional
 from blok import blok, InitContext
 
 
-DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
-DEFAULT_PUBLIC_HOSTS = ["localhost"]
 
-
-class RedisConnection(BaseModel):
-    host: str
-    port: str
-    dependency: Optional[str] = None
-
-
-@blok("live.arkitekt.redis")
+@blok(RedisService)
 class RedisBlok:
     def __init__(self) -> None:
         self.host = "redis"
@@ -39,7 +31,7 @@ class RedisBlok:
             dependency=self.host if not self.skip else None,
         )
 
-    def init(self, init: InitContext):
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -51,33 +43,32 @@ class RedisBlok:
             },
             "image": self.image,
             "ports": [f"{self.port}:{self.port}"],
-            "name": self.host,
         }
 
         context.docker_compose.set_nested(f"services", self.host, redis_service)
 
     def get_options(self):
-        with_port = CLIOption(
+        with_port = Option(
             subcommand="port",
             help="Which port to use",
             type=int,
             default=self.port,
             show_default=True,
         )
-        with_host = CLIOption(
+        with_host = Option(
             subcommand="host",
             help="Which public hosts to use",
             type=str,
             default=self.host,
             show_default=True,
         )
-        with_skip = CLIOption(
+        with_skip = Option(
             subcommand="skip",
             help="Skip docker creation (if using external redis?)",
             is_flag=True,
             default=self.skip,
         )
-        with_image = CLIOption(
+        with_image = Option(
             subcommand="image",
             help="The image to use for the service",
             default=self.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:
+        ...
+
+        
+

arkitekt_next/bloks/services/socket.py

@@ -0,0 +1,16 @@
+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.docker_socket")
+class DockerSocketService(Protocol):
+
+    def register_socket(self, name: str) -> str:
+        self.registered_configs[name] = name
+        return self.docker_socket
+
+