arkitekt-next 0.16.0__tar.gz → 0.17.0__tar.gz

{arkitekt_next-0.16.0 → arkitekt_next-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkitekt-next
-Version: 0.16.0
+Version: 0.17.0
 Summary: client for the arkitekt_next platform
 Author-email: jhnnsrs <jhnnsrs@gmail.com>
 License-Expression: MIT

{arkitekt_next-0.16.0 → arkitekt_next-0.17.0}/arkitekt_next/app/fakts.py

@@ -20,6 +20,15 @@ def build_device_code_fakts(
     no_cache: bool = False,
     headless: bool = False,
 ) -> Fakts:
+    """ Builds a Fakts instance for device code authentication.
+    
+    This is used when the user wants to authenticate an application
+    using a device code. The user will be prompted to open a browser
+    and enter a code to authenticate the application.
+    
+    
+    
+    """
     identifier = manifest.identifier
     version = manifest.version
     if url is None:
@@ -46,6 +55,15 @@ def build_device_code_fakts(
 
 
 def build_redeem_fakts(manifest: Manifest, redeem_token: str, url: str) -> Fakts:
+    """ Builds a Fakts instance for redeeming a token.
+    
+    A redeem token is used to register an application with the
+    fakts server, and to claim the configuration for the application.
+    
+    Instead of using a device code, the user can redeem an application
+    without user interaction.
+    
+    """
     identifier = manifest.identifier
     version = manifest.version
 
@@ -67,7 +85,15 @@ def build_token_fakts(
     manifest: Manifest,
     token: str,
     url: str,
-):
+) -> Fakts:
+    """ Builds a Fakts instance for token-based authentication.
+    
+    This is used when an appllication was previously authenticated
+    and the user has a (claim) token to use for authentication.
+    
+    E.g. when deploying an application through the kabinet deployer
+    
+    """
     identifier = manifest.identifier
     version = manifest.version
 

{arkitekt_next-0.16.0 → arkitekt_next-0.17.0}/arkitekt_next/cli/commands/call/local.py

@@ -1,4 +1,4 @@
-
+""" Calls a function in a local app, without needing to use rekuest or fakts."""
 from click import Context
 import rich_click as click
 from arkitekt_next.cli.options import *

arkitekt_next-0.17.0/arkitekt_next/cli/commands/call/main.py

@@ -0,0 +1,28 @@
+""" Calling functions in your arkitekt_next app"""
+
+from click import Context
+import rich_click as click
+
+
+from .remote import remote
+
+
+@click.group()
+@click.pass_context
+def call(ctx: Context) -> None:
+    """Call functions in your arkitekt_next app.
+    
+    This command allows you to call functions in your app 
+    either locally or remotely.
+    
+    Locally, you can call functions that are defined in your app
+    without needing to use rekuest or fakts. (No Server for assignment needed)
+    
+    Remotely, you can call functions that are defined in your app
+    using rekuest or fakts. This goes through a rekuest server to
+    remote call the function.
+    
+    """
+
+
+call.add_command(remote, "remote")

arkitekt_next-0.17.0/arkitekt_next/cli/templates/filter.py

@@ -0,0 +1,26 @@
+from arkitekt_next import register
+from mikro_next.api.schema import Image, from_array_like, PartialDerivedViewInput
+
+
+@register
+def max_intensity_projection(image: Image) -> Image:
+    """Z-Project the Maximum Intensity
+
+    This function projects the maximum intensity of the input image
+    along the z-axis
+
+    Parameters
+    ----------
+    image : Image
+        The input image
+
+    Returns
+    -------
+    Image
+        The projected image
+
+    """
+    image_data = image.data.max(dim="z")
+    return from_array_like(
+        image_data, name="Max Intensity Projection" + image.name, derived_views=[PartialDerivedViewInput(originImage=image)]
+    )

{arkitekt_next-0.16.0 → arkitekt_next-0.17.0}/arkitekt_next/cli/templates/simple.py

@@ -1,9 +1,12 @@
+""" An example of a simple template for Arkitekt Next"""
+
 from arkitekt_next import register
 import time
+from typing import Generator
 
 
 @register
-def generate_n_string(n: int = 10, timeout: int = 2) -> str:
+def generate_n_string(n: int = 10, timeout: int = 2) -> Generator[str, None, None]:
     """Generate N Strings
 
     This function generates {{n}} strings with a {{timeout}} ms timeout between each string

{arkitekt_next-0.16.0 → arkitekt_next-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkitekt-next"
-version = "0.16.0"
+version = "0.17.0"
 description = "client for the arkitekt_next platform"
 authors = [{ name = "jhnnsrs", email = "jhnnsrs@gmail.com" }]
 requires-python = ">=3.11,<4"
@@ -65,6 +65,7 @@ dev-dependencies = [
     "rich-click>=1.8",
     "mikro-next>=0.3.1",
     "python-semantic-release>=9.21.1",
+    "qtpy>=2.4.3",
 ]
 
 [tool.hatch.build.targets.sdist]

arkitekt_next-0.16.0/arkitekt_next/__blok__.py

@@ -1,58 +0,0 @@
-from arkitekt_next.bloks.admin import AdminBlok
-from arkitekt_next.bloks.arkitekt import ArkitektBlok
-from arkitekt_next.bloks.mikro import MikroBlok
-from arkitekt_next.bloks.fluss import FlussBlok
-from arkitekt_next.bloks.orkestrator import OrkestratorBlok
-from arkitekt_next.bloks.redis import RedisBlok
-from arkitekt_next.bloks.gateway import CaddyBlok
-from arkitekt_next.bloks.livekit import LocalLiveKitBlok
-from arkitekt_next.bloks.postgres import PostgresBlok
-from arkitekt_next.bloks.minio import MinioBlok
-from arkitekt_next.bloks.kabinet import KabinetBlok
-from arkitekt_next.bloks.lok import LokBlok
-from arkitekt_next.bloks.alpaka import AlpakaBlok
-from arkitekt_next.bloks.lovekit import LovekitBlok
-from arkitekt_next.bloks.config import ConfigBlok
-from arkitekt_next.bloks.mount import MountBlok
-from arkitekt_next.bloks.internal_docker import InternalDockerBlok
-from arkitekt_next.bloks.socket import DockerSocketBlok
-from arkitekt_next.bloks.rekuest import RekuestBlok
-from arkitekt_next.bloks.tailscale import TailscaleBlok
-from arkitekt_next.bloks.secret import SecretBlok
-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.elektro import ElektroBlok
-from blok.blok import Blok
-
-
-def get_bloks() -> list[Blok]:
-    return [
-        AdminBlok(),
-        ArkitektBlok(),
-        MikroBlok(),
-        FlussBlok(),
-        RedisBlok(),
-        CaddyBlok(),
-        AlpakaBlok(),
-        LovekitBlok(),
-        LocalLiveKitBlok(),
-        PostgresBlok(),
-        MinioBlok(),
-        OllamaBlok(),
-        LokBlok(),
-        SelfSignedBlok(),
-        KabinetBlok(),
-        MountBlok(),
-        ConfigBlok(),
-        KraphBlok(),
-        InternalDockerBlok(),
-        DockerSocketBlok(),
-        RekuestBlok(),
-        TailscaleBlok(),
-        SecretBlok(),
-        PreformedNamesBlok(),
-        OrkestratorBlok(),
-        ElektroBlok(),
-    ]

arkitekt_next-0.16.0/arkitekt_next/bloks/__init__.py

@@ -1 +0,0 @@
-from .admin import AdminBlok

arkitekt_next-0.16.0/arkitekt_next/bloks/admin.py

@@ -1,43 +0,0 @@
-from blok import blok, InitContext, Option
-from arkitekt_next.bloks.services.admin import AdminService, AdminCredentials
-
-
-@blok(AdminService, description="Admin credentials for the application")
-class AdminBlok:
-    def __init__(self) -> None:
-        self.password = "admin"
-        self.username = "admin"
-        self.email = "admin@admin.com"
-
-    def preflight(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-    def retrieve(self):
-        return AdminCredentials(
-            password=self.password,
-            username=self.username,
-            email=self.email,
-        )
-
-    def get_options(self):
-        with_username = Option(
-            subcommand="username",
-            help="Which admin username to use",
-            default=self.username,
-            show_default=True,
-        )
-        with_username = Option(
-            subcommand="password",
-            help="Which password to use",
-            default=self.password,
-            show_default=True,
-        )
-        with_email = Option(
-            subcommand="password",
-            help="Which password to use",
-            default=self.password,
-            show_default=True,
-        )
-
-        return [with_username, with_username, with_email]

arkitekt_next-0.16.0/arkitekt_next/bloks/alpaka.py

@@ -1,139 +0,0 @@
-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.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.alpaka", description="a container and app management service")
-class AlpakaBlok(BaseArkitektService):
-    def get_builder(self):
-        return "arkitekt.generic"
-
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "alpaka"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/arkitektio/alpaka-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/alpaka:nightly"
-
-    def preflight(
-        self,
-        lok: LokService,
-        db: DBService,
-        redis: RedisService,
-        s3: S3Service,
-        config: ConfigService,
-        ollama: OllamaService,
-        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_path = gateway.expose_service(path_name, 80, self.host)
-        lok.register_service_on_subpath(
-            self.get_blok_meta().service_identifier, gateway_path, "ht"
-        )
-
-        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())
-        ollama_access = ollama.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,
-                **self.get_additional_config(),
-            }
-        )
-
-        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)
-
-        if ollama_access.dependency:
-            depends_on.append(ollama_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

arkitekt_next-0.16.0/arkitekt_next/bloks/arkitekt.py

@@ -1,55 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-from arkitekt_next.bloks.kraph import KraphBlok
-from arkitekt_next.bloks.lok import LokBlok
-from arkitekt_next.bloks.tailscale import TailscaleBlok
-from blok import InitContext, Panel, Renderer, blok
-
-from .fluss import FlussBlok
-from .internal_docker import InternalDockerBlok
-from .kabinet import KabinetBlok
-from .mikro import MikroBlok
-from .orkestrator import OrkestratorBlok
-from .rekuest import RekuestBlok
-from .ollama import OllamaBlok
-from .elektro import ElektroBlok
-from .alpaka import AlpakaBlok
-from .lovekit import LovekitBlok
-
-
-class AdminCredentials(BaseModel):
-    password: str
-    username: str
-    email: str
-
-
-@blok(
-    "live.arkitekt",
-    dependencies=[
-        LokBlok.as_dependency(True, True),
-        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),
-        KraphBlok.as_dependency(True, True),
-        AlpakaBlok.as_dependency(True, True),
-        ElektroBlok.as_dependency(True, True),
-        LovekitBlok.as_dependency(True, True),
-    ],
-)
-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. You can use this to setup a full stack application with the following services""",
-                expand=False,
-                title="Welcome to Arkitekt!",
-                style="bold magenta",
-            )
-        )
-
-    def build(self, cwd):
-        pass

arkitekt_next-0.16.0/arkitekt_next/bloks/base.py

@@ -1,217 +0,0 @@
-from arkitekt_next.bloks.services.channel import ChannelService
-from blok import blok, InitContext, Option
-from blok.tree import YamlFile, Repo
-from typing import Any, Optional, 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,
-        db: DBService,
-        redis: RedisService,
-        s3: S3Service,
-        config: ConfigService,
-        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,
-    ):
-        deps = init.dependencies
-
-        lok.register_scopes(self.scopes)
-
-        path_name = 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)
-
-        self.service_identifier = self.get_blok_meta().service_identifier
-
-        gateway_path = gateway.expose_service(
-            path_name, 80, self.host, strip_prefix=False
-        )
-
-        lok_labels = lok.register_service_on_subpath(
-            self.service_identifier, gateway_path, "ht"
-        )
-
-        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,
-                **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 = {
-            "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(),
-        ]