arkitekt-next 0.7.38__py3-none-any.whl → 0.7.40__py3-none-any.whl

arkitekt_next/bloks/fluss.py

@@ -1,5 +1,8 @@
 import secrets
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_dependencies,
+    create_default_service_yaml,
+)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
@@ -21,17 +24,11 @@ class FlussBlok:
         self.secret_key = secrets.token_hex(16)
         self.ensured_repos = []
 
+    def get_builder(self):
+        return "arkitekt.generic"
+
     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",
-        ]
+        return create_default_service_dependencies()
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():

arkitekt_next/bloks/funcs.py

@@ -3,6 +3,20 @@ from blok.tree import YamlFile, Repo
 from typing import 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):
     service_name: str
@@ -15,6 +29,23 @@ class DefaultService(Protocol):
 
     def get_identifier(self) -> str: ...
 
+    def get_builder(self) -> str: ...
+
+
+def create_default_service_dependencies():
+    return [
+        DnsService,
+        GatewayService,
+        DBService,
+        RedisService,
+        S3Service,
+        ConfigService,
+        MountService,
+        AdminService,
+        SecretService,
+        LokService,
+    ]
+
 
 def create_default_service_yaml(
     init: InitContext,
@@ -22,17 +53,28 @@ def create_default_service_yaml(
 ) -> YamlFile:
     check_protocol_compliance(self, DefaultService)
     deps = init.dependencies
-    deps["live.arkitekt.lok"].register_scopes(self.scopes)
 
-    gateway_access = deps["live.arkitekt.gateway"].expose(self.host, 80, self.host)
+    init.get_service(LokService).register_scopes(self.scopes)
+
+    path_name = self.host
+
+    gateway_access = init.get_service(GatewayService).expose(path_name, 80, self.host)
+
+    postgress_access = init.get_service(DBService).register_db(self.host)
+    redis_access = init.get_service(RedisService).register()
+    lok_access = init.get_service(LokService).retrieve_credentials()
+    admin_access = init.get_service(AdminService).retrieve()
+    minio_access = init.get_service(S3Service).create_buckets(self.buckets)
+    lok_labels = init.get_service(LokService).retrieve_labels(
+        self.get_identifier(), self.get_builder()
+    )
+
+    dns_result = init.get_service(DnsService).get_dns_result()
 
-    postgress_access = deps["live.arkitekt.postgres"].register_db(self.host)
-    redis_access = deps["live.arkitekt.redis"].register()
-    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
-    admin_access = deps["live.arkitekt.admin"].retrieve()
-    minio_access = deps["live.arkitekt.s3"].create_buckets(self.buckets)
-    lok_access = deps["live.arkitekt.lok"].retrieve_credentials()
-    lok_labels = deps["live.arkitekt.lok"].retrieve_labels(self.get_identifier())
+    csrf_trusted_origins = []
+    for hostname in dns_result.hostnames:
+        csrf_trusted_origins.append(f"http://{hostname}")
+        csrf_trusted_origins.append(f"https://{hostname}")
 
     configuration = YamlFile(
         **{
@@ -47,10 +89,12 @@ def create_default_service_yaml(
             "lok": asdict(lok_access),
             "s3": asdict(minio_access),
             "scopes": self.scopes,
+            "force_script_name": path_name,
+            "csrf_trusted_origins": csrf_trusted_origins,
         }
     )
 
-    config_mount = deps["live.arkitekt.config"].register_config(
+    config_mount = init.get_service(ConfigService).register_config(
         f"{self.host}.yaml", configuration
     )
 
@@ -72,11 +116,15 @@ def create_default_service_yaml(
     }
 
     if self.mount_repo:
-        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        mount = init.get_service(MountService).register_mount(
+            self.host, Repo(self.repo)
+        )
         service["volumes"].extend([f"{mount}:/workspace"])
 
     if self.build_repo:
-        mount = deps["live.arkitekt.mount"].register_mount(self.host, Repo(self.repo))
+        mount = init.get_service(MountService).register_mount(
+            self.host, Repo(self.repo)
+        )
         service["build"] = mount
     else:
         service["image"] = self.image

arkitekt_next/bloks/gateway.py

@@ -16,16 +16,25 @@ class ExposedHost(BaseModel):
     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")
 class GatewayBlok:
     def __init__(self) -> None:
         self.exposed_hosts = {}
+        self.exposed_to_hosts = {}
         self.http_expose_default = None
         self.exposed_ports = {}
         self.with_certer = True
@@ -38,10 +47,10 @@ class GatewayBlok:
 
     def get_internal_host(self):
         return "caddy"
-    
+
     def get_https_port(self):
         return 443
-    
+
     def get_http_port(self):
         return 80
 
@@ -52,7 +61,10 @@ class GatewayBlok:
         self.public_ips = dns.get_dns_result().ip_addresses
         self.public_hosts = dns.get_dns_result().hostnames
 
-    def build(self, context: ExecutionContext,):
+    def build(
+        self,
+        context: ExecutionContext,
+    ):
         caddyfile = """
 {
     auto_https off
@@ -64,13 +76,13 @@ class GatewayBlok:
                 caddyfile += f"""
 :{port.port} {{
     tls /certs/caddy.crt /certs/caddy.key
-    reverse_proxy {port.host}:{port.port}
+    reverse_proxy {port.host}:{port.to}
 }}
                 """
             else:
                 caddyfile += f"""
 :{port.port} {{
-    reverse_proxy {port.host}:{port.port}
+    reverse_proxy {port.host}:{port.to}
 }}
                 """
 
@@ -112,6 +124,15 @@ class GatewayBlok:
     }}
                 """
 
+            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 {{
@@ -129,10 +150,18 @@ class GatewayBlok:
         if self.with_certer:
             caddy_depends_on.append("certer")
 
+        exposed_ports_strings = [
+            f"{port.port}:{port.port}" for port in self.exposed_ports.values()
+        ]
+
         caddy_container = {
             "image": "caddy:latest",
             "volumes": ["./configs/Caddyfile:/etc/caddy/Caddyfile", "./certs:/certs"],
-            "ports": [f"{self.http_port}:80", f"{self.https_port}:443"],
+            "ports": [
+                f"{self.http_port}:80",
+                f"{self.https_port}:443",
+            ]
+            + exposed_ports_strings,
             "depends_on": caddy_depends_on,
         }
 
@@ -150,16 +179,24 @@ class GatewayBlok:
 
         context.docker_compose.set_nested("services", "certer", certer_container)
 
-    def expose(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
+    def expose(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
         )
 
+    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)
+        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(

arkitekt_next/bloks/kabinet.py

@@ -1,7 +1,10 @@
 from typing import Dict, Any
 import secrets
 
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_yaml,
+    create_default_service_dependencies,
+)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
 
@@ -12,7 +15,10 @@ class KabinetBlok:
         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.scopes = {
+            "kabinet_deploy": "Deploy containers",
+            "kabinet_add_repo": "Add repositories to the database",
+        }
         self.mount_repo = False
         self.build_repo = False
         self.buckets = ["media"]
@@ -20,17 +26,11 @@ class KabinetBlok:
         self.ensured_repos = []
         self.image = "jhnnsrs/kabinet:next"
 
+    def get_builder(self):
+        return "arkitekt.generic"
+
     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",
-        ]
+        return create_default_service_dependencies()
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
@@ -57,7 +57,7 @@ class KabinetBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-           type=bool,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(

arkitekt_next/bloks/livekit.py

@@ -22,7 +22,6 @@ class LocalLiveKitBlok:
         self.api_secret = "secret"
         self.skip = False
 
-
     def preflight(self, init: InitContext, gateway: GatewayService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
@@ -33,16 +32,18 @@ class LocalLiveKitBlok:
             return
 
         gateway.expose_port(7880, self.host, True)
-        gateway.expose_port(7881, self.host, True)
+        gateway.expose_port_to(7882, self.host, 7880, False)
 
         self.initialized = True
 
     def retrieve_access(self):
-        return LivekitCredentials(**{
-            "api_key": self.api_key,
-            "api_secret": self.api_secret,
-            "api_url": f"http://{self.host}:7880",
-        })
+        return LivekitCredentials(
+            **{
+                "api_key": self.api_key,
+                "api_secret": self.api_secret,
+                "api_url": f"http://{self.host}:7880",
+            }
+        )
 
     def build(self, context: ExecutionContext):
         if self.skip:
@@ -55,18 +56,14 @@ class LocalLiveKitBlok:
             "image": self.image,
             "command": self.command,
             "ports": [
-                f"{self.port_range[0]}-{self.port_range[1]}:{self.port_range[0]}-{self.port_range[1]}"
+                f"{self.port_range[0]}-{self.port_range[1]}:{self.port_range[0]}-{self.port_range[1]}",
+                "7881:7881",
             ],
         }
 
         context.docker_compose.set_nested("services", self.host, db_service)
 
     def get_options(self):
-        with_command = Option(
-            subcommand="command",
-            help="The fakts url for connection",
-            default=self.command,
-        )
         with_host = Option(
             subcommand="host",
             help="The fakts url for connection",
@@ -77,12 +74,10 @@ class LocalLiveKitBlok:
             help="The fakts url for connection",
             default=False,
             type=bool,
-            
         )
 
         return [
             with_host,
-            with_command,
             with_skip,
         ]
 

arkitekt_next/bloks/lok.py

@@ -17,11 +17,11 @@ from dataclasses import asdict
 
 from arkitekt_next.bloks.services.redis import RedisService
 from blok import blok, InitContext, ExecutionContext, Option
+from blok.bloks.services.dns import DnsService
 from blok.tree import YamlFile, Repo
 from blok import blok, InitContext
 
 
-
 DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 
 
@@ -132,35 +132,28 @@ class LokBlok:
         self.tokens = []
         self.groups = []
         self.secret_key = secrets.token_hex(16)
-        self.scopes = {"hallo": "welt"}
+        self.scopes = {
+            "openid": "The open id connect scope",
+            "read": "A generic read access",
+            "write": "A generic write access",
+        }
         self.key = None
         self.deployment_name = "default"
-        self.base_routes = [
-            "ht",
-            "o",
-            "graphql",
-            ".well-known",
-            "f",
-            "admin",
-            "static",
-            "accounts",
-        ]
         self.token_expiry_seconds = 700000
         self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
         self.registered_tokens = {}
 
-
     def retrieve_credentials(self) -> LokCredentials:
         return LokCredentials(
             public_key=self.public_key, key_type="RS256", issuer="lok"
         )
 
-    def retrieve_labels(self, service_name: str) -> list[str]:
+    def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]:
         return [
             f"fakts.service={service_name}",
-            f"fakts.builder=arkitekt.{service_name}",
+            f"fakts.builder={builder_name}",
         ]
-    
+
     def retrieve_token(self, user: str = "admin") -> str:
         new_token = self.secret_blok.retrieve_secret()
         self.registered_tokens[user] = new_token
@@ -170,25 +163,32 @@ class LokBlok:
     def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
         self.scopes = self.scopes | scopes_dict
 
-    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, secrets: SecretBlok, livekit: LivekitService, scopes: list[Dict[str, str]]):
+    def preflight(
+        self,
+        init: InitContext,
+        gateway: GatewayService,
+        db: DBService,
+        redis: RedisService,
+        admin: AdminService,
+        secrets: SecretBlok,
+        livekit: LivekitService,
+        dns: DnsService,
+    ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
         assert self.public_key, "Public key is required"
         assert self.private_key, "Private key is required"
 
-        self.scopes = {scope["scope"]: scope["description"] for scope in scopes}
-
-        for i in self.base_routes:
-             gateway.expose(
-                i, 80, self.host, strip_prefix=False
-            )
+        gateway.expose("lok", 80, self.host, strip_prefix=False)
+        gateway.expose_mapped(".well-known", 80, self.host, "lok")
 
         self.secret_blok = secrets
         self.postgress_access = db.register_db(self.host)
         self.redis_access = redis.register()
         self.admin_access = admin.retrieve()
         self.local_access = livekit.retrieve_access()
+        self.dns_result = dns.get_dns_result()
         self.initialized = True
 
     def build(self, context: ExecutionContext):
@@ -222,6 +222,12 @@ class LokBlok:
 
         db_service["command"] = self.command
 
+        trusted_origins = []
+
+        for i in self.dns_result.hostnames:
+            trusted_origins.append(f"http://{i}")
+            trusted_origins.append(f"https://{i}")
+
         configuration = YamlFile(
             **{
                 "db": asdict(self.postgress_access),
@@ -232,17 +238,22 @@ class LokBlok:
                     "hosts": ["*"],
                     "secret_key": self.secret_key,
                 },
-                "redis":  asdict(self.redis_access),
+                "redis": asdict(self.redis_access),
                 "lok": asdict(self.retrieve_credentials()),
                 "private_key": self.private_key,
                 "public_key": self.public_key,
                 "scopes": self.scopes,
-                "redeem_tokens": [token for token in self.registered_tokens],
+                "redeem_tokens": [
+                    {"user": name, "token": token}
+                    for name, token in self.registered_tokens.items()
+                ],
                 "groups": [group for group in self.groups],
                 "deployment": {"name": self.deployment_name},
                 "livekit": asdict(self.local_access),
                 "token_expire_seconds": self.token_expiry_seconds,
                 "apps": [],
+                "force_script_name": "lok",
+                "csrf_trusted_origins": trusted_origins,
             }
         )
 
@@ -292,13 +303,6 @@ class LokBlok:
             type=GROUP,
             show_default=True,
         )
-        with_scopes = Option(
-            subcommand="scopes",
-            help="Additional scopes that should be created (normally handled by the bloks)",
-            default=[f"{key}:{value}" for key, value in self.scopes.items()],
-            multiple=True,
-            type=SCOPE,
-        )
         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",
@@ -314,7 +318,7 @@ class LokBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
-           type=bool,
+            type=bool,
             default=False,
         )
         build_repo = Option(
@@ -361,7 +365,6 @@ class LokBlok:
             with_host,
             with_private_key,
             with_public_key,
-            with_scopes,
             with_secret_key,
         ]
 

arkitekt_next/bloks/mikro.py

@@ -7,7 +7,11 @@ from blok import blok, InitContext
 
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_dependencies,
+    create_default_service_yaml,
+    DefaultService,
+)
 
 
 class AccessCredentials(BaseModel):
@@ -24,7 +28,10 @@ class MikroBlok:
         self.host = "mikro"
         self.command = "bash run-debug.sh"
         self.repo = "https://github.com/arkitektio/mikro-server-next"
-        self.scopes = {"read_image": "Read image from the database"}
+        self.scopes = {
+            "mikro_read": "Read image from the database",
+            "mikro_write": "Write image to the database",
+        }
         self.image = "jhnnsrs/mikro:next"
         self.mount_repo = False
         self.build_repo = False
@@ -32,16 +39,10 @@ class MikroBlok:
         self.secret_key = secrets.token_hex(16)
 
     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",
-        ]
+        return create_default_service_dependencies()
+
+    def get_builder(self):
+        return "arkitekt.generic"
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():

arkitekt_next/bloks/minio.py

@@ -54,8 +54,6 @@ class MinioBlok:
         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()
@@ -63,11 +61,14 @@ class MinioBlok:
         bucket_map = {}
 
         for bucket in buckets:
-            bucket_map[bucket] = self.name_service.retrieve_name()
+            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,
@@ -81,17 +82,22 @@ class MinioBlok:
 
         return creds
 
-    def preflight(self, init: InitContext, secret: SecretService, name: NameService, gateway: GatewayService, config: ConfigService):
+    def preflight(
+        self,
+        init: InitContext,
+        secret: SecretService,
+        name: NameService,
+        gateway: GatewayService,
+        config: ConfigService,
+    ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        gateway.expose_default(9000, self.host)
         self.secret_service = secret
         self.name_service = name
+        self.gateway_service = gateway
 
-        self.config_path = config.get_path(
-            self.host + ".yaml"
-        )
+        self.config_path = config.get_path(self.host + ".yaml")
 
     def build(self, context: ExecutionContext):
         minio_service_init = {
@@ -103,7 +109,7 @@ class MinioBlok:
             "environment": {
                 "MINIO_ROOT_PASSWORD": self.password,
                 "MINIO_ROOT_USER": self.username,
-                "MINIO_HOST": f"{self.host}:9000",
+                "MINIO_HOST": f"http://{self.host}:9000",
             },
             "image": self.init_image,
             "volumes": [f"{self.config_path}:/workspace/config.yaml"],
@@ -128,7 +134,19 @@ class MinioBlok:
         )
 
         context.file_tree.set_nested(
-            *self.config_path.split("/"), YamlFile(**{"buckets": list(self.buckets)})
+            *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):

arkitekt_next/bloks/rekuest.py

@@ -1,7 +1,10 @@
 from typing import Dict, Any
 import secrets
 
-from arkitekt_next.bloks.funcs import create_default_service_yaml
+from arkitekt_next.bloks.funcs import (
+    create_default_service_dependencies,
+    create_default_service_yaml,
+)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
 
@@ -12,7 +15,10 @@ class RekuestBlok:
         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.scopes = {
+            "rekuest_agent": "Act as an agent",
+            "rekuest_call": "Call other apps with rekuest",
+        }
         self.mount_repo = False
         self.build_repo = False
         self.buckets = ["media"]
@@ -21,16 +27,10 @@ class RekuestBlok:
         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",
-        ]
+        return create_default_service_dependencies()
+
+    def get_builder(self):
+        return "arkitekt.rekuest"
 
     def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
@@ -65,7 +65,7 @@ class RekuestBlok:
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-           type=bool,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/services/__init__.py

@@ -0,0 +1,27 @@
+from .admin import AdminService
+from .lok import LokService
+from .db import DBService
+from .redis import RedisService
+from .s3 import S3Service
+from .config import ConfigService
+from .mount import MountService
+from .secret import SecretService
+from .gateway import GatewayService
+from .livekit import LivekitService
+
+
+__all__ = [
+    "AdminService",
+    "LokService",
+    "DBService",
+    "RedisService",
+    "S3Service",
+    "ConfigService",
+    "MountService",
+    "SecretService",
+    "GatewayService",
+    "LivekitService",
+    "MountService",
+    "ConfigService",
+    "SecretService",
+]

arkitekt_next/bloks/services/gateway.py

@@ -8,23 +8,20 @@ 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(self, path_name: str, port: int, host: str, strip_prefix: bool = True):
-       ...
+    def expose_mapped(self, path_name: str, port: int, host: str, to_name: str): ...
 
-    def expose_default(self, port: int, host: str):
-        ...
+    def expose_default(self, port: int, host: str): ...
 
-    def expose_port(self, port: int, host: str, tls: bool = False):
-        ...
+    def expose_port(self, port: int, host: str, tls: bool = False): ...
 
-    def get_internal_host(self):
-        ...
+    def expose_port_to(self, port: int, host: str, to_port: str, tls: bool = False): ...
 
+    def get_internal_host(self): ...
 
-    def get_https_port(self):
-        ...
+    def get_https_port(self): ...
 
-    def get_http_port(self):
-        ...
-    
+    def get_http_port(self): ...

arkitekt_next/bloks/services/lok.py

@@ -1,10 +1,9 @@
-
-
 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
@@ -14,14 +13,8 @@ class LokCredentials:
 
 @service("live.arkitekt.lok")
 class LokService(Protocol):
+    def retrieve_credentials(self) -> LokCredentials: ...
 
-    def retrieve_credentials(self) -> LokCredentials:
-        ...
-
-    def retrieve_labels(self, service_name: str) -> list[str]:
-        ...
-
-    def register_scopes(self, scopes_dict: Dict[str, str]):
-        ...
-        
+    def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]: ...
 
+    def register_scopes(self, scopes_dict: Dict[str, str]): ...

arkitekt_next/bloks/services/redis.py

@@ -6,6 +6,7 @@ from typing import Dict, Any, Protocol, Optional
 from blok import blok, InitContext, service
 from dataclasses import dataclass
 
+
 @dataclass
 class RedisConnection:
     host: str
@@ -13,16 +14,6 @@ class RedisConnection:
     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,
-        )
-
-    
+    def register(self) -> RedisConnection: ...

arkitekt_next/bloks/services/s3.py

@@ -1,12 +1,12 @@
-
-
 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:
+    name: str
     access_key: str
     buckets: Dict[str, str]
     host: str
@@ -18,9 +18,4 @@ class S3Credentials:
 
 @service("live.arkitekt.s3")
 class S3Service(Protocol):
-
-    def create_buckets(self, buckets: List[str]) -> S3Credentials:
-        ...
-
-        
-
+    def create_buckets(self, buckets: List[str]) -> S3Credentials: ...

{arkitekt_next-0.7.38.dist-info → arkitekt_next-0.7.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.38
+Version: 0.7.40
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -14,25 +14,25 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
+Provides-Extra: blok
 Provides-Extra: cli
-Provides-Extra: server
-Requires-Dist: blok (>=0.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
-Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
+Requires-Dist: blok (>=0.0.9) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: dokker (>=0.1.21)
 Requires-Dist: fakts (>=0.5.0)
-Requires-Dist: fluss-next (>=0.1.69) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.70) ; extra == "all"
 Requires-Dist: herre (>=0.4.3)
-Requires-Dist: kabinet (>=0.1.7) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.8) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=0.3.6)
-Requires-Dist: mikro-next (>=0.1.24) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
-Requires-Dist: namegenerator (>=1.0.6) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
-Requires-Dist: netifaces (>=0.11.0) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
+Requires-Dist: mikro-next (>=0.1.25) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: namegenerator (>=1.0.6) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: netifaces (>=0.11.0) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: reaktion-next (>=0.1.59) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.13) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: rekuest-next (>=0.2.14) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
 Requires-Dist: rich-click (>=1.6.1) ; extra == "cli" or extra == "all"
 Requires-Dist: semver (>=3.0.1) ; extra == "cli" or extra == "all"
 Requires-Dist: turms (>=0.5.0) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
-Requires-Dist: unlok-next (>=0.1.64) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: unlok-next (>=0.1.65) ; python_version >= "3.8" and python_version < "4.0"
 Requires-Dist: watchfiles (>=0.18.1) ; extra == "cli" or extra == "all"
 Description-Content-Type: text/markdown
 

{arkitekt_next-0.7.38.dist-info → arkitekt_next-0.7.40.dist-info}/RECORD

@@ -16,32 +16,32 @@ arkitekt_next/bloks/__init__.py,sha256=gXny6-WJ3alV1__xveI_0wcvgDuglR1WB7v7-8h1O
 arkitekt_next/bloks/admin.py,sha256=MlUQUYCHxCWtSD75mVHgs3DcDa0s8_D6_AIBslnYjZw,1300
 arkitekt_next/bloks/arkitekt.py,sha256=1h2fyJK-TcuiOVFyE7iO2S1jwLv52APsQpfxddmHWjk,1263
 arkitekt_next/bloks/config.py,sha256=SqJg9kB0AQ62b_WpIKgJ8Jpcqpc-AKN7gdEj87O-UGY,1268
-arkitekt_next/bloks/fluss.py,sha256=WXsE1M-0vDCVj5Fxi6MvHcPQiezkJPQ5GvUq93t4nt8,2814
-arkitekt_next/bloks/funcs.py,sha256=6QImH3eOSd6KXd8XfaulexAzy16A_J8GJi58Q18MQms,2641
-arkitekt_next/bloks/gateway.py,sha256=1seqZkU0yMai60JB0Rz1J--uNv21osiTVZVSjlusRjE,5184
+arkitekt_next/bloks/fluss.py,sha256=07l8mdS35JyuEthv4xH9qpCCNepMkJGm02PxEakQBD0,2671
+arkitekt_next/bloks/funcs.py,sha256=z1b58hENZfTfXYEqg_pP_2hm3ogDyu9_Ek8wk1P5XkA,3633
+arkitekt_next/bloks/gateway.py,sha256=a1suHpSbdvu-KnkExYtRAxizwHhQXQhvoil8g24sLG4,6234
 arkitekt_next/bloks/internal_docker.py,sha256=q9gPPtU1m0-0eeqF4zxtCELp4lF8TVZSJi1qVwnSWus,2421
-arkitekt_next/bloks/kabinet.py,sha256=gvoXeA4W6Aoc26wWK8nN9i6Gj5bxYE3by28MTLtJNyM,2995
-arkitekt_next/bloks/livekit.py,sha256=8_7YgsTnV3zZ_RonZZaOHyKkCoiKqLVv6-h74yGlB0A,2681
-arkitekt_next/bloks/lok.py,sha256=x1bu2b03sARVF4mxSBJzzdyCNJVx0feyhCz1qWjRRN4,12466
-arkitekt_next/bloks/mikro.py,sha256=x58fbw6INDfiRYwMRFYm8RIygmXoYj28gtn7mS6bEro,2814
-arkitekt_next/bloks/minio.py,sha256=6Mi1flePiwIA-durcRsQSE3OtCYwGzVLTJI7jHMrlgk,4918
+arkitekt_next/bloks/kabinet.py,sha256=RMetXRKFRO9z_eGPXyzGCHTo9HJlcPaew2lfCltGoMg,2937
+arkitekt_next/bloks/livekit.py,sha256=yhre3PkIQwKGdGPFC-DhTID3rIbRQMts_UsAX9tw6-A,2561
+arkitekt_next/bloks/lok.py,sha256=MGXKg1NRvydA-wlncBQJwO2GfaQLl2shVo0g45r9J_8,12532
+arkitekt_next/bloks/mikro.py,sha256=vNM9K7I3AK2G0WooaMQl7U8-_TN96P2YUfblqAMsvdI,2772
+arkitekt_next/bloks/minio.py,sha256=k7t1J46lO3eaBO9KdP7iYF--Go-m25dEmOwisbbOoVQ,5496
 arkitekt_next/bloks/mount.py,sha256=d14w7bMiaWbl5wgvanh4PwfIqEYsDEsw91360xfX0fU,1031
 arkitekt_next/bloks/namegen.py,sha256=0k4PYya5J4EQyt3XZ3UKhDlO_k29pmUEQSaklZGN8MA,1035
 arkitekt_next/bloks/postgres.py,sha256=FRUF2fobUlU6OmK1VC7aN_WuX1NctLmZhzJJA1uOOeY,2773
 arkitekt_next/bloks/redis.py,sha256=_ddmcD3WwX7VA7zzzQ7-yjSM7f4reV0C8Pl70s7R2k8,2130
-arkitekt_next/bloks/rekuest.py,sha256=_Er2mgiH0bQS62PWlGDolulpLkeYrQJ8TvQ2jqf6aOU,3044
+arkitekt_next/bloks/rekuest.py,sha256=OgX_OeVeGVK-pSL3S8cocUWsYX929Yv5o9NuEvkwJr0,2975
 arkitekt_next/bloks/secret.py,sha256=P4Z56FhcgVD0KbokhcMNAXwDjo_86rI99nWh3gUGXSQ,1014
-arkitekt_next/bloks/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arkitekt_next/bloks/services/__init__.py,sha256=i9vGNd1lFBem3O2PblTouRzFVQkdwOYoUmqqU43dIWQ,592
 arkitekt_next/bloks/services/admin.py,sha256=OXMAHph5lABNPFsXm8aboWffJ7CzSSNvke7xpmj9raI,463
 arkitekt_next/bloks/services/config.py,sha256=BLtbKXRRWmuZxvaaksuxt9EiDcazYwKL_IUIRhXBin8,393
 arkitekt_next/bloks/services/db.py,sha256=jMO751KJYjNmvHD0tOTWgkkemwTXc6mLHAge_i68JSA,600
-arkitekt_next/bloks/services/gateway.py,sha256=YUpz7qkqfOTXS74gU0C7s3o7MHe_9xQJHQLWg7aGhyc,662
+arkitekt_next/bloks/services/gateway.py,sha256=9dDv2aWCErkZ9JreqHdKax63_Imbc2EnWhpeScLnI7Q,799
 arkitekt_next/bloks/services/livekit.py,sha256=5u-GThgKsgXiiobEL4arm3JJOgNTZae15Q-75i-4D8g,366
-arkitekt_next/bloks/services/lok.py,sha256=OYC5BVr3MxeP8AuARO56UFL4490Yygcscdm5DQq-fVs,517
+arkitekt_next/bloks/services/lok.py,sha256=fzOGum0VmcVaONUhTv4jHYky4WrFq2ygDAYJjBv2vAI,500
 arkitekt_next/bloks/services/mount.py,sha256=MDlwHl5cTfBO8IgkofuFjQBbfIMKDm_R9suWkiyVG48,289
 arkitekt_next/bloks/services/name.py,sha256=ZMDlZwnSaoIUj7STlpFo32nHKMuOibKzetYWSjh-t-c,254
-arkitekt_next/bloks/services/redis.py,sha256=d5cSk2v6A6CvYULocwd2Cnx9RkHKYHmZT1mZmZQNKgs,633
-arkitekt_next/bloks/services/s3.py,sha256=njXlLzUssj46w90bMdqO-7HSAVQtZHH2r1yVNlR-mfU,492
+arkitekt_next/bloks/services/redis.py,sha256=hC8cKXkGzwrY183fI-8wjUY8Ge58lNhcX7r4zAPfq_k,469
+arkitekt_next/bloks/services/s3.py,sha256=_mk_9NdaeHRVZ__1M9CL1Ec1gSQKkzlOiQXse7MSx94,485
 arkitekt_next/bloks/services/secret.py,sha256=iUG1ZH_dR0tL48rueNOK2ILjEnyqNJjQCY-4KKrB_Zg,342
 arkitekt_next/bloks/services/socket.py,sha256=eXACQPldS9I1xGVDcbF6LrVkHHsBcjvG1VtlvHnM-14,427
 arkitekt_next/bloks/socket.py,sha256=YIrSKfQezrsKwRKDPdT1aXhlQzjgnx_UaNaQ9LiEfGY,1008
@@ -145,8 +145,8 @@ arkitekt_next/qt/utils.py,sha256=MgBPtPmCSBkIuATov3UgREESwxAHh77lWNNxyE7Qs48,773
 arkitekt_next/service_registry.py,sha256=pczUuP_Nve7OYwB7-oDBLIw6bkjZPnzL3xFca5TF1io,3405
 arkitekt_next/tqdm.py,sha256=DlrxPluHao7TvW-Cqgt0UokRS-fM2_ZNiWiddqvCqCc,1488
 arkitekt_next/utils.py,sha256=gmKWy9M51vimohmmaoIpAJ0CaB22TFP0w3JszRrwiak,2379
-arkitekt_next-0.7.38.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
-arkitekt_next-0.7.38.dist-info/METADATA,sha256=NJrnRs82cPUTEThfUuwjRUAm0W1lgcLoVqcT7FITWzQ,6055
-arkitekt_next-0.7.38.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-arkitekt_next-0.7.38.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
-arkitekt_next-0.7.38.dist-info/RECORD,,
+arkitekt_next-0.7.40.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
+arkitekt_next-0.7.40.dist-info/METADATA,sha256=Cb4uLTlJt7J7itIWXLDnv1PDJnCJlZEHmhPOZpBextY,5973
+arkitekt_next-0.7.40.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+arkitekt_next-0.7.40.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
+arkitekt_next-0.7.40.dist-info/RECORD,,