arkitekt-next 0.7.49__tar.gz → 0.7.51__tar.gz

{arkitekt_next-0.7.49 → arkitekt_next-0.7.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.49
+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.13) ; (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.25) ; (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.59) ; (python_version >= "3.8" and python_version < "4.0") and (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: 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.65) ; 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.51/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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-0.7.49 → arkitekt_next-0.7.51}/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.49 → arkitekt_next-0.7.51}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arkitekt-next"
-version = "0.7.49"
+version = "0.7.51"
 description = "client for the arkitekt_next platform"
 authors = ["jhnnsrs <jhnnsrs@gmail.com>"]
 license = "MIT"
@@ -11,12 +11,12 @@ readme = "README.md"
 python = "^3.8"
 herre = ">=0.4.3"
 fakts = ">=0.5.0"
-mikro-next = { version = ">=0.1.25", python = "^3.10", optional = true }
-kabinet = { version = ">=0.1.8", optional = true,  python = "^3.9" }
-fluss-next = { version = ">=0.1.70", optional = true }
-reaktion-next= { version = ">=0.1.59", python = "^3.8", optional = true }
-rekuest-next= { version = ">=0.2.14", python = "^3.8", optional = true }
-unlok-next= { version = ">=0.1.65", python = "^3.8", optional = true }
+mikro-next = { version = ">=0.1.28", python = "^3.10", optional = true }
+kabinet = { version = ">=0.1.11", optional = true,  python = "^3.9" }
+fluss-next = { version = ">=0.1.73", optional = true }
+reaktion-next= { version = ">=0.1.63", python = "^3.8", optional = true }
+rekuest-next= { version = ">=0.2.18", python = "^3.8", optional = true }
+unlok-next= { version = ">=0.1.67", python = "^3.8", optional = true }
 rich-click = { version = ">=1.6.1", optional = true }
 watchfiles = { version = ">=0.18.1", optional = true }
 turms = { version = ">=0.5.0", python = "^3.9", optional = true }
@@ -24,7 +24,7 @@ semver = { version = ">=3.0.1", optional = true }
 dokker = ">=0.1.21"
 koil = ">=0.3.6"
 netifaces = { version = ">=0.11.0", python = "^3.8", optional = true }
-blok = { version = ">=0.0.13", python = "^3.8", optional = true }
+blok = { version = ">=0.0.15", python = "^3.8", optional = true }
 cryptography = { version = ">=40.0.8", python = "^3.8", optional = true }
 namegenerator = { version = ">=1.0.6", python = "^3.8", optional = true }