arkitekt-next 0.12.2__py3-none-any.whl → 0.14.0__py3-none-any.whl

arkitekt_next/bloks/lovekit.py

@@ -0,0 +1,199 @@
+from dataclasses import asdict
+from typing import Dict, Any
+import secrets
+
+
+from arkitekt_next.bloks.services.admin import AdminService
+from arkitekt_next.bloks.services.channel import ChannelService
+from arkitekt_next.bloks.services.config import ConfigService
+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 LokService
+from arkitekt_next.bloks.services.mount import MountService
+from arkitekt_next.bloks.services.ollama import OllamaService
+from arkitekt_next.bloks.services.redis import RedisService
+from arkitekt_next.bloks.services.s3 import S3Service
+from arkitekt_next.bloks.services.secret import SecretService
+from blok import blok, InitContext, ExecutionContext, Option
+from blok.bloks.services.dns import DnsService
+from blok.tree import Repo, YamlFile
+from arkitekt_next.bloks.base import BaseArkitektService
+
+
+@blok("live.arkitekt.lovekit", description="Stream live video and audio with Arkitekt")
+class LovekitBlok:
+    def __init__(self) -> None:
+        self.dev = False
+        self.host = "lovekit"
+        self.command = "bash run-debug.sh"
+        self.repo = "https://github.com/arkitektio/lovekit-server"
+        self.scopes = {
+            "alpaka_pull": "Pull new Models",
+            "alpaka_chat": "Add repositories to the database",
+        }
+        self.mount_repo = False
+        self.build_repo = False
+        self.buckets = ["media"]
+        self.secret_key = secrets.token_hex(16)
+        self.image = "jhnnsrs/lovekit:nightly"
+
+    def preflight(
+        self,
+        lok: LokService,
+        db: DBService,
+        redis: RedisService,
+        s3: S3Service,
+        config: ConfigService,
+        livekit: LivekitService,
+        mount: MountService,
+        admin: AdminService,
+        secret: SecretService,
+        gateway: GatewayService,
+        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,
+    ):
+        lok.register_scopes(self.scopes)
+
+        path_name = self.host
+
+        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("live.arkitekt.alpaka", self.get_builder())
+
+        livekit_access = livekit.get_access()
+
+        django_secret = secret.retrieve_secret()
+
+        csrf_trusted_origins = []
+
+        configuration = YamlFile(
+            **{
+                "db": asdict(postgress_access),
+                "django": {
+                    "admin": asdict(admin_access),
+                    "debug": True,
+                    "hosts": ["*"],
+                    "secret_key": django_secret,
+                },
+                "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,
+                "livekit": {
+                    "host": livekit_access.host,
+                    "port": livekit_access.port,
+                    "api_key": livekit_access.api_key,
+                    "api_secret": livekit_access.api_secret,
+                },
+            }
+        )
+
+        config_mount = config.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 = mount.register_mount(self.host, Repo(repo))
+            service["volumes"].extend([f"{mount}:/workspace"])
+
+        if build_repo or dev:
+            mount = mount.register_mount(self.host, Repo(repo))
+            service["build"] = mount
+        else:
+            service["image"] = image
+
+        service["command"] = command
+
+        self.service = service
+
+    def get_builder(self):
+        return "arkitekt.generic"
+
+    def build(self, context: ExecutionContext):
+        context.docker_compose.set_nested("services", self.host, self.service)
+
+    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,
+            ),
+        ]

arkitekt_next/bloks/ollama.py

@@ -2,7 +2,7 @@ from typing import Dict, Any
 import secrets
 
 from arkitekt_next.bloks.services.gateway import GatewayService
-from arkitekt_next.bloks.services.ollama import OllamaService, OllamaCredentials
+from arkitekt_next.bloks.services.ollama import OllamaService, OllamaAccess
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 
@@ -16,15 +16,22 @@ class OllamaBlok:
         self.skip = False
         self.gpu = bool
 
-    def preflight(self, init: InitContext, gateway: GatewayService):
+    def get_access(self) -> OllamaAccess:
+        """Get the credentials for the Ollama service."""
+        return OllamaAccess(
+            api_key="",
+            api_secret="",
+            api_url=f"http://{self.host}:{self.port}",
+            dependency=self.host,
+        )
+
+    def preflight(self, init: InitContext):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
         if self.skip:
             return
 
-        gateway.expose_port_to(self.port, self.host, 11434, False)
-
         self.initialized = True
 
     def build(self, context: ExecutionContext):
@@ -84,6 +91,4 @@ class OllamaBlok:
         ]
 
     def __str__(self) -> str:
-        return (
-            f"Ollama(host={self.host}, command={self.command}, image={self.image})"
-        )
+        return f"Ollama(host={self.host}, command={self.command}, image={self.image})"

arkitekt_next/bloks/services/admin.py

@@ -13,10 +13,9 @@ class AdminCredentials:
 
 @service("live.arkitekt.admin")
 class AdminService(Protocol):
+    def retrieve(self) -> AdminCredentials:
+        """Retrieve the admin credentials.
 
-    def retrieve(self):
-        return AdminCredentials(
-            password=self.password,
-            username=self.username,
-            email=self.email,
-        )
+        Admin credentials should be used to access the admin interface of the application.
+
+        """

arkitekt_next/bloks/services/livekit.py

@@ -1,4 +1,6 @@
 from typing import Dict, Any, Protocol
+
+from cv2 import HOUGH_STANDARD
 from blok import blok, InitContext, Option
 from blok import service
 from dataclasses import dataclass
@@ -8,10 +10,11 @@ from dataclasses import dataclass
 class LivekitCredentials:
     api_key: str
     api_secret: str
-    api_url: str
+    host: str
+    port: int
+    dependency: str | None = None
 
 
 @service("io.livekit.livekit")
 class LivekitService(Protocol):
-
-    def retrieve_access(self) -> LivekitCredentials: ...
+    def get_access(self) -> LivekitCredentials: ...

arkitekt_next/bloks/services/ollama.py

@@ -1,16 +1,21 @@
-from typing import Dict, Any, Protocol
+from typing import Dict, Any, Optional, Protocol
 from blok import blok, InitContext, Option
 from blok import service
 from dataclasses import dataclass
 
 
 @dataclass
-class OllamaCredentials:
+class OllamaAccess:
     api_key: str
     api_secret: str
     api_url: str
+    dependency: Optional[str] = None
 
 
 @service("io.ollama.ollama", description=" A self-hosted ollama LLM server")
 class OllamaService(Protocol):
     pass
+
+    def get_access(self) -> OllamaAccess:
+        """Get the credentials for the ollama service."""
+        ...

arkitekt_next/bloks/services/secret.py

@@ -13,6 +13,4 @@ class AdminCredentials:
 
 @service("live.arkitekt.secrets")
 class SecretService(Protocol):
-
-    def retrieve_secret() -> str:
-        pass
+    def retrieve_secret(self) -> str: ...

arkitekt_next/builders.py

@@ -2,15 +2,14 @@ from typing import List, Optional
 import logging
 import os
 
-from arkitekt_next.apps.service.fakts_next import (
-    build_arkitekt_next_fakts_next,
-    build_arkitekt_next_redeem_fakts_next,
-    build_arkitekt_next_token_fakts_next,
+from arkitekt_next.app.fakts import (
+    build_device_code_fakts,
+    build_redeem_fakts,
+    build_token_fakts,
 )
-from arkitekt_next.apps.service.herre import build_arkitekt_next_herre_next
 from .utils import create_arkitekt_next_folder
-from .base_models import Manifest
-from .apps.protocols import App
+from fakts_next.models import Manifest
+from .app import App
 from .service_registry import ServiceBuilderRegistry, get_default_service_registry
 from .init_registry import InitHookRegistry, get_default_init_hook_registry
 from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
@@ -100,7 +99,6 @@ def easy(
     service_registry = service_registry or get_default_service_registry()
     init_hook_registry = init_hook_registry or get_default_init_hook_registry()
 
-
     if identifier is None:
         identifier = __file__.split("/")[-1].replace(".py", "")
 
@@ -115,32 +113,30 @@ def easy(
         requirements=service_registry.get_requirements(),
     )
 
-
     if token:
-        fakts_next = build_arkitekt_next_token_fakts_next(
+        fakts_next = build_token_fakts(
             manifest=manifest,
             token=token,
             url=url,
         )
 
     elif redeem_token:
-        fakts_next = build_arkitekt_next_redeem_fakts_next(
+        fakts_next = build_redeem_fakts(
             manifest=manifest,
             redeem_token=redeem_token,
             url=url,
         )
     else:
-        fakts_next = build_arkitekt_next_fakts_next(
+        fakts_next = build_device_code_fakts(
             manifest=manifest,
             url=url,
             no_cache=no_cache,
             headless=headless,
         )
 
-    herre_next = build_arkitekt_next_herre_next(fakts_next=fakts_next)
-
     params = {
-              "instance_id": instance_id,}
+        "instance_id": instance_id,
+    }
 
     create_arkitekt_next_folder(with_cache=True)
 
@@ -153,11 +149,7 @@ def easy(
 
     app = App(
         fakts=fakts_next,
-        herre=herre_next,
-        manifest=manifest,
-        services=service_registry.build_service_map(
-            fakts=fakts_next, herre=herre_next, params=params, manifest=manifest
-        ),
+        services=service_registry.build_service_map(fakts=fakts_next, params=params),
     )
 
     init_hook_registry.run_all(app)
@@ -176,7 +168,6 @@ def interactive(
     token: Optional[str] = None,
     no_cache: bool = False,
     redeem_token: Optional[str] = None,
-    app_kind: str = "development",
     registry: Optional[ServiceBuilderRegistry] = None,
     sync_mode: bool = True,
 ) -> App:
@@ -193,7 +184,7 @@ def interactive(
         token=token,
         no_cache=no_cache,
         redeem_token=redeem_token,
-     
+        service_registry=registry,
     )
 
     if sync_mode:
@@ -202,7 +193,8 @@ def interactive(
         # to avoid having to use await for every call. This is the default
         # behaviour for the app, but can be overwritten by setting
         # app.koil.sync_in_async = False
-        app._koil.sync_in_async = True
+        if app.__koil:
+            app.__koil.sync_in_async = True
         app.enter()
 
     return app

arkitekt_next/cli/commands/inspect/implementations.py

@@ -2,7 +2,7 @@ import asyncio
 from pydantic import BaseModel
 import rich_click as click
 from importlib import import_module
-from arkitekt_next.apps.protocols import App
+from arkitekt_next.app.app import App
 from arkitekt_next.cli.commands.run.utils import import_builder
 from arkitekt_next.cli.vars import get_console, get_manifest
 from arkitekt_next.cli.options import with_builder

arkitekt_next/cli/commands/inspect/requirements.py

@@ -1,7 +1,7 @@
 from arkitekt_next import get_default_service_registry
 import rich_click as click
 from importlib import import_module
-from arkitekt_next.apps.protocols import App
+from arkitekt_next.app.app import App
 from arkitekt_next.cli.commands.run.utils import import_builder
 from arkitekt_next.cli.vars import get_console, get_manifest
 from arkitekt_next.cli.options import with_builder

arkitekt_next/cli/commands/kabinet/build.py

@@ -13,7 +13,6 @@ from .types import Flavour, InspectionInput
 import yaml
 from typing import Dict, List, Optional
 import json
-from arkitekt_next.base_models import Requirement
 from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
 from arkitekt_next.utils import create_arkitekt_next_folder
 from rekuest_next.api.schema import ImplementationInput

arkitekt_next/cli/commands/kabinet/types.py

@@ -1,11 +1,8 @@
-from importlib.metadata import version
 from pydantic import BaseModel, Field, field_validator
 import datetime
-from typing import List, Optional, Union, Literal, Dict
+from typing import List, Optional
 from enum import Enum
-import semver
-import uuid
-from arkitekt_next.base_models import Requirement
+
 from string import Formatter
 import os
 
@@ -31,6 +28,7 @@ class SelectorType(str, Enum):
 
 
 class Flavour(BaseModel):
+    """ Flavour is a pydantic model that represents a flavour of an app image"""
     selectors: List[SelectorInput]
     description: str = Field(default="")
     dockerfile: str = Field(default="Dockerfile")

arkitekt_next/cli/commands/run/dev.py

@@ -17,7 +17,7 @@ from typing import MutableSet, Tuple, Any, Set
 from arkitekt_next.cli.ui import construct_changes_group, construct_app_group
 from arkitekt_next.cli.commands.run.utils import import_builder
 from arkitekt_next.cli.types import Manifest
-from arkitekt_next.apps.protocols import App
+from arkitekt_next.app.app import App
 import rich_click as click
 from arkitekt_next.cli.options import (
     with_fakts_next_url,
@@ -168,8 +168,6 @@ def is_entrypoint_change(
     return False
 
 
-
-
 def callback(console: Console, future: asyncio.Task[None]):
     if future.cancelled():
         return
@@ -186,22 +184,14 @@ def callback(console: Console, future: asyncio.Task[None]):
                 raise has_exception
             except Exception:
                 console.print_exception()
-                panel = Panel(
-                    "Error running App", style="bold red", border_style="red"
-                )
+                panel = Panel("Error running App", style="bold red", border_style="red")
                 console.print(panel)
 
 
-
-
-
-
-
-
 async def run_dev(
     console: Console,
     manifest: Manifest,
-    version: str | None =None,
+    version: str | None = None,
     builder: str = "arkitekt_next.builders.easy",
     deep: bool = False,
     **builder_kwargs,
@@ -242,10 +232,8 @@ async def run_dev(
         console.print(panel)
         module = None
 
-    
-    
-    current_run: asyncio.Future[None] | None = None    
-    # This is the main task that is running the app    
+    current_run: asyncio.Future[None] | None = None
+    # This is the main task that is running the app
 
     try:
         app: App = builder_func(
@@ -266,8 +254,6 @@ async def run_dev(
             "Error building initial App", style="bold red", border_style="red"
         )
         console.print(panel)
-        
-        
 
     async for changes in awatch(
         ".",
@@ -276,7 +262,7 @@ async def run_dev(
         step=500,
     ):
         if deep:
-            # 
+            #
             to_be_reloaded = check_deeps(changes)
             if not to_be_reloaded:
                 continue
@@ -315,8 +301,6 @@ async def run_dev(
                     if deep:
                         reload_modules(to_be_reloaded)
                     else:
-         
-         
                         reload(module)
         except Exception:
             console.print_exception()

arkitekt_next/cli/commands/run/utils.py

@@ -1,23 +1,23 @@
 from importlib import import_module
 from typing import Callable
-from arkitekt_next.apps.protocols import App
+from arkitekt_next.app.app import App
 
 
 def import_builder(builder: str) -> Callable[..., App]:
-    """ Import a builder function from a module.
-    
+    """Import a builder function from a module.
+
     Parameters
     ----------
     builder : str
         The builder function to import, in the format "module.function".
-        
+
     Returns
     -------
     Callable[..., App]
         The imported builder function.
-    
+
     """
-    
+
     module_path, function_name = builder.rsplit(".", 1)
     module = import_module(module_path)
     function = getattr(module, function_name)

arkitekt_next/cli/types.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union, Literal, Dict
 from enum import Enum
 import semver
 import uuid
-from arkitekt_next.base_models import Requirement
+from fakts_next.models import Requirement
 from string import Formatter
 import os
 
@@ -39,4 +39,3 @@ class Manifest(BaseModel):
             "logo": self.logo,
             "scopes": self.scopes,
         }
-

arkitekt_next/cli/ui.py

@@ -1,7 +1,7 @@
 from rich.console import Group
 from rich.tree import Tree
 from rich.panel import Panel
-from arkitekt_next.apps import App
+from arkitekt_next.app import App
 from typing import MutableSet, Tuple, Any, Dict
 import os
 from .texts import LOGO, WELCOME_MESSAGE
@@ -59,7 +59,7 @@ def construct_app_group(app: App) -> Group:
     Group
         A rich panel group
     """
-    panel_header = f"Running App \n\n{app.manifest.identifier}:{app.manifest.version}\n"
+    panel_header = f"Running App \n\n{app.fakts.manifest.identifier}:{app.fakts.manifest.version}\n"
 
     actor_tree = Tree("Registered Definitions", style="white not bold")
     service_tree = Tree("Depends on services", style="white not bold")

arkitekt_next/cli/utils.py

@@ -1,6 +1,6 @@
 from importlib import import_module
 from typing import Callable
-from arkitekt_next.apps.protocols import App
+from arkitekt_next.app.app import App
 import os