arkitekt-next 0.7.54__tar.gz → 0.7.56__tar.gz

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.54
+Version: 0.7.56
 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.15) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: blok (>=0.0.19) ; (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.73) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.76) ; extra == "all"
 Requires-Dist: herre (>=0.4.3)
-Requires-Dist: kabinet (>=0.1.11) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.14) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=0.3.6)
-Requires-Dist: mikro-next (>=0.1.28) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: mikro-next (>=0.1.31) ; (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.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: reaktion-next (>=0.1.66) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
+Requires-Dist: rekuest-next (>=0.2.21) ; (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.67) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: unlok-next (>=0.1.70) ; 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.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/admin.py

@@ -4,7 +4,7 @@ from blok import blok, InitContext, Option
 from arkitekt_next.bloks.services.admin import AdminService, AdminCredentials
 
 
-@blok(AdminService)
+@blok(AdminService, description="sdmin credentials for the application")
 class AdminBlok:
     def __init__(self) -> None:
         self.password = "admin"

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/arkitekt.py

@@ -10,6 +10,7 @@ from .fluss import FlussBlok
 from .gateway import GatewayBlok
 from .internal_docker import InternalDockerBlok
 from .orkestrator import OrkestratorBlok
+from typing import Optional
 
 
 class AdminCredentials(BaseModel):
@@ -23,7 +24,7 @@ class ArkitektBlok:
     def entry(self, renderer: Renderer):
         renderer.render(
             Panel(
-                f"This is the arkitekt build that allows you to setup a full stack arkitekt application. Make sure to understand how bloks work before proceeding.",
+                f"""This is the arkitekt build that allows you to setup a full stack arkitekt application. You can use this to setup a full stack application with the following services""",
                 expand=False,
                 title="Welcome to Arkitekt!",
                 style="bold magenta",
@@ -32,17 +33,27 @@ class ArkitektBlok:
 
     def preflight(
         self,
-        lok: LocalLiveKitBlok,
-        mikro: MikroBlok,
-        kabinet: KabinetBlok,
-        rekuest: RekuestBlok,
-        fluss: FlussBlok,
         gateway: GatewayBlok,
-        internal_engine: InternalDockerBlok,
-        scale: TailscaleBlok,
-        orkestrator: OrkestratorBlok,
+        livekit: Optional[LocalLiveKitBlok] = None,
+        mikro: Optional[MikroBlok] = None,
+        kabinet: Optional[KabinetBlok] = None,
+        rekuest: Optional[RekuestBlok] = None,
+        fluss: Optional[FlussBlok] = None,
+        internal_engine: Optional[InternalDockerBlok] = None,
+        scale: Optional[TailscaleBlok] = None,
+        orkestrator: Optional[OrkestratorBlok] = None,
     ):
-        print(lok, mikro, kabinet, rekuest, fluss, gateway, internal_engine)
+        print(
+            gateway,
+            mikro,
+            kabinet,
+            rekuest,
+            fluss,
+            gateway,
+            internal_engine,
+            scale,
+            orkestrator,
+        )
 
     def build(self, cwd):
         pass

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/fluss.py

@@ -9,7 +9,9 @@ from typing import List
 DEFAULT_ARKITEKT_URL = "http://localhost:8000"
 
 
-@blok("live.arkitekt.fluss")
+@blok(
+    "live.arkitekt.fluss", description="A service for managing workflows and their data"
+)
 class FlussBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/gateway.py

@@ -31,7 +31,9 @@ class ExposedPort(BaseModel):
     to: int
 
 
-@blok("live.arkitekt.gateway")
+@blok(
+    "live.arkitekt.gateway", description="A gateway for exposing services on the host"
+)
 class GatewayBlok:
     def __init__(self) -> None:
         self.exposed_hosts = {}

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/internal_docker.py

@@ -9,7 +9,10 @@ from blok.bloks.services.dns import DnsService
 from blok.tree import YamlFile, Repo
 
 
-@blok("live.arkitekt.internal_engine")
+@blok(
+    "live.arkitekt.internal_engine",
+    description="an arktitekt deployer app that uses docker",
+)
 class InternalDockerBlok:
     def __init__(self) -> None:
         self.host = "internal_docker"

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/kabinet.py

@@ -7,7 +7,7 @@ from blok.tree import Repo, YamlFile
 from arkitekt_next.bloks.base import BaseArkitektService
 
 
-@blok("live.arkitekt.kabinet")
+@blok("live.arkitekt.kabinet", description="a container and app management service")
 class KabinetBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/livekit.py

@@ -7,7 +7,7 @@ from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
 
-@blok(LivekitService)
+@blok(LivekitService, description="a self-hosted livekit server")
 class LocalLiveKitBlok:
     def __init__(self) -> None:
         self.host = "livekit"

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/lok.py

@@ -113,7 +113,7 @@ class ScopeParamType(click.ParamType):
 SCOPE = ScopeParamType()
 
 
-@blok(LokService)
+@blok(LokService, description="Lok is an authentication and authorization service")
 class LokBlok:
     db_name: str
 

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/mikro.py

@@ -18,7 +18,7 @@ class AccessCredentials(BaseModel):
     db_name: str
 
 
-@blok("live.arkitekt.mikro")
+@blok("live.arkitekt.mikro", description="Mikro is the bio-image database for arkitekt")
 class MikroBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/minio.py

@@ -33,7 +33,10 @@ class BucketMapParamType(click.ParamType):
 TOKEN = BucketMapParamType()
 
 
-@blok(S3Service)
+@blok(
+    S3Service,
+    description="Minio is an easy use self-hosted object storage service",
+)
 class MinioBlok:
     db_name: str
 

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/mount.py

@@ -6,9 +6,8 @@ from blok import blok, InitContext, Option, ExecutionContext
 from blok.tree import YamlFile
 
 
-@blok(MountService)
+@blok(MountService, description="Mounting files into the file tree for use")
 class MountBlok:
-
     def __init__(self) -> None:
         self.mount_path = "mounts"
         self.registered_configs = {}

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/namegen.py

@@ -8,7 +8,7 @@ import secrets
 import namegenerator
 
 
-@blok(NameService)
+@blok(NameService, description="Preformed names that will not change")
 class PreformedNamesBlok:
     def __init__(self) -> None:
         self.preformed_names = [namegenerator.gen() for _ in range(100)]

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/orkestrator.py

@@ -6,7 +6,10 @@ from blok.bloks.services.vscode import VsCodeService
 from blok.tree import Repo, YamlFile
 
 
-@blok("live.arkitekt.orkestrator")
+@blok(
+    "live.arkitekt.orkestrator",
+    description="Orkestrator is the electron-based UI for arkitekt",
+)
 class OrkestratorBlok:
     def __init__(self) -> None:
         self.dev = False
@@ -28,13 +31,21 @@ class OrkestratorBlok:
             return
         self.mount = mount.register_mount("orkestrator", Repo(self.repo))
 
-        vscode.register_task(
-            "Run Orkestrator",
-            "shell",
-            "yarn",
-            ["start"],
-            {"cwd": f"{self.mount}"},
-        )
+        if vscode is not None:
+            vscode.register_task(
+                "Run Orkestrator",
+                "shell",
+                "yarn",
+                ["start"],
+                {"cwd": f"{self.mount}"},
+            )
+            vscode.register_task(
+                "Build Orkestrator",
+                "shell",
+                "yarn",
+                [],
+                {"cwd": f"{self.mount}"},
+            )
 
         self.initialized = True
 

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/postgres.py

@@ -1,6 +1,7 @@
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from arkitekt_next.bloks.services.db import DBService, DBCredentials
+from arkitekt_next.bloks.services.mount import MountService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
@@ -10,7 +11,10 @@ import secrets
 from blok import blok, InitContext
 
 
-@blok(DBService)
+@blok(
+    DBService,
+    description="Postgres with Apache AGE",
+)
 class PostgresBlok(BaseModel):
     host: str = "db"
     port: int = 5432
@@ -18,8 +22,13 @@ class PostgresBlok(BaseModel):
     password: str = pydantic.Field(default_factory=lambda: secrets.token_hex(16))
     user: str = pydantic.Field(default_factory=lambda: namegenerator.gen(separator=""))
     image: str = "jhnnsrs/daten:next"
+    mount_repo: bool = False
+    build_repo: bool = False
+    repo: str = "https://github.com/arkitektio/daten-server"
+    dev: bool = False
 
     registered_dbs: dict[str, DBCredentials] = {}
+    build_image: Optional[Dict[str, Any]] = None
 
     def get_dependencies(self):
         return []
@@ -42,22 +51,34 @@ class PostgresBlok(BaseModel):
             self.registered_dbs[db_name] = access_credentials
             return access_credentials
 
-    def preflight(self, init: InitContext):
+    def preflight(self, init: InitContext, mount: MountService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-    def build(self, context: ExecutionContext):
-        db_service = {
+        self.build_image = {
             "environment": {
                 "POSTGRES_USER": self.user,
                 "POSTGRES_PASSWORD": self.password,
-                "POSTGRES_MULTIPLE_DATABASES": ",".join(self.registered_dbs.keys()),
+                "POSTGRES_MULTIPLE_DATABASES": "",
             },
-            "image": self.image,
             "labels": ["fakts.service=live.arkitekt.postgres"],
         }
 
-        context.docker_compose.set_nested(f"services", self.host, db_service)
+
+        if self.build_repo or self.dev:
+            mount = init.get_service(MountService).register_mount(self.host, Repo(self.repo))
+            self.build_image["build"] = mount
+        else:
+            self.build_image["image"] = self.image
+
+            
+    def build(self, context: ExecutionContext):
+
+        self.build_image["environment"]["POSTGRES_MULTIPLE_DATABASES"] = ",".join(
+            self.registered_dbs.keys()
+        )
+        
+        context.docker_compose.set_nested(f"services", self.host, self.build_image)
 
     def get_options(self):
         with_postgres_password = Option(
@@ -80,5 +101,27 @@ class PostgresBlok(BaseModel):
             help="The image to use for the service",
             default=self.image,
         )
+        with_repo = Option(
+            subcommand="repo",
+            help="The repo to use for the service",
+            default=self.repo,
+        )
+        build_repo = Option(
+            subcommand="build_repo",
+            help="Should we build the repo?",
+            default=self.build_repo,
+        )
+
+        mount_repo = Option(
+            subcommand="mount_repo",
+            help="Should we mount the repo?",
+            default=self.mount_repo,
+        )
+
+        dev = Option(
+            subcommand="dev",
+            help="Should we run the service in development mode (includes withrepo, mountrepo)?",
+            default=self.dev,
+        )
 
-        return [with_postgres_password, skip_build, with_user_password, with_image]
+        return [with_postgres_password, skip_build, with_user_password, with_image, with_repo, build_repo, mount_repo, dev]

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/redis.py

@@ -9,7 +9,10 @@ from typing import Dict, Any, Optional
 from blok import blok, InitContext
 
 
-@blok(RedisService)
+@blok(
+    RedisService,
+    description="Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker",
+)
 class RedisBlok:
     def __init__(self) -> None:
         self.host = "redis"

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/rekuest.py

@@ -6,7 +6,7 @@ from blok.tree import Repo, YamlFile
 from arkitekt_next.bloks.base import BaseArkitektService
 
 
-@blok("live.arkitekt.rekuest")
+@blok("live.arkitekt.rekuest", description="Rekuest is the RPC and Functionaliy hub")
 class RekuestBlok(BaseArkitektService):
     def __init__(self) -> None:
         self.dev = False

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/secret.py

@@ -6,7 +6,7 @@ from arkitekt_next.bloks.services.secret import SecretService
 import secrets
 
 
-@blok(SecretService)
+@blok(SecretService, description="Preformed secrets that will not change")
 class SecretBlok:
     def __init__(self) -> None:
         self.preformed_secrets = [secrets.token_urlsafe(32) for _ in range(100)]

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/socket.py

@@ -10,7 +10,9 @@ class AdminCredentials(BaseModel):
     email: str
 
 
-@blok("live.arkitekt.docker_socket")
+@blok(
+    "live.arkitekt.docker_socket", description="Hosting the docker socket of the host"
+)
 class DockerSocketBlok:
     def __init__(self) -> None:
         self.docker_socket = "/var/run/docker.sock"

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/arkitekt_next/bloks/tailscale.py

@@ -7,7 +7,7 @@ from blok.bloks.services.dns import DnsService
 from blok.tree import YamlFile
 
 
-@blok("live.arkitekt.tailscale")
+@blok("live.arkitekt.tailscale", description="Tailscale is a zero config VPN")
 class TailscaleBlok:
     def __init__(self, name: str = "arkitekt") -> None:
         self.name = name

{arkitekt_next-0.7.54 → arkitekt_next-0.7.56}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arkitekt-next"
-version = "0.7.54"
+version = "0.7.56"
 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.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 }
+mikro-next = { version = ">=0.1.31", python = "^3.10", optional = true }
+kabinet = { version = ">=0.1.14", optional = true,  python = "^3.9" }
+fluss-next = { version = ">=0.1.76", optional = true }
+reaktion-next= { version = ">=0.1.66", python = "^3.8", optional = true }
+rekuest-next= { version = ">=0.2.21", python = "^3.8", optional = true }
+unlok-next= { version = ">=0.1.70", 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.15", python = "^3.8", optional = true }
+blok = { version = ">=0.0.19", 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 }