arkitekt-next 0.8.60__tar.gz → 0.8.62__tar.gz

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.8.60
+Version: 0.8.62
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -14,29 +14,39 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
+Provides-Extra: alpaka
 Provides-Extra: blok
 Provides-Extra: cli
 Provides-Extra: extended
+Provides-Extra: fluss
+Provides-Extra: kabinet
+Provides-Extra: kraph
+Provides-Extra: lovekit
+Provides-Extra: mikro
+Provides-Extra: reaktion
+Provides-Extra: rekuest
 Provides-Extra: stream
+Provides-Extra: unlok
+Requires-Dist: alpaka (>=0.1.17) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "alpaka" or extra == "extended")
 Requires-Dist: blok (>=0.0.22) ; (python_version >= "3.9" 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 (>=1.0.0)
 Requires-Dist: fakts-next (>=1.0.4)
-Requires-Dist: fluss-next (>=0.1.95) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.96) ; extra == "fluss" or extra == "all"
 Requires-Dist: herre-next (>=1.0.2)
-Requires-Dist: kabinet (>=0.1.45) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.46) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "kabinet" or extra == "all")
 Requires-Dist: koil (>=1.0.3)
-Requires-Dist: kraph (>=0.1.100) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "extended")
-Requires-Dist: lovekit (>=0.1.18) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "stream")
-Requires-Dist: mikro-next (>=0.1.50) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kraph (>=0.1.101) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "kraph" or extra == "extended")
+Requires-Dist: lovekit (>=0.1.19) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "lovekit" or extra == "stream")
+Requires-Dist: mikro-next (>=0.1.55) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "mikro" or 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.86) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.58) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: reaktion-next (>=0.1.87) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "reaktion" or extra == "all")
+Requires-Dist: rekuest-next (>=0.2.62) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "rekuest" or extra == "all")
 Requires-Dist: rich-click (>=1.6.1) ; extra == "cli" or extra == "all" or extra == "blok"
 Requires-Dist: semver (>=3.0.1) ; extra == "cli" or extra == "all"
 Requires-Dist: turms (>=0.8.2) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
-Requires-Dist: unlok-next (>=0.1.87) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: unlok-next (>=0.1.89) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "unlok")
 Requires-Dist: watchfiles (>=0.18.1) ; extra == "cli" or extra == "all"
 Description-Content-Type: text/markdown
 

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/__blok__.py

@@ -21,6 +21,7 @@ from arkitekt_next.bloks.namegen import PreformedNamesBlok
 from arkitekt_next.bloks.ollama import OllamaBlok
 from arkitekt_next.bloks.self_signed import SelfSignedBlok
 from arkitekt_next.bloks.kraph import KraphBlok
+from arkitekt_next.bloks.local_sign import LocalSignBlok
 
 
 def get_bloks():
@@ -48,4 +49,6 @@ def get_bloks():
         SecretBlok(),
         PreformedNamesBlok(),
         OrkestratorBlok(),
+        LocalSignBlok(),
     ]
+

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/__init__.py

@@ -34,7 +34,11 @@ from .builders import easy, interactive
 from .apps.types import App
 from fakts_next.helpers import afakt, fakt
 from .init_registry import init, InitHookRegisty, get_current_init_hook_registry
-from .service_registry import require, ServiceBuilderRegistry, get_current_service_registry
+from .service_registry import (
+    require,
+    ServiceBuilderRegistry,
+    get_current_service_registry,
+)
 
 
 __all__ = [

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/base_models.py

@@ -2,7 +2,7 @@
 
 from hashlib import sha256
 import json
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, ConfigDict
 from typing import List, Optional
 
 
@@ -42,9 +42,7 @@ class Manifest(BaseModel):
     """ A URL to the logo of the app TODO: We should enforce this to be a http URL as local paths won't work """
     requirements: Optional[List[Requirement]] = Field(default_factory=list)
     """ Requirements that this app has TODO: What are the requirements? """
-
-    class Config:
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")
 
     def hash(self):
         """Hash the manifest

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/arkitekt.py

@@ -22,18 +22,21 @@ class AdminCredentials(BaseModel):
     email: str
 
 
-@blok("live.arkitekt", dependencies=[
-    MikroBlok.as_dependency(True, True),
-    KabinetBlok.as_dependency(True, True),
-    RekuestBlok.as_dependency(True, True),
-    FlussBlok.as_dependency(True, True),
-    InternalDockerBlok.as_dependency(True, True),
-    LocalLiveKitBlok.as_dependency(True, True),
-    OrkestratorBlok.as_dependency(True, False),
-    KraphBlok.as_dependency(True, False),
-    TailscaleBlok.as_dependency(True, False),
-    OllamaBlok.as_dependency(True, False),
-])
+@blok(
+    "live.arkitekt",
+    dependencies=[
+        MikroBlok.as_dependency(True, True),
+        KabinetBlok.as_dependency(True, True),
+        RekuestBlok.as_dependency(True, True),
+        FlussBlok.as_dependency(True, True),
+        InternalDockerBlok.as_dependency(True, True),
+        LocalLiveKitBlok.as_dependency(True, True),
+        OrkestratorBlok.as_dependency(True, False),
+        KraphBlok.as_dependency(True, False),
+        TailscaleBlok.as_dependency(True, False),
+        OllamaBlok.as_dependency(True, False),
+    ],
+)
 class ArkitektBlok:
 
     def entry(self, renderer: Renderer):
@@ -46,6 +49,5 @@ class ArkitektBlok:
             )
         )
 
-
     def build(self, cwd):
         pass

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/base.py

@@ -1,6 +1,6 @@
 from blok import blok, InitContext, Option
 from blok.tree import YamlFile, Repo
-from typing import Any, Protocol
+from typing import Any, Optional, Protocol
 from blok.utils import check_protocol_compliance
 from dataclasses import asdict
 from arkitekt_next.bloks.services import (
@@ -58,15 +58,15 @@ class BaseArkitektService:
         self,
         init: InitContext,
         lok: LokService,
-        dns: DnsService,
         db: DBService,
-        gateway: GatewayService,
         redis: RedisService,
         s3: S3Service,
         config: ConfigService,
         mount: MountService,
         admin: AdminService,
         secret: SecretService,
+        gateway: Optional[GatewayService] = None,
+        dns: DnsService = None,
         mount_repo: bool = False,
         host: str = "",
         image: str = "",
@@ -83,7 +83,9 @@ class BaseArkitektService:
 
         path_name = self.host
 
-        gateway_access = gateway.expose(path_name, 80, self.host)
+        if gateway:
+            print("Registering gateway access")
+            gateway_access = gateway.expose(path_name, 80, self.host)
 
         postgress_access = db.register_db(self.host)
         redis_access = redis.register()

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/gateway.py

@@ -33,7 +33,8 @@ class ExposedPort(BaseModel):
 
 
 @blok(
-    "live.arkitekt.gateway", description="A gateway for exposing services on the host",
+    "live.arkitekt.gateway",
+    description="A gateway for exposing services on the host",
 )
 class CaddyBlok:
     def __init__(self) -> None:
@@ -63,7 +64,13 @@ class CaddyBlok:
     def retrieve_gateway_network(self):
         return self.gateway_network
 
-    def preflight(self, init: InitContext, dns: DnsService, name: NameService, certer: CerterService):
+    def preflight(
+        self,
+        init: InitContext,
+        dns: DnsService,
+        name: NameService,
+        certer: CerterService,
+    ):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -73,7 +80,6 @@ class CaddyBlok:
 
         self.cert_mount = certer.retrieve_certs_mount()
         self.depends_on = certer.retrieve_depends_on()
-        
 
     def build(
         self,
@@ -108,8 +114,7 @@ class CaddyBlok:
                 """
     tls /certs/caddy.crt /certs/caddy.key
     """
-                if protocol == "https"
-                and self.cert_mount
+                if protocol == "https" and self.cert_mount
                 else ""
             )
             caddyfile += """
@@ -167,7 +172,6 @@ class CaddyBlok:
             f"{port.port}:{port.port}" for port in self.exposed_ports.values()
         ]
 
-
         volumes = ["./configs/Caddyfile:/etc/caddy/Caddyfile"]
         if self.cert_mount:
             volumes.append(f"{self.cert_mount}:/certs")

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/kraph.py

@@ -18,7 +18,10 @@ class AccessCredentials(BaseModel):
     db_name: str
 
 
-@blok("live.arkitekt.kraph", description="Kraph allows you to interconnect structures in a graph database")
+@blok(
+    "live.arkitekt.kraph",
+    description="Kraph allows you to interconnect structures in a graph database",
+)
 class KraphBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False

arkitekt_next-0.8.62/arkitekt_next/bloks/local_sign.py

@@ -0,0 +1,261 @@
+import click
+
+from pydantic import BaseModel
+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, Optional
+from arkitekt_next.bloks.secret import SecretBlok
+from arkitekt_next.bloks.services.admin import AdminService
+from arkitekt_next.bloks.services.db import DBService
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.livekit import LivekitService
+from arkitekt_next.bloks.services.lok import LokCredentials, LokService
+import yaml
+import secrets
+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"
+
+
+# Define a custom user type that will parse and validate the user input
+class UserParamType(click.ParamType):
+    name = "user"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, dict):
+            return value
+        try:
+            name, password = value.split(":")
+            return {"name": name, "password": password}
+        except ValueError:
+            self.fail(
+                f"User '{value}' is not in the correct format. It should be 'name:password'.",
+                param,
+                ctx,
+            )
+
+
+USER = UserParamType()
+
+
+# Define a custom user type that will parse and validate the user input
+class GroupParamType(click.ParamType):
+    name = "group"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, dict):
+            return value
+        try:
+            name, description = value.split(":")
+            return {"name": name, "description": description}
+        except ValueError:
+            self.fail(
+                f"User '{value}' is not in the correct format. It should be 'name:password'.",
+                param,
+                ctx,
+            )
+
+
+GROUP = GroupParamType()
+
+
+class RedeemTokenParamType(click.ParamType):
+    name = "redeem_token"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, dict):
+            assert "user" in value, f"scope is required {value}"
+            assert "token" in value, f"description is required {value}"
+            return value
+
+        try:
+            user, token = value.split(":")
+            return {"user": user, "token": token}
+        except ValueError:
+            self.fail(
+                f"RedeemToken '{value}' is not in the correct format. It should be 'username:token'.",
+                param,
+                ctx,
+            )
+
+
+TOKEN = RedeemTokenParamType()
+
+
+class ScopeParamType(click.ParamType):
+    name = "scope"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, dict):
+            assert "scope" in value, f"scope is required {value}"
+            assert "description" in value, f"description is required {value}"
+            return value
+
+        try:
+            name, description = value.split(":")
+            return {"scope": name, "description": description}
+        except ValueError:
+            self.fail(
+                f"Scopes '{value}' is not in the correct format. It should be 'scope:description'.",
+                param,
+                ctx,
+            )
+
+
+SCOPE = ScopeParamType()
+
+
+@blok(LokService, description="A local sign service")
+class LocalSignBlok:
+    db_name: str
+
+    def __init__(self) -> None:
+        self.db_name = "lok_db"
+        self.mount_repo = False
+        self.build_repo = False
+        self.private_key = None
+        self.public_key = None
+        self.host = "lok"
+        self.dev = False
+        self.with_repo = False
+        self.users = []
+        self.tokens = []
+        self.groups = []
+        self.scopes = {}
+        self.key = None
+        self.deployment_name = "default"
+        self.token_expiry_seconds = 700000
+        self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
+        self.registered_tokens = {}
+        self.local_access = None
+
+    def retrieve_credentials(self) -> LokCredentials:
+        return LokCredentials(
+            public_key=self.public_key, key_type="RS256", issuer="lok"
+        )
+
+    def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]:
+        return [
+            f"fakts.service={service_name}",
+            f"fakts.builder={builder_name}",
+        ]
+
+    def retrieve_token(self, user: str = "admin") -> str:
+        pass 
+        return "fake-token"
+
+    def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
+        self.scopes = self.scopes | scopes_dict
+
+    def preflight(
+        self,
+        init: InitContext
+    ):
+        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"
+
+
+    def build(self, context: ExecutionContext):
+        context.file_tree.set_nested("secrets", "public_key.pem", self.public_key)
+        context.file_tree.set_nested("secrets", "private_key.pem", self.private_key)
+
+    def get_options(self):
+        key = rsa.generate_private_key(
+            public_exponent=65537, key_size=2048, backend=crypto_default_backend()
+        )
+
+        private_key = key.private_bytes(
+            crypto_serialization.Encoding.PEM,
+            crypto_serialization.PrivateFormat.PKCS8,
+            crypto_serialization.NoEncryption(),
+        ).decode()
+
+        public_key = (
+            key.public_key()
+            .public_bytes(
+                crypto_serialization.Encoding.OpenSSH,
+                crypto_serialization.PublicFormat.OpenSSH,
+            )
+            .decode()
+        )
+
+        with_dev = Option(
+            subcommand="dev",
+            help="Run the service in development mode",
+            type=bool,
+            default=self.dev,
+            show_default=True,
+        )
+
+        with_fakts_url = Option(
+            subcommand="db_name",
+            help="The name of the database",
+            default="db_name",
+            show_default=True,
+        )
+        with_users = Option(
+            subcommand="users",
+            help="Users that should be greated by default. Format is name:password",
+            default=["admin:admin"],
+            multiple=True,
+            type=USER,
+            show_default=True,
+        )
+        with_groups = Option(
+            subcommand="groups",
+            help="Groups that should be greated by default. Format is name:description",
+            default=["admin:admin_group"],
+            multiple=True,
+            type=GROUP,
+            show_default=True,
+        )
+        with_public_key = Option(
+            subcommand="public_key",
+            help="The public key for the JWT creation",
+            default=public_key,
+            required=True,
+            callback=validate_public_key,
+        )
+        with_private_key = Option(
+            subcommand="private_key",
+            help="The corresponding private key for the JWT creation",
+            default=private_key,
+            callback=validate_private_key,
+            required=True,
+        )
+
+        return [
+            with_dev,
+            with_fakts_url,
+            with_users,
+            with_groups,
+            with_private_key,
+            with_public_key,
+        ]
+
+
+def validate_public_key(ctx, param, value):
+    if not value.startswith("ssh-rsa"):
+        raise click.BadParameter(
+            f"Public key must be in ssh-rsa format. Started with {value}"
+        )
+    return value
+
+
+def validate_private_key(ctx, param, value):
+    if not value.startswith("-----BEGIN PRIVATE KEY-----"):
+        raise click.BadParameter(
+            f"Private key must be in PEM format. Started with {value}"
+        )
+    return value

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/lok.py

@@ -234,8 +234,6 @@ class LokBlok:
             trusted_origins.append(f"http://{i}")
             trusted_origins.append(f"https://{i}")
 
-
-
         configuration = YamlFile(
             **{
                 "db": asdict(self.postgress_access),
@@ -257,7 +255,11 @@ class LokBlok:
                 ],
                 "groups": [group for group in self.groups],
                 "deployment": {"name": self.deployment_name},
-                "livekit": asdict(self.local_access) if self.local_access else {"api_key": "dev", "api_secret": "secret", "api_url": None},
+                "livekit": (
+                    asdict(self.local_access)
+                    if self.local_access
+                    else {"api_key": "dev", "api_secret": "secret", "api_url": None}
+                ),
                 "token_expire_seconds": self.token_expiry_seconds,
                 "apps": [],
                 "force_script_name": "lok",

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/ollama.py

@@ -20,7 +20,6 @@ class OllamaBlok:
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-
         if self.skip:
             return
 
@@ -28,7 +27,6 @@ class OllamaBlok:
 
         self.initialized = True
 
-
     def build(self, context: ExecutionContext):
         if self.skip:
             return
@@ -40,7 +38,7 @@ class OllamaBlok:
             "image": self.image,
             "environment": {
                 "OLLAMA_KEEP_ALIVE": "24h",
-            }
+            },
         }
 
         if self.gpu:
@@ -58,7 +56,6 @@ class OllamaBlok:
                 }
             }
 
-
         context.docker_compose.set_nested("services", self.host, db_service)
 
     def get_options(self):

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/orkestrator.py

@@ -34,11 +34,10 @@ class OrkestratorBlok:
 
         if self.disable:
             return
-        
+
         if not self.dev:
             gateway.expose(self.path_name, 80, self.host)
 
-
             self.service = {
                 "image": "jhnnsrs/orkestrator_next:nightly",
                 "environment": {
@@ -46,8 +45,8 @@ class OrkestratorBlok:
                 },
             }
 
-            return 
-    
+            return
+
         else:
 
             self.mount = mount.register_mount("orkestrator", Repo(self.repo))
@@ -73,7 +72,7 @@ class OrkestratorBlok:
     def build(self, context: ExecutionContext):
         if self.disable:
             return
-        
+
         if self.dev:
 
             context.install_commands.set_nested(
@@ -84,7 +83,6 @@ class OrkestratorBlok:
             )
             return
 
-        
         context.docker_compose.set_nested("services", self.host, self.service)
         pass
 

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/self_signed.py

@@ -32,9 +32,7 @@ class ExposedPort(BaseModel):
     to: int
 
 
-@blok(
-    "live.arkitekt.certer", description="A self-signed certificate generator"
-)
+@blok("live.arkitekt.certer", description="A self-signed certificate generator")
 class SelfSignedBlok:
     def __init__(self) -> None:
         self.host = "certer"
@@ -44,7 +42,6 @@ class SelfSignedBlok:
     def retrieve_certs_mount(self):
         return self.certs_mount
 
-
     def retrieve_depends_on(self):
         return ["certer"]
 
@@ -55,7 +52,6 @@ class SelfSignedBlok:
         self.public_ips = dns.get_dns_result().ip_addresses
         self.public_hosts = dns.get_dns_result().hostnames
 
-
     def build(
         self,
         context: ExecutionContext,
@@ -63,7 +59,6 @@ class SelfSignedBlok:
 
         context.file_tree.set_nested("certs", {})
 
-
         certer_container = {
             "image": self.certer_image,
             "volumes": ["./certs:/certs"],
@@ -75,8 +70,6 @@ class SelfSignedBlok:
 
         context.docker_compose.set_nested("services", self.host, certer_container)
 
-   
-
     def get_options(self):
         with_public_urls = Option(
             subcommand="public_url",

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/bloks/services/certer.py

@@ -10,5 +10,5 @@ from blok import blok, InitContext, service
 class CerterService(Protocol):
 
     def retrieve_certs_mount(self) -> str: ...
-        
-    def retrieve_depends_on(self) -> list[str]: ...
+
+    def retrieve_depends_on(self) -> list[str]: ...

{arkitekt_next-0.8.60 → arkitekt_next-0.8.62}/arkitekt_next/cli/commands/gen/init.py

@@ -14,7 +14,7 @@ from arkitekt_next.cli.options import (
 import yaml
 from arkitekt_next.cli.utils import build_relative_dir
 from arkitekt_next.cli.vars import get_console, get_manifest
-from arkitekt_next.service_registry import check_and_import_services
+from arkitekt_next.service_registry import get_default_service_registry
 
 
 @click.command()
@@ -51,7 +51,7 @@ def init(ctx, boring, services, config, documents, schemas, path, seperate_doc_d
     # Initializing the config
     projects = {}
 
-    registry = check_and_import_services()
+    registry = get_default_service_registry()
 
     chosen_services = registry.service_builders