arkitekt-next 0.7.38__tar.gz → 0.7.40__tar.gz

{arkitekt_next-0.7.38 → arkitekt_next-0.7.40}/PKG-INFO

@@ -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 → arkitekt_next-0.7.40}/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-0.7.40/arkitekt_next/bloks/funcs.py

@@ -0,0 +1,134 @@
+from blok import blok, InitContext, Option
+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
+    host: str
+    buckets: list[str]
+    scopes: dict[str, str]
+    secret_key: str
+    mount_repo: bool
+    build_repo: bool
+
+    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,
+    self: DefaultService,
+) -> YamlFile:
+    check_protocol_compliance(self, DefaultService)
+    deps = init.dependencies
+
+    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()
+
+    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(
+        **{
+            "db": asdict(postgress_access),
+            "django": {
+                "admin": asdict(admin_access),
+                "debug": True,
+                "hosts": ["*"],
+                "secret_key": self.secret_key,
+            },
+            "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,
+        }
+    )
+
+    config_mount = init.get_service(ConfigService).register_config(
+        f"{self.host}.yaml", configuration
+    )
+
+    depends_on = []
+
+    if redis_access.dependency:
+        depends_on.append(redis_access.dependency)
+
+    if postgress_access.dependency:
+        depends_on.append(postgress_access.dependency)
+
+    if minio_access.dependency:
+        depends_on.append(minio_access.dependency)
+
+    service = {
+        "labels": lok_labels,
+        "volumes": [f"{config_mount}:/workspace/config.yaml"],
+        "depends_on": depends_on,
+    }
+
+    if self.mount_repo:
+        mount = init.get_service(MountService).register_mount(
+            self.host, Repo(self.repo)
+        )
+        service["volumes"].extend([f"{mount}:/workspace"])
+
+    if self.build_repo:
+        mount = init.get_service(MountService).register_mount(
+            self.host, Repo(self.repo)
+        )
+        service["build"] = mount
+    else:
+        service["image"] = self.image
+
+    service["command"] = self.command
+
+    return service

{arkitekt_next-0.7.38 → arkitekt_next-0.7.40}/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-0.7.38 → arkitekt_next-0.7.40}/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-0.7.38 → arkitekt_next-0.7.40}/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-0.7.38 → arkitekt_next-0.7.40}/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-0.7.38 → arkitekt_next-0.7.40}/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():