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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkitekt-next
-Version: 0.15.0
+Version: 0.17.0
 Summary: client for the arkitekt_next platform
 Author-email: jhnnsrs <jhnnsrs@gmail.com>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Requires-Dist: watchfiles>=1.0.5
 Provides-Extra: all
 Requires-Dist: fluss-next>=0.2.0; extra == 'all'
 Requires-Dist: kabinet>=0.2.0; extra == 'all'
-Requires-Dist: mikro-next>=0.4; extra == 'all'
+Requires-Dist: mikro-next>=0.6; extra == 'all'
 Requires-Dist: reaktion-next>=0.2.0; extra == 'all'
 Requires-Dist: rekuest-next>=0.7; extra == 'all'
 Requires-Dist: rich-click>=1.6.1; extra == 'all'
@@ -47,7 +47,7 @@ Requires-Dist: kraph>=0.2.0; extra == 'kraph'
 Provides-Extra: lovekit
 Requires-Dist: lovekit>=0.2.0; extra == 'lovekit'
 Provides-Extra: mikro
-Requires-Dist: mikro-next>=0.4.0; extra == 'mikro'
+Requires-Dist: mikro-next>=0.6.0; extra == 'mikro'
 Provides-Extra: reaktion
 Requires-Dist: reaktion-next>=0.2.0; extra == 'reaktion'
 Provides-Extra: unlok

{arkitekt_next-0.15.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.15.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.15.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.15.0 → arkitekt_next-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkitekt-next"
-version = "0.15.0"
+version = "0.17.0"
 description = "client for the arkitekt_next platform"
 authors = [{ name = "jhnnsrs", email = "jhnnsrs@gmail.com" }]
 requires-python = ">=3.11,<4"
@@ -25,7 +25,7 @@ cli = [
 ]
 alpaka = ["alpaka>=0.2.0"]
 kraph = ["kraph>=0.2.0"]
-mikro = ["mikro-next>=0.4.0"]
+mikro = ["mikro-next>=0.6.0"]
 kabinet = ["kabinet>=0.4.0"]
 elektro = ["elektro>=0.5.0"]
 fluss = ["fluss-next>=0.2.0"]
@@ -39,7 +39,7 @@ all = [
     "semver>=3.0.1",
     "reaktion-next>=0.2.0",
     "rekuest-next>=0.7",
-    "mikro-next>=0.4",
+    "mikro-next>=0.6",
     "kabinet>=0.2.0",
     "fluss-next>=0.2.0",
     "unlok-next>=1.1.1",
@@ -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.15.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.15.0/arkitekt_next/bloks/__init__.py

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

arkitekt_next-0.15.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.15.0/arkitekt_next/bloks/alpaka.py

@@ -1,136 +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.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())
-        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.15.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