arkitekt-next 0.7.50__py3-none-any.whl → 0.7.51__py3-none-any.whl

arkitekt_next/bloks/base.py

@@ -0,0 +1,216 @@
+from blok import blok, InitContext, Option
+from blok.tree import YamlFile, Repo
+from typing import Any, 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):
+    dev: bool
+    repo: str
+    command: str
+    service_name: str
+    host: str
+    buckets: list[str]
+    scopes: dict[str, str]
+    secret_key: str
+    mount_repo: bool
+    build_repo: bool
+
+    def get_blok_meta(self) -> str: ...
+
+    def get_builder(self) -> str: ...
+
+
+def create_default_service_dependencies():
+    return [
+        DnsService,
+        GatewayService,
+        DBService,
+        RedisService,
+        S3Service,
+        ConfigService,
+        MountService,
+        AdminService,
+        SecretService,
+        LokService,
+    ]
+
+
+class BaseArkitektService:
+    def get_additional_config(self):
+        return {}
+
+    def preflight(
+        self,
+        init: InitContext,
+        lok: LokService,
+        dns: DnsService,
+        db: DBService,
+        gateway: GatewayService,
+        redis: RedisService,
+        s3: S3Service,
+        config: ConfigService,
+        mount: MountService,
+        admin: AdminService,
+        secret: SecretService,
+        mount_repo: bool = False,
+        host: str = "",
+        image: str = "",
+        secret_key: str = "",
+        build_repo: bool = False,
+        command: str = "",
+        repo: str = "",
+        disable: bool = False,
+        dev: bool = False,
+    ):
+        deps = init.dependencies
+
+        lok.register_scopes(self.scopes)
+
+        path_name = self.host
+
+        gateway_access = gateway.expose(path_name, 80, self.host)
+
+        postgress_access = db.register_db(self.host)
+        redis_access = redis.register()
+        lok_access = lok.retrieve_credentials()
+        admin_access = admin.retrieve()
+        minio_access = s3.create_buckets(self.buckets)
+        lok_labels = lok.retrieve_labels(
+            self.get_blok_meta().service_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,
+                **self.get_additional_config(),
+            }
+        )
+
+        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 mount_repo or dev:
+            mount = init.get_service(MountService).register_mount(self.host, Repo(repo))
+            service["volumes"].extend([f"{mount}:/workspace"])
+
+        if build_repo or dev:
+            mount = init.get_service(MountService).register_mount(self.host, Repo(repo))
+            service["build"] = mount
+        else:
+            service["image"] = image
+
+        service["command"] = command
+
+        self.service = service
+
+    def get_additional_options(self):
+        return []
+
+    def get_options(self):
+        return [
+            Option(
+                subcommand="dev",
+                help="Shoud we run the service in development mode (includes withrepo, mountrepo)?",
+                default=self.dev,
+            ),
+            Option(
+                subcommand="host",
+                help="The name we should use for the host?",
+                default=self.host,
+            ),
+            Option(
+                subcommand="disable",
+                help="Shoud we disable the service?",
+                default=False,
+            ),
+            Option(
+                subcommand="repo",
+                help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
+                default=self.repo,
+            ),
+            Option(
+                subcommand="command",
+                help="Which command should we use when building the service?",
+                default=self.command,
+            ),
+            Option(
+                subcommand="mount_repo",
+                help="Should we mount the repo into the container?",
+                type=bool,
+                default=self.mount_repo,
+            ),
+            Option(
+                subcommand="build_repo",
+                help="Should we build the container from the repo?",
+                type=bool,
+                default=self.build_repo,
+            ),
+            Option(
+                subcommand="host",
+                help="How should the service be named inside the docker-compose file?",
+                default=self.host,
+            ),
+            Option(
+                subcommand="secret_key",
+                help="The secret key to use for the django service",
+                default=self.secret_key,
+            ),
+            Option(
+                subcommand="image",
+                help="The image to use for the service",
+                default=self.image,
+            ),
+            *self.get_additional_options(),
+        ]

arkitekt_next/bloks/fluss.py

@@ -1,18 +1,16 @@
 import secrets
-from arkitekt_next.bloks.funcs import (
-    build_default_service_options,
-    create_default_service_dependencies,
-    create_default_service_yaml,
-)
+
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
+from arkitekt_next.bloks.base import BaseArkitektService
+from typing import List
 
 
 DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 
 
 @blok("live.arkitekt.fluss")
-class FlussBlok:
+class FlussBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False
         self.host = "fluss"
@@ -24,28 +22,10 @@ class FlussBlok:
         self.build_repo = False
         self.buckets = ["media"]
         self.secret_key = secrets.token_hex(16)
-        self.ensured_repos = []
+        self.ensured_repos: List[str] = []
 
     def get_builder(self):
         return "arkitekt.generic"
 
-    def get_dependencies(self):
-        return create_default_service_dependencies()
-
-    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):
-        def_options = build_default_service_options(self)
-
-        return [
-            *def_options,
-        ]

arkitekt_next/bloks/kabinet.py

@@ -1,17 +1,14 @@
 from typing import Dict, Any
 import secrets
 
-from arkitekt_next.bloks.funcs import (
-    create_default_service_yaml,
-    create_default_service_dependencies,
-    build_default_service_options,
-)
+
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
+from arkitekt_next.bloks.base import BaseArkitektService
 
 
 @blok("live.arkitekt.kabinet")
-class KabinetBlok:
+class KabinetBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False
         self.host = "kabinet"
@@ -28,27 +25,16 @@ class KabinetBlok:
         self.ensured_repos = ["jhnnsrs/ome:main", "jhnnsrs/renderer:main"]
         self.image = "jhnnsrs/kabinet:next"
 
+    def get_additional_config(self):
+        return {"ensured_repos": self.ensured_repos}
+
     def get_builder(self):
         return "arkitekt.generic"
 
-    def get_dependencies(self):
-        return create_default_service_dependencies()
-
-    def preflight(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        self.service = create_default_service_yaml(
-            init, self, {"ensured_repos": self.ensured_repos}
-        )
-
-        self.initialized = True
-
     def build(self, context: ExecutionContext):
         context.docker_compose.set_nested("services", self.host, self.service)
 
-    def get_options(self):
-        def_options = build_default_service_options(self)
+    def get_additional_options(self):
         with_repos = Option(
             subcommand="repos",
             help="The default repos to enable for the service",
@@ -56,6 +42,5 @@ class KabinetBlok:
         )
 
         return [
-            *def_options,
             with_repos,
         ]

arkitekt_next/bloks/lok.py

@@ -5,7 +5,6 @@ from cryptography.hazmat.primitives import serialization as crypto_serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.backends import default_backend as crypto_default_backend
 from typing import Dict
-from arkitekt_next.bloks.funcs import build_default_service_options
 from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.services.admin import AdminService
 from arkitekt_next.bloks.services.db import DBService
@@ -283,8 +282,6 @@ class LokBlok:
             .decode()
         )
 
-        def_options = build_default_service_options(self)
-
         with_dev = Option(
             subcommand="dev",
             help="Run the service in development mode",
@@ -331,7 +328,7 @@ class LokBlok:
         )
 
         return [
-            *def_options,
+            with_dev,
             with_fakts_url,
             with_users,
             with_groups,

arkitekt_next/bloks/mikro.py

@@ -7,12 +7,7 @@ from blok import blok, InitContext
 
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
-from arkitekt_next.bloks.funcs import (
-    build_default_service_options,
-    create_default_service_dependencies,
-    create_default_service_yaml,
-    DefaultService,
-)
+from arkitekt_next.bloks.base import BaseArkitektService
 
 
 class AccessCredentials(BaseModel):
@@ -24,7 +19,7 @@ class AccessCredentials(BaseModel):
 
 
 @blok("live.arkitekt.mikro")
-class MikroBlok:
+class MikroBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False
         self.host = "mikro"
@@ -40,26 +35,8 @@ class MikroBlok:
         self.buckets = ["media", "zarr", "parquet"]
         self.secret_key = secrets.token_hex(16)
 
-    def get_dependencies(self):
-        return create_default_service_dependencies()
-
     def get_builder(self):
         return "arkitekt.generic"
 
-    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):
-        def_options = build_default_service_options(self)
-
-        return [
-            *def_options,
-        ]

arkitekt_next/bloks/orkestrator.py

@@ -1,13 +1,8 @@
 from typing import Dict, Any
 import secrets
-
-from arkitekt_next.bloks.funcs import (
-    create_default_service_yaml,
-    create_default_service_dependencies,
-    build_default_service_options,
-)
 from arkitekt_next.bloks.services.mount import MountService
 from blok import blok, InitContext, ExecutionContext, Option, Command
+from blok.bloks.services.vscode import VsCodeService
 from blok.tree import Repo, YamlFile
 
 
@@ -20,7 +15,7 @@ class OrkestratorBlok:
         self.build_command = ["yarn"]
         self.up_command = ["yarn", "start"]
 
-    def preflight(self, init: InitContext, mount: MountService):
+    def preflight(self, init: InitContext, mount: MountService, vscode: VsCodeService | None = None) :
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -28,6 +23,14 @@ class OrkestratorBlok:
             return
         self.mount = mount.register_mount("orkestrator", Repo(self.repo))
 
+        vscode.register_task(
+            "Run Orkestrator",
+            "shell",
+            "yarn",
+            ["start"],
+            {"cwd": f"{self.mount}"},
+        )
+
         self.initialized = True
 
     def build(self, context: ExecutionContext):

arkitekt_next/bloks/rekuest.py

@@ -1,17 +1,13 @@
 from typing import Dict, Any
 import secrets
 
-from arkitekt_next.bloks.funcs import (
-    build_default_service_options,
-    create_default_service_dependencies,
-    create_default_service_yaml,
-)
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import Repo, YamlFile
+from arkitekt_next.bloks.base import BaseArkitektService
 
 
 @blok("live.arkitekt.rekuest")
-class RekuestBlok:
+class RekuestBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False
         self.host = "rekuest"
@@ -25,29 +21,10 @@ class RekuestBlok:
         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 create_default_service_dependencies()
-
     def get_builder(self):
         return "arkitekt.rekuest"
 
-    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):
-        def_options = build_default_service_options(self)
-
-        return [
-            *def_options,
-        ]

arkitekt_next/bloks/services/db.py

@@ -6,6 +6,7 @@ from typing import Dict, Any, Protocol, Optional
 from blok import blok, InitContext, service
 from dataclasses import dataclass
 
+
 @dataclass
 class DBCredentials:
     password: str
@@ -17,11 +18,6 @@ class DBCredentials:
     dependency: Optional[str] = None
 
 
-
-@blok("live.arkitekt.postgres")
+@service("live.arkitekt.postgres")
 class DBService(Protocol):
-
-
-    def register_db(self, db_name: str) -> DBCredentials:
-        ...
-    
+    def register_db(self, db_name: str) -> DBCredentials: ...

arkitekt_next/bloks/services/gateway.py

@@ -6,7 +6,7 @@ from typing import Dict, Any, Protocol
 from blok import blok, InitContext, service
 
 
-@blok("live.arkitekt.gateway")
+@service("live.arkitekt.gateway")
 class GatewayService(Protocol):
     def expose(
         self, path_name: str, port: int, host: str, strip_prefix: bool = True

arkitekt_next/bloks/services/redis.py

@@ -14,6 +14,6 @@ class RedisConnection:
     dependency: Optional[str] = None
 
 
-@blok("live.arkitekt.redis")
+@service("live.arkitekt.redis")
 class RedisService(Protocol):
     def register(self) -> RedisConnection: ...

arkitekt_next/bloks/services/socket.py

@@ -6,11 +6,8 @@ from typing import Dict, Any, Protocol
 from blok import blok, InitContext, service
 
 
-@blok("live.arkitekt.docker_socket")
+@service("live.arkitekt.docker_socket")
 class DockerSocketService(Protocol):
-
     def register_socket(self, name: str) -> str:
         self.registered_configs[name] = name
         return self.docker_socket
-
-    

{arkitekt_next-0.7.50.dist-info → arkitekt_next-0.7.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.50
+Version: 0.7.51
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -16,23 +16,23 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
 Provides-Extra: blok
 Provides-Extra: cli
-Requires-Dist: blok (>=0.0.14) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: blok (>=0.0.15) ; (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.70) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.73) ; extra == "all"
 Requires-Dist: herre (>=0.4.3)
-Requires-Dist: kabinet (>=0.1.8) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.11) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=0.3.6)
-Requires-Dist: mikro-next (>=0.1.26) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: mikro-next (>=0.1.28) ; (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.61) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.15) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: reaktion-next (>=0.1.63) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
+Requires-Dist: rekuest-next (>=0.2.18) ; (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.66) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: unlok-next (>=0.1.67) ; 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.50.dist-info → arkitekt_next-0.7.51.dist-info}/RECORD

@@ -15,36 +15,36 @@ arkitekt_next/apps/types.py,sha256=cKRqHyKlNcGamPUxzvY0wyz0sEI4sBPa4CnvFnT1sTo,1
 arkitekt_next/bloks/__init__.py,sha256=gXny6-WJ3alV1__xveI_0wcvgDuglR1WB7v7-8h1Olo,30
 arkitekt_next/bloks/admin.py,sha256=MlUQUYCHxCWtSD75mVHgs3DcDa0s8_D6_AIBslnYjZw,1300
 arkitekt_next/bloks/arkitekt.py,sha256=N0WcdEr_x2TzDdpIW_WP8lVodYxRbOU4I5IP-aKGLLQ,1417
+arkitekt_next/bloks/base.py,sha256=6gsDc9sVYDqY4El2hhH32QiYHcYUd6eZQRgvhAuY2a0,6341
 arkitekt_next/bloks/config.py,sha256=SqJg9kB0AQ62b_WpIKgJ8Jpcqpc-AKN7gdEj87O-UGY,1268
-arkitekt_next/bloks/fluss.py,sha256=5-luL5EeCb2DE9aRcjUTxjz5fu2EwgIoBWGGmdlypkc,1487
-arkitekt_next/bloks/funcs.py,sha256=IdiMNUkQN5frHpgsiXJJfJib1lFhUEVwGYjJugpSlds,5350
+arkitekt_next/bloks/fluss.py,sha256=b9hBV0nMy_0ctQIEQntGGaee3oDZy1lQKO1Eacc0zVs,997
 arkitekt_next/bloks/gateway.py,sha256=Qfw_SkJbyMe5GrZ8YJaaLVyZ2ZlKpacJjUFLBk97vbg,6692
 arkitekt_next/bloks/internal_docker.py,sha256=4jhKwfVKPCZzhkuEVq1iw4gIpc6_R0Cco-_s0L8PiZI,2891
-arkitekt_next/bloks/kabinet.py,sha256=jJKLG2VCsnXk7ZVbtqtHiFbz3ezXJeoTxy8itScu64c,1860
+arkitekt_next/bloks/kabinet.py,sha256=a_NA9psOvwypZm_FqIs3Yn6L-G1R8EMOUApJMSiBnPA,1432
 arkitekt_next/bloks/livekit.py,sha256=yhre3PkIQwKGdGPFC-DhTID3rIbRQMts_UsAX9tw6-A,2561
-arkitekt_next/bloks/lok.py,sha256=pdhSaPPmz6v52gitPxhbKCP2CK7GSw3w-vbBB_pabNA,11575
-arkitekt_next/bloks/mikro.py,sha256=JpWqEsV1-LktxSuWhEleZnDOdecHPZDqSR49VbcGxRo,1769
+arkitekt_next/bloks/lok.py,sha256=-OoCFzf2ci8sBrYBnnmni-cJoAxuynUSj0kzWYpJznw,11444
+arkitekt_next/bloks/mikro.py,sha256=r7wc56pvFkPkxigx70xEu31dgpO6q3TviDQUM9oyQwM,1223
 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/orkestrator.py,sha256=FR6Pg3YbX-U8tda9HFTsqSxCWCjWfvJj4rJ35uc_EWs,1965
+arkitekt_next/bloks/orkestrator.py,sha256=26dEhBqlKP_ujM1bNyFiuXiy2Fl-yhwwsJjYcsoAo60,2078
 arkitekt_next/bloks/postgres.py,sha256=FRUF2fobUlU6OmK1VC7aN_WuX1NctLmZhzJJA1uOOeY,2773
 arkitekt_next/bloks/redis.py,sha256=_ddmcD3WwX7VA7zzzQ7-yjSM7f4reV0C8Pl70s7R2k8,2130
-arkitekt_next/bloks/rekuest.py,sha256=X1U_5xEUt_Eb3E6UkOt52m78tn5zTsueXxTScvHNKks,1551
+arkitekt_next/bloks/rekuest.py,sha256=6mxRK1M5ua14rEeF2Wr0QjqV0eUgOLvdDJAuDpRDRUk,993
 arkitekt_next/bloks/secret.py,sha256=P4Z56FhcgVD0KbokhcMNAXwDjo_86rI99nWh3gUGXSQ,1014
 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=8gxbVi7DP1pXv6d7Lm4sA8sKptIWeNIVtQHWa1M-YUk,844
+arkitekt_next/bloks/services/db.py,sha256=Lc8uL8xibz99-16YPxtB_ls6CP3dN_jCaOzJ9uZ8b_0,588
+arkitekt_next/bloks/services/gateway.py,sha256=X7ghhLXZ9hDQIMXMTkfBMcS9o9oc16y0C-b_3r3uwCo,847
 arkitekt_next/bloks/services/livekit.py,sha256=5u-GThgKsgXiiobEL4arm3JJOgNTZae15Q-75i-4D8g,366
 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=hC8cKXkGzwrY183fI-8wjUY8Ge58lNhcX7r4zAPfq_k,469
+arkitekt_next/bloks/services/redis.py,sha256=W9CraIZJztFE1vQVCfxCxY4T_gBPRTM84VwFR8Hwtp8,472
 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/services/socket.py,sha256=3MbENiJrwQbFKrpWxax56F24elnSD7S-olgycfuOX7s,423
 arkitekt_next/bloks/socket.py,sha256=YIrSKfQezrsKwRKDPdT1aXhlQzjgnx_UaNaQ9LiEfGY,1008
 arkitekt_next/bloks/tailscale.py,sha256=IkMBA1CwslMTOF1m2UUmE6qH_gbaEet2eXsPDgBxcew,2915
 arkitekt_next/builders.py,sha256=8HeQsNqyxpbFsnTrA9AAm0_BqxGjU1_ylS1Z-hbjAFw,6074
@@ -136,8 +136,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.50.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
-arkitekt_next-0.7.50.dist-info/METADATA,sha256=2NcEtQFrGpvlyEZGgcNbz6dSpCH6oL70ZxdrF940q08,5974
-arkitekt_next-0.7.50.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-arkitekt_next-0.7.50.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
-arkitekt_next-0.7.50.dist-info/RECORD,,
+arkitekt_next-0.7.51.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
+arkitekt_next-0.7.51.dist-info/METADATA,sha256=2ZYi33bz7qSRGM8nwbp19YaZ68Olpr2aOKjs_mPK6-c,5975
+arkitekt_next-0.7.51.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+arkitekt_next-0.7.51.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
+arkitekt_next-0.7.51.dist-info/RECORD,,

arkitekt_next/bloks/funcs.py

@@ -1,187 +0,0 @@
-from blok import blok, InitContext, Option
-from blok.tree import YamlFile, Repo
-from typing import Any, 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):
-    dev: bool
-    repo: str
-    command: str
-    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 build_default_service_options(self: DefaultService) -> list[Option]:
-    return [
-        Option(
-            subcommand="dev",
-            help="Shoud we run the service in development mode (includes withrepo, mountrepo)?",
-            default=self.dev,
-        ),
-        Option(
-            subcommand="disable",
-            help="Shoud we disable the service?",
-            default=False,
-        ),
-        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,
-        ),
-        Option(
-            subcommand="with_command",
-            help="Which command should we use when building the service?",
-            default=self.command,
-        ),
-        Option(
-            subcommand="mount_repo",
-            help="Should we mount the repo into the container?",
-            type=bool,
-            default=self.mount_repo,
-        ),
-        Option(
-            subcommand="build_repo",
-            help="Should we build the container from the repo?",
-            type=bool,
-            default=self.build_repo,
-        ),
-        Option(
-            subcommand="host",
-            help="How should the service be named inside the docker-compose file?",
-            default=self.host,
-        ),
-        Option(
-            subcommand="secret_key",
-            help="The secret key to use for the django service",
-            default=self.secret_key,
-        ),
-    ]
-
-
-def create_default_service_yaml(
-    init: InitContext,
-    self: DefaultService,
-    additional_keys: dict[str, Any] = None,
-) -> YamlFile:
-    check_protocol_compliance(self, DefaultService)
-    deps = init.dependencies
-    additional_keys = additional_keys or {}
-
-    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,
-            **additional_keys,
-        }
-    )
-
-    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 or self.dev:
-        mount = init.get_service(MountService).register_mount(
-            self.host, Repo(self.repo)
-        )
-        service["volumes"].extend([f"{mount}:/workspace"])
-
-    if self.build_repo or self.dev:
-        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