arkitekt-next 0.23.0__tar.gz → 0.25.0__tar.gz

{arkitekt_next-0.23.0 → arkitekt_next-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkitekt-next
-Version: 0.23.0
+Version: 0.25.0
 Summary: client for the arkitekt_next platform
 Author-email: jhnnsrs <jhnnsrs@gmail.com>
 License-Expression: MIT
@@ -8,14 +8,14 @@ License-File: LICENSE
 Requires-Python: <4,>=3.11
 Requires-Dist: click>=8.2.0
 Requires-Dist: dokker>=2.3.0
-Requires-Dist: fakts-next>=2.1.0
+Requires-Dist: fakts-next>=2.2.0
 Requires-Dist: kabinet>=0.7.0
-Requires-Dist: koil>=2.0.4
-Requires-Dist: rath>=3.6.0
-Requires-Dist: rekuest-next>=0.13.1
+Requires-Dist: koil>=2.0.5
+Requires-Dist: rath>=3.7.0
+Requires-Dist: rekuest-next>=0.15.0
 Requires-Dist: rich-click>=1.8.8
 Requires-Dist: semver>=3.0.4
-Requires-Dist: turms>=0.9.2
+Requires-Dist: turms>=0.10.0
 Requires-Dist: watchfiles>=1.0.5
 Provides-Extra: all
 Requires-Dist: fluss-next>=0.2.0; extra == 'all'

arkitekt_next-0.25.0/arkitekt_next/pytest/__init__.py

@@ -0,0 +1 @@
+from .fixtures import *

arkitekt_next-0.25.0/arkitekt_next/pytest/fixtures.py

@@ -0,0 +1,86 @@
+from typing import Generator
+import pytest
+from arkitekt_next.cli.main import cli
+from click.testing import CliRunner
+from arkitekt_server.create import temp_server, ArkitektServerConfig
+from dokker import Deployment
+from dataclasses import dataclass
+from arkitekt_next.app import App
+from fakts_next.grants.remote import FaktsEndpoint
+from arkitekt_next import easy
+from dokker import local
+
+from arkitekt_next.service_registry import get_default_service_registry
+import pytest
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register custom command line options for pytest."""
+    parser.addoption(
+        "--test-against",
+        action="store",
+        default="temp",
+        help="Base URL of the Arkitekt server to use in tests",
+    )
+
+
+@pytest.fixture(scope="session")
+def running_server(request: pytest.FixtureRequest) -> Generator[Deployment, None, None]:
+    """ Generates a local Arkitekt server deployment for testing purposes. """
+    
+    if not request.config.getoption("--test-against") == "temp":
+        raise ValueError("Invalid test environment specified. Currently only 'temp' is supported.")
+
+    config = ArkitektServerConfig()
+
+    with temp_server() as temp_path:
+        
+        setup = local(temp_path / "docker-compose.yaml")
+        
+        setup.add_health_check(
+            url=lambda spec: f"http://localhost:{spec.find_service('gateway').get_port_for_internal(80).published}/lok/ht",
+            service="lok",
+            timeout=5,
+            max_retries=10,
+        )
+        with setup as setup:
+            setup.down()
+            
+            
+            setup.up()
+            
+            setup.check_health()
+            yield setup
+            setup.down()
+ 
+ 
+ 
+@dataclass
+class EasyApp:
+    """Dataclass to hold the Arkitekt server deployment."""
+    deployment: Deployment
+    app: App         
+            
+
+@pytest.fixture(scope="session")
+def test_app(running_server: Deployment) -> Generator[EasyApp, None, None]:
+    """Fixture to ensure the Arkitekt server is running."""
+    
+    async def device_code_hook(endpoint: FaktsEndpoint, device_code: str):
+        
+        await running_server.arun(
+            "lok", f"uv run python manage.py validatecode {device_code} --user demo --org arkitektio"
+        )
+        
+        
+    registry = get_default_service_registry()
+        
+    assert registry, "Service registry must be initialized"    
+        
+
+
+    with easy(url=f"http://localhost:{running_server.spec.find_service('gateway').get_port_for_internal(80).published}", device_code_hook=device_code_hook) as app:
+        
+        yield EasyApp(
+            deployment=running_server,
+            app=app
+        )

{arkitekt_next-0.23.0 → arkitekt_next-0.25.0}/arkitekt_next/qt/builders.py

@@ -1,38 +1,41 @@
+import logging
+import os
+from typing import List, Optional
+
+from qtpy import QtWidgets, QtCore
+
 from arkitekt_next.app.fakts import (
     build_device_code_fakts,
     build_redeem_fakts,
     build_token_fakts,
 )
-from arkitekt_next.utils import create_arkitekt_next_folder
-from fakts_next.models import Manifest
+from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
+from arkitekt_next.init_registry import InitHookRegistry, get_default_init_hook_registry
+from arkitekt_next.qt.types import QtApp
 from arkitekt_next.service_registry import (
     ServiceBuilderRegistry,
     get_default_service_registry,
 )
-from arkitekt_next.constants import DEFAULT_ARKITEKT_URL
-from qtpy import QtWidgets, QtCore
-from typing import List, Optional
-import os
-import logging
-from arkitekt_next.qt.types import QtApp
+from arkitekt_next.utils import create_arkitekt_next_folder
+from fakts_next.models import Manifest
 
 
 def qt(
-    identifier: str,
+    identifier: str | None = None,
     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,
+    parent: Optional[QtCore.QObject] = None,
     token: Optional[str] = None,
     no_cache: bool = False,
     redeem_token: Optional[str] = None,
     app_kind: str = "development",
-    registry: Optional[ServiceBuilderRegistry] = None,
+    service_registry: Optional[ServiceBuilderRegistry] = None,
     description: Optional[str] = None,
-    **kwargs,
+    instance_id: str = "main",
+    init_hook_registry: Optional[InitHookRegistry] = None,
 ) -> QtApp:
     """Creates a next app
 
@@ -100,7 +103,11 @@ def qt(
     NextApp
         A built app, that can be used to interact with the ArkitektNext server
     """
-    registry = registry or get_default_service_registry()
+    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", "")
 
     url = os.getenv("FAKTS_URL", url)
     token = os.getenv("FAKTS_TOKEN", token)
@@ -110,9 +117,9 @@ def qt(
         identifier=identifier,
         scopes=scopes if scopes else ["openid"],
         logo=logo,
-        requirements=registry.get_requirements(),
-        description=description,
+        requirements=service_registry.get_requirements(),
     )
+
     if token:
         fakts_next = build_token_fakts(
             manifest=manifest,
@@ -122,16 +129,21 @@ def qt(
 
     elif redeem_token:
         fakts_next = build_redeem_fakts(
-            manifest=manifest, redeem_token=redeem_token, url=url
+            manifest=manifest,
+            redeem_token=redeem_token,
+            url=url,
         )
     else:
         fakts_next = build_device_code_fakts(
             manifest=manifest,
             url=url,
             no_cache=no_cache,
+            headless=False,
         )
 
-    params = kwargs
+    params = {
+        "instance_id": instance_id,
+    }
 
     create_arkitekt_next_folder(with_cache=True)
 
@@ -143,10 +155,13 @@ def qt(
         logging.basicConfig(level=log_level)
 
     app = QtApp(
+        parent=parent,
         fakts=fakts_next,
-        services=registry.build_service_map(fakts=fakts_next, params=params),
+        services=service_registry.build_service_map(fakts=fakts_next, params=params),
     )
 
+    init_hook_registry.run_all(app)
+
     app.enter()
 
     return app

{arkitekt_next-0.23.0 → arkitekt_next-0.25.0}/arkitekt_next/qt/types.py

@@ -1,26 +1,20 @@
 from arkitekt_next.app.app import App
-from typing import List, Callable, Dict, Any
+from typing import Callable, TypeVar, ParamSpec, Any, Optional, Type
+from types import TracebackType
+from koil.qt import async_to_qt
+from koil import run_spawned
+from qtpy import QtCore
+
+R = TypeVar("R")
+P = ParamSpec("P")
 
 
 class QtApp(App):
     """An app that is built with the easy builder"""
 
-    hooks: Dict[str, List[Callable]] = {
-        "on_start": [],
-        "on_stop": [],
-        "on_error": [],
-        "on_message": [],
-        "on_warning": [],
-        "on_info": [],
-        "on_debug": [],
-        "on_enter": [],
-    }
-
-    def register_hook(self, hook_name: str, hook: Callable):
-        """Register a hook"""
-        self.hooks[hook_name].append(hook)
-
-    def register(self, *args, **kwargs):
+    parent: QtCore.QObject
+
+    def register(self, *args: Any, **kwargs: Any) -> None:
         """Register a function with the app (not in the Qt event loop)
 
         This is useful for functions that do not need access to the Qt event loop
@@ -31,7 +25,7 @@ class QtApp(App):
         """
         self.services["rekuest"].register(*args, **kwargs)
 
-    def register_in_qt_loop(self, function: Callable, **kwargs):
+    def register_in_qt_loop(self, function: Callable[..., Any], **kwargs: Any):
         """Register a function in the Qt event loop
 
         This is useful for functions that need to be resolved in the Qt event loop and are
@@ -40,13 +34,13 @@ class QtApp(App):
 
         """
 
-        from rekuest_next.qt.builders import qtinloopactifier
+        from rekuest_next.qt.builders import qtinloopactifier  # type: ignore
 
         return self.services["rekuest"].register(
             function, actifier=qtinloopactifier, **kwargs
         )
 
-    def register_with_qt_future(self, function: Callable, **kwargs):
+    def register_with_qt_future(self, function: Callable[..., Any], **kwargs: Any):
         """Register a function with a future that can be resolved in the Qt event loop
 
         This is useful for functions that need to be resolved in the Qt event loop, but
@@ -90,19 +84,27 @@ class QtApp(App):
 
 
         """
-        from rekuest_next.qt.builders import qtwithfutureactifier
+        from rekuest_next.qt.builders import qtwithfutureactifier  # type: ignore
 
         return self.services["rekuest"].register(
             function, actifier=qtwithfutureactifier, **kwargs
         )
 
-    def register_with_qt_generator(self, function: Callable, **kwargs):
-        from rekuest_next.qt.builders import qtwithgeneratoractifier
+    def register_with_qt_generator(self, function: Callable[..., Any], **kwargs: Any):
+        from rekuest_next.qt.builders import qtwithgeneratoractifier  # type: ignore
 
         return self.services["rekuest"].register(
             function, actifier=qtwithgeneratoractifier, **kwargs
         )
 
+    def wrap(self, function: Callable[P, R]) -> async_to_qt[R, P]:
+        """ """
+
+        async def wrappable(*args: P.args, **kwargs: P.kwargs) -> R:
+            return await run_spawned(function, *args, **kwargs)
+
+        return async_to_qt(wrappable, parent=self.parent)
+
     def run(self):
         """Run the app"""
         self.services["rekuest"].run()
@@ -114,6 +116,11 @@ class QtApp(App):
 
         return self
 
-    async def __aexit__(self, exc_type, exc_value, traceback):
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
         for service in self.services.values():
             await service.__aexit__(exc_type, exc_value, traceback)

{arkitekt_next-0.23.0 → arkitekt_next-0.25.0}/pyproject.toml

@@ -1,23 +1,23 @@
 [project]
 name = "arkitekt-next"
-version = "0.23.0"
+version = "0.25.0"
 description = "client for the arkitekt_next platform"
 authors = [{ name = "jhnnsrs", email = "jhnnsrs@gmail.com" }]
 requires-python = ">=3.11,<4"
 readme = "README.md"
 license = "MIT"
 dependencies = [
-    "fakts-next>=2.1.0",
+    "fakts-next>=2.2.0",
     "dokker>=2.3.0",
-    "koil>=2.0.4",
-    "rath>=3.6.0",
+    "koil>=2.0.5",
+    "rath>=3.7.0",
     "click>=8.2.0",
-    "rekuest-next>=0.13.1",
+    "rekuest-next>=0.15.0",
     "kabinet>=0.7.0",
     "semver>=3.0.4",
     "rich-click>=1.8.8",
     "watchfiles>=1.0.5",
-    "turms>=0.9.2",
+    "turms>=0.10.0",
 ]
 
 [project.optional-dependencies]
@@ -56,6 +56,9 @@ blok = [
 [project.scripts]
 arkitekt-next = "arkitekt_next.cli.main:cli"
 
+[project.entry-points.pytest11]
+arkitekt_next = "arkitekt_next.pytest"
+
 [tool.uv]
 dev-dependencies = [
     "autoflake>=1.7.7,<2",
@@ -64,7 +67,7 @@ dev-dependencies = [
     "pytest-cov>=4.0.0,<5",
     "pytest-aiohttp>=1.0.4,<2",
     "rich-click>=1.8",
-    "mikro-next>=0.12.0",
+    "mikro-next>=0.13.0",
     "python-semantic-release>=9.21.1",
     "qtpy>=2.4.3",
     "arkitekt-server>=1.3",
@@ -73,11 +76,11 @@ dev-dependencies = [
     "rekuest-next>=0.13.1",
     "kabinet>=0.6.0",
     "alpaka>=0.4.0",
-    "kraph>=0.3.0",
+    "kraph>=0.4.0",
     "fluss-next>=0.7.0",
     "lovekit>=1.1.0",
     "unlok-next>=1.1.1",
-    "reaktion-next>=0.3.1",
+    "reaktion-next>=0.4.0",
 ]
 
 [tool.hatch.build.targets.sdist]