arkitekt-next 0.7.59__tar.gz → 0.8.0__tar.gz

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.59
+Version: 0.8.0
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -16,24 +16,24 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
 Provides-Extra: blok
 Provides-Extra: cli
-Requires-Dist: blok (>=0.0.19) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
+Requires-Dist: blok (>=0.0.19) ; (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 (>=0.1.21)
-Requires-Dist: fakts (>=0.5.0)
-Requires-Dist: fluss-next (>=0.1.78) ; extra == "all"
-Requires-Dist: herre (>=0.4.3)
-Requires-Dist: kabinet (>=0.1.16) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
-Requires-Dist: koil (>=0.3.6)
-Requires-Dist: lovekit (>=0.1.4) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
-Requires-Dist: mikro-next (>=0.1.33) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: dokker (>=1.0.0)
+Requires-Dist: fakts (>=1.0.0)
+Requires-Dist: fluss-next (>=0.1.83) ; extra == "all"
+Requires-Dist: herre (>=1.0.0)
+Requires-Dist: kabinet (>=0.1.22) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: koil (>=1.0.0)
+Requires-Dist: lovekit (>=0.1.10) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: mikro-next (>=0.1.38) ; (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.68) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.24) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: reaktion-next (>=0.1.73) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
+Requires-Dist: rekuest-next (>=0.2.29) ; (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.72) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: turms (>=0.6.0) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: unlok-next (>=0.1.77) ; 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
 
@@ -64,7 +64,7 @@ To understand the idea behind arkitekt_next, you need to understand the idea beh
 ## Install
 
 ```bash
-pip install arkitekt_next[all]
+pip install arkitekt-next[all]
 ```
 
 This installs all dependencies for the arkitekt_next platform, inlcuding the arkitekt_next CLI, which can be used to develop and create apps, containerize them and deploy t
@@ -81,7 +81,7 @@ type annotations, orchestration of real-time (in memoery) workflows, data hostin
 To get started create a directory and run
 
 ```bash
-arkitekt_next init
+arkitekt-next init
 ```
 
 Which will lead you throught an app creation process.
@@ -105,7 +105,7 @@ And then connected to a local or remote server by running
 Run example:
 
 ```bash
-arkitekt_next run dev
+arkitekt-next run dev
 ```
 
 

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/README.md

@@ -25,7 +25,7 @@ To understand the idea behind arkitekt_next, you need to understand the idea beh
 ## Install
 
 ```bash
-pip install arkitekt_next[all]
+pip install arkitekt-next[all]
 ```
 
 This installs all dependencies for the arkitekt_next platform, inlcuding the arkitekt_next CLI, which can be used to develop and create apps, containerize them and deploy t
@@ -42,7 +42,7 @@ type annotations, orchestration of real-time (in memoery) workflows, data hostin
 To get started create a directory and run
 
 ```bash
-arkitekt_next init
+arkitekt-next init
 ```
 
 Which will lead you throught an app creation process.
@@ -66,7 +66,7 @@ And then connected to a local or remote server by running
 Run example:
 
 ```bash
-arkitekt_next run dev
+arkitekt-next run dev
 ```
 
 

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/__init__.py

@@ -11,11 +11,21 @@ try:
     from rekuest_next.register import register
     from rekuest_next.agents.hooks import background
     from rekuest_next.agents.hooks import startup
+    from rekuest_next.agents.context import context
+    from rekuest_next.state.state import state
+    from rekuest_next.actors.reactive.api import progress, aprogress
+    from rekuest_next.actors.reactive.api import log, alog
 except ImportError as e:
     raise e
     register = missing_install("rekuest_next", e)
     background = missing_install("rekuest_next", e)
     startup = missing_install("rekuest_next", e)
+    context = missing_install("rekuest_next", e)
+    state = missing_install("rekuest_next", e)
+    progress = missing_install("rekuest_next", e)
+    aprogress = missing_install("rekuest_next", e)
+    log = missing_install("rekuest_next", e)
+    alog = missing_install("rekuest_next", e)
 
 from .builders import easy, interactive
 from .apps.types import App
@@ -38,6 +48,8 @@ __all__ = [
     "useInstanceID",
     "useUser",
     "next",
+    "state",
+    "context",
     "background",
     "startup",
     "register_next",

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/bloks/arkitekt.py

@@ -43,17 +43,7 @@ class ArkitektBlok:
         scale: Optional[TailscaleBlok] = None,
         orkestrator: Optional[OrkestratorBlok] = None,
     ):
-        print(
-            gateway,
-            mikro,
-            kabinet,
-            rekuest,
-            fluss,
-            gateway,
-            internal_engine,
-            scale,
-            orkestrator,
-        )
+        pass
 
     def build(self, cwd):
         pass

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/bloks/postgres.py

@@ -64,20 +64,20 @@ class PostgresBlok(BaseModel):
             "labels": ["fakts.service=live.arkitekt.postgres"],
         }
 
-
         if self.build_repo or self.dev:
-            mount = init.get_service(MountService).register_mount(self.host, Repo(self.repo))
+            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):
@@ -124,4 +124,13 @@ class PostgresBlok(BaseModel):
             default=self.dev,
         )
 
-        return [with_postgres_password, skip_build, with_user_password, with_image, with_repo, build_repo, mount_repo, dev]
+        return [
+            with_postgres_password,
+            skip_build,
+            with_user_password,
+            with_image,
+            with_repo,
+            build_repo,
+            mount_repo,
+            dev,
+        ]

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/builders.py

@@ -109,7 +109,6 @@ def easy(
         requirements=registry.get_requirements(),
     )
     if token:
-        print("Using token")
         fakts = build_arkitekt_next_token_fakts(
             manifest=manifest,
             token=token,
@@ -117,7 +116,6 @@ def easy(
         )
 
     elif redeem_token:
-        print("Using redeem token")
         fakts = build_arkitekt_next_redeem_fakts_next(
             manifest=manifest,
             redeem_token=redeem_token,
@@ -126,7 +124,6 @@ def easy(
             headless=headless,
         )
     else:
-        print("Using normal fakts")
         fakts = build_arkitekt_next_fakts_next(
             manifest=manifest,
             url=url,
@@ -160,8 +157,8 @@ def easy(
     return app
 
 
-
-def interactive(identifier: str,
+def interactive(
+    identifier: str,
     version: str = "0.0.1",
     logo: Optional[str] = None,
     scopes: Optional[List[str]] = None,
@@ -174,23 +171,26 @@ def interactive(identifier: str,
     app_kind: str = "development",
     registry: Optional[ServiceBuilderRegistry] = None,
     sync_mode: bool = True,
-    **kwargs):
+    **kwargs,
+):
     """Creates an interactive jupyter app"""
 
-    app =  easy(identifier=identifier,
-                version=version,
-                logo=logo,
-                scopes=scopes,
-                url=url,
-                headless=headless,
-                log_level=log_level,
-                token=token,
-                no_cache=no_cache,
-                redeem_token=redeem_token,
-                app_kind=app_kind,
-                registry=registry,
-                **kwargs)
-    
+    app = easy(
+        identifier=identifier,
+        version=version,
+        logo=logo,
+        scopes=scopes,
+        url=url,
+        headless=headless,
+        log_level=log_level,
+        token=token,
+        no_cache=no_cache,
+        redeem_token=redeem_token,
+        app_kind=app_kind,
+        registry=registry,
+        **kwargs,
+    )
+
     if sync_mode:
         # When running in an interactive async enironvment, just like
         # in a jupyter notebook, we can opt to run the app in sync mode

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/cli/commands/call/remote.py

@@ -3,7 +3,6 @@ from arkitekt_next.cli.options import *
 import asyncio
 from arkitekt_next.cli.ui import construct_run_panel
 from importlib import import_module
-from rekuest.postmans.utils import arkiuse
 import rich_click as click
 from arkitekt_next.cli.options import *
 import asyncio
@@ -19,12 +18,7 @@ async def call_app(
     arg,
 ):
     async with app:
-        async with arkiuse(
-            hash=hash,
-            postman=app.rekuest.postman,
-        ) as a:
-            print(arg)
-            print(await a.aassign(kwargs=arg))
+        raise NotImplementedError("This is not implemented yet")
 
 
 @click.command("prod")

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/cli/commands/kabinet/utils.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Optional
 import os
 import yaml
@@ -42,6 +43,6 @@ def validate_flavours(flavours_folder: str, only: Optional[str]):
                 )
 
         else:
-            print(
+            logging.info(
                 f"Found file {dir_name} in flavours folder. Not a valid flavour. Ignoring"
             )

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/cli/types.py

@@ -35,7 +35,7 @@ class Manifest(BaseModel):
     identifier: str
     version: str
     author: str
-    logo: Optional[str]
+    logo: Optional[str] = None
     entrypoint: str
     scopes: List[str]
     created_at: datetime.datetime = Field(default_factory=datetime.datetime.now)

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/model.py

@@ -85,7 +85,7 @@ class Manifest(BaseModel):
 
     def hash(self):
         """Hash the manifest"""
-        return sha256(self.json(sort_keys=True).encode()).hexdigest()
+        return sha256(self.model_dump_json().encode()).hexdigest()
 
 
 class User(BaseModel):

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/qt/__init__.py

@@ -9,7 +9,7 @@ to ArkitektNext, and configure settings.
 """
 
 from .magic_bar import MagicBar
-from .builders import publicqt
+from .builders import publicqt, devqt
 from .types import *
 
-__all__ = ["MagicBar", "publicqt", "QtApp"]
+__all__ = ["MagicBar", "publicqt", "devqt", "QtApp"]

arkitekt_next-0.8.0/arkitekt_next/qt/builders.py

@@ -0,0 +1,258 @@
+from arkitekt_next.apps.service.fakts_next import (
+    build_arkitekt_next_redeem_fakts_next,
+)
+from arkitekt_next.apps.service.fakts_qt import build_arkitekt_next_qt_fakts
+from arkitekt_next.apps.service.herre_qt import build_arkitekt_next_qt_herre
+from arkitekt_next.utils import create_arkitekt_next_folder
+from arkitekt_next.model import Manifest
+from arkitekt_next.apps.types import App
+from arkitekt_next.service_registry import (
+    ServiceBuilderRegistry,
+    check_and_import_services,
+)
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+from qtpy import QtWidgets, QtCore
+from typing import List, Optional
+import os
+import logging
+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,
+)
+from arkitekt_next.apps.service.herre import build_arkitekt_next_herre
+from arkitekt_next.utils import create_arkitekt_next_folder
+from arkitekt_next.model import Manifest
+from arkitekt_next.apps.types import App
+from arkitekt_next.service_registry import (
+    ServiceBuilderRegistry,
+    check_and_import_services,
+)
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+
+
+def devqt(
+    identifier: str,
+    version: str = "0.0.1",
+    logo: Optional[str] = None,
+    scopes: Optional[List[str]] = None,
+    url: str = DEFAULT_ARKITEKT_URL,
+    headless: bool = False,
+    log_level: str = "ERROR",
+    parent: Optional[QtWidgets.QWidget] = None,
+    token: Optional[str] = None,
+    no_cache: bool = False,
+    redeem_token: Optional[str] = None,
+    app_kind: str = "development",
+    registry: Optional[ServiceBuilderRegistry] = None,
+    **kwargs,
+) -> App:
+    """Creates a next app
+
+    A simple way to create an ArkitektNext Next app, ArkitektNext next apps are
+    development apps by default, as they will try to register themselves
+    with services that are not yet available in production (such as the
+    rekuest_next and mikro_next services). They represent the next generation
+    of ArkitektNext apps, and will be the default way to create ArkitektNext apps
+    in the future. From here be dragons.
+
+    A few things to note:
+        -   The Next builder closely mimics the easy builder, but will use the
+            next generation of services (such as rekuest_next and mikro_next)
+            and will therefore not be compatible with the current generation.
+
+        -  Next apps will try to establish themselves a "development" apps, by default
+            which means that they will be authenticated with the ArkitektNext server on
+            a per user basis. If you want to create a "desktop" app, which multiple users
+            can use, you should set the `app_kind` to "desktop" TODO: Currently not implemented (use next app for this)
+        -  The Next builder can also be used in plugin apps, and when provided with a fakts token
+           will be able to connect to the ArkitektNext server without any user interaction.
+
+
+    Parameters
+    ----------
+    identifier : str
+        The apps identifier (should be globally unique, see Manifest for more info)
+    version : str, optional
+        The version of the app, by default "0.0.1"
+    logo : str, optional
+        The logo of the app as a public http url, by default None
+    scopes : List[str], optional
+        The scopes, that this apps requires, will default to standard scopes, by default None
+    url : str, optional
+        The fakts server that will be used to configure this app, in a default ArkitektNext deployment this
+        is the address of the "Lok Service" (which provides the Fakts API), by default DEFAULT_ARKITEKT_URL
+        Will be overwritten by the FAKTS_URL environment variable
+    headless : bool, optional
+        Should we run in headless, mode, e.g printing necessary interaction into the console (will forexample
+        stop opening browser windows), by default False
+    log_level : str, optional
+        The log-level to use, by default "ERROR"
+    token : str, optional
+        A fakts token to use, by default None
+        Will be overwritten by the FAKTS_TOKEN environment variable
+    no_cache : bool, optional
+        Should we skip caching token, acess-token, by default False
+        Attention: If this is set to True, the app will always have to be configured
+        and authenticated.
+    instance_id : str, optional
+        The instance_id to use, by default "main"
+        Can be set to a different value, if you want to run multiple intstances
+        of the same app by the same user.
+        Will be overwritten by the REKUEST_INSTANCE_ID environment variable
+    register_reaktion : bool, optional
+        Should we register the reaktion extension, by default True
+        If set to False, the app will not be able to use the reaktion extension
+        (which is necessary for scheduling in app` workflows from fluss)
+    app_kind : str, optional
+        The kind of app to create, by default "development"
+        Can be set to "desktop" to create a desktop app, that can be used by multiple users.
+
+    Returns
+    -------
+    NextApp
+        A built app, that can be used to interact with the ArkitektNext server
+    """
+    registry = registry or check_and_import_services()
+
+    url = os.getenv("FAKTS_URL", url)
+    token = os.getenv("FAKTS_TOKEN", token)
+
+    manifest = Manifest(
+        version=version,
+        identifier=identifier,
+        scopes=scopes if scopes else ["openid"],
+        logo=logo,
+        requirements=registry.get_requirements(),
+    )
+    if token:
+        fakts = build_arkitekt_next_token_fakts(
+            manifest=manifest,
+            token=token,
+            url=url,
+        )
+
+    elif redeem_token:
+        fakts = build_arkitekt_next_redeem_fakts_next(
+            manifest=manifest,
+            redeem_token=redeem_token,
+            url=url,
+            no_cache=no_cache,
+            headless=headless,
+        )
+    else:
+        fakts = build_arkitekt_next_fakts_next(
+            manifest=manifest,
+            url=url,
+            no_cache=no_cache,
+            headless=headless,
+            client_kind=app_kind,
+        )
+
+    herre = build_arkitekt_next_herre(fakts=fakts)
+
+    params = kwargs
+
+    create_arkitekt_next_folder(with_cache=True)
+
+    try:
+        from rich.logging import RichHandler
+
+        logging.basicConfig(level=log_level, handlers=[RichHandler()])
+    except ImportError:
+        logging.basicConfig(level=log_level)
+
+    app = App(
+        fakts=fakts,
+        herre=herre,
+        manifest=manifest,
+        services=registry.build_service_map(
+            fakts=fakts, herre=herre, params=params, manifest=manifest
+        ),
+    )
+
+    app.enter()
+
+    return app
+
+
+def publicqt(
+    identifier: str,
+    version: str = "latest",
+    logo: Optional[str] = None,
+    scopes: Optional[List[str]] = None,
+    log_level: str = "ERROR",
+    registry: Optional[ServiceBuilderRegistry] = None,
+    parent: Optional[QtWidgets.QWidget] = None,
+    beacon_widget: Optional[QtWidgets.QWidget] = None,
+    login_widget: Optional[QtWidgets.QWidget] = None,
+    settings: Optional[QtCore.QSettings] = None,
+    **kwargs,
+) -> App:
+    """Public QtApp creation
+
+    A simple way to create an Arkitekt app with a public grant (allowing users to sign
+    in with the application ) utlizing a retrieve grant (necessating a previous configuration
+    of the application on the server side)
+
+    Args:
+        identifier (str): The apps identifier
+        version (str, optional): The apps verion. Defaults to "latest".
+        parent (QtWidget, optional): The QtParent (for the login and server select widget). Defaults to None.
+
+    Returns:
+        Arkitekt: The Arkitekt app
+    """
+
+    registry = registry or check_and_import_services()
+
+    settings = settings or QtCore.QSettings("arkitekt_next", f"{identifier}:{version}")
+
+    manifest = Manifest(
+        version=version,
+        identifier=identifier,
+        scopes=scopes if scopes else ["openid"],
+        logo=logo,
+        requirements=registry.get_requirements(),
+    )
+
+    fakts = build_arkitekt_next_qt_fakts(
+        manifest=manifest,
+        beacon_widget=beacon_widget,
+        parent=parent,
+        settings=settings,
+    )
+
+    herre = build_arkitekt_next_qt_herre(
+        manifest,
+        fakts=fakts,
+        login_widget=login_widget,
+        parent=parent,
+        settings=settings,
+    )
+
+    params = kwargs
+
+    try:
+        from rich.logging import RichHandler
+
+        logging.basicConfig(level=log_level, handlers=[RichHandler()])
+    except ImportError:
+        logging.basicConfig(level=log_level)
+
+    app = App(
+        fakts=fakts,
+        herre=herre,
+        manifest=manifest,
+        services=registry.build_service_map(
+            fakts=fakts, herre=herre, params=params, manifest=manifest
+        ),
+    )
+
+    app.enter()
+
+    return app

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/qt/magic_bar.py

@@ -63,7 +63,7 @@ class Logo(QtWidgets.QWidget):
                     data = await resp.read()
                     return data
                 else:
-                    print(f"Failed to download the image. Status code: {resp.status}")
+                    logger.error(f"Failed to download the image. Status code: {resp.status}")
                     return None
 
 

{arkitekt_next-0.7.59 → arkitekt_next-0.8.0}/arkitekt_next/service_registry.py

@@ -76,9 +76,9 @@ def check_and_import_services() -> ServiceBuilderRegistry:
                 rekuest_module.init_services(service_builder_registry)
                 logging.info(f"Called init_service function from {module_name}")
             else:
-                print(f"No init_services function in {module_name}.__arkitekt__")
+                logging.debug(f"No init_services function in {module_name}.__arkitekt__. Skipping.")
         except Exception as e:
-            print(f"Failed to call init_services for {module_name}: {e}")
+            logging.critical(f"Failed to call init_services for {module_name}: {e}")
             traceback.print_exc()
 
     # Check local modules in the current working directory