@camera.ui/server 0.0.48 → 0.0.50-internal.0

package/dist/server/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@camera.ui/server",
-  "version": "0.0.48",
+  "version": "0.0.50-internal.0",
   "description": "camera.ui",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "type": "module",
+  "main": "dist/server/bin/cameraui-server.js",
   "bin": {
     "cameraui-server": "./dist/server/bin/cameraui-server.js"
   },
   "scripts": {
-    "build": "rimraf ./dist/server && tsc && cpy package.json dist/server && cpy requirements.txt dist/server",
+    "build": "rimraf ./dist/server && npm run build:wasm && mypy src && tsc && npm run copy:files && npm run clean",
+    "build:wasm": "cd src/decoder/wasm && asc assembly/index.ts assembly/console.ts --config asconfig.json && cd ../../../../../",
     "check": "tsc --noEmit",
+    "clean": "rimraf dist/server/src/decoder/python/test && rimraf dist/server/src/camera/python/test",
+    "copy:files": "cpy package.json dist/server && cpy requirements.txt dist/server && cpy 'src/**/*.py' dist/server/src --parents && cpy src/decoder/wasm/build/**/* ./dist/server/src/decoder/wasm/build",
     "format": "prettier --write 'src/' 'bin/' --ignore-unknown --no-error-on-unmatched-pattern",
     "install-updates": "npm i --save",
     "lint": "eslint .",
@@ -17,89 +21,97 @@
     "update": "updates --update ./",
     "prepublishOnly": "node -e \"if(!process.env.SAFE_PUBLISH){console.error('Error: Use npm run publish:latest or npm run publish:alpha to publish');process.exit(1)}\"",
     "publish:latest": "tsx ../scripts/publish.ts -p ./ -m ./localdeps.txt --cameraui",
-    "publish:alpha": "tsx ../scripts/publish.ts -p ./ -m ./localdeps.txt --cameraui --npm-args --tag alpha"
+    "publish:alpha": "tsx ../scripts/publish.ts -p ./ -m ./localdeps.txt --cameraui --npm-args --tag alpha",
+    "publish:internal": "tsx ../scripts/publish.ts -p ./ -m ./localdeps.txt --cameraui --npm-args --tag internal"
   },
   "dependencies": {
-    "@camera.ui/common": "^0.0.37",
-    "@camera.ui/ffmpeg": "^0.0.5",
-    "@camera.ui/go2rtc": "^0.0.30",
-    "@camera.ui/nats": "^0.0.15",
-    "@camera.ui/plugineer": "^0.0.43",
-    "@camera.ui/types": "^0.0.84",
-    "@fastify/cors": "^10.0.1",
-    "@fastify/formbody": "^8.0.1",
-    "@fastify/helmet": "^13.0.0",
-    "@fastify/multipart": "^9.0.1",
-    "@fastify/static": "^8.0.3",
+    "@assemblyscript/loader": "^0.27.36",
+    "@bjia56/portable-python": "^0.1.114",
+    "@camera.ui/common": "^0.0.40",
+    "@camera.ui/ffmpeg": "^0.0.7",
+    "@camera.ui/go2rtc": "^0.0.50",
+    "@camera.ui/nats": "^0.0.22",
+    "@camera.ui/rpc-client": "^0.0.3",
+    "@camera.ui/rpc-common": "^0.0.3",
+    "@camera.ui/rpc-server": "^0.0.3",
+    "@camera.ui/rtsp": "^0.0.49",
+    "@camera.ui/rust-decoder": "^0.0.5",
+    "@fastify/cors": "^11.0.1",
+    "@fastify/formbody": "^8.0.2",
+    "@fastify/helmet": "^13.0.1",
+    "@fastify/multipart": "^9.0.3",
+    "@fastify/static": "^8.1.1",
     "@isaacs/ttlcache": "^1.4.1",
-    "@scrypted/node-pty": "1.0.18",
     "adm-zip": "^0.5.16",
     "ansicolor": "^2.0.3",
-    "dotenv": "^16.4.7",
+    "cloudflared": "^0.7.0",
+    "compare-versions": "^6.1.1",
+    "dotenv": "^16.5.0",
     "express-useragent": "^1.0.15",
-    "fastify": "^5.2.0",
+    "fastify": "^5.3.2",
     "fastify-plugin": "^5.0.1",
     "fastify-type-provider-zod": "^4.0.2",
     "fkill": "^9.0.0",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.0",
     "get-port": "^7.1.0",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",
-    "lmdb": "^3.2.0",
-    "msgpackr": "^1.11.2",
-    "nats": "^2.28.2",
+    "lmdb": "^3.2.6",
     "node-forge": "^1.3.1",
     "object-path": "^0.11.8",
     "ps-list": "^8.1.1",
-    "qs": "^6.13.1",
+    "qs": "^6.14.0",
     "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.1",
+    "rxjs": "^7.8.2",
     "safe-timers": "^1.1.0",
-    "semver": "^7.6.3",
-    "sharp": "^0.33.5",
+    "semver": "^7.7.1",
+    "sharp": "^0.34.1",
     "socket.io": "^4.8.1",
-    "systeminformation": "^5.23.13",
+    "systeminformation": "^5.25.11",
     "tail": "^2.2.6",
     "tar": "^7.4.3",
-    "tsyringe": "^4.8.0",
-    "uuid": "^11.0.3",
-    "werift": "^0.20.1",
-    "ws": "^8.18.0",
-    "zod": "^3.24.1"
+    "tsyringe": "^4.10.0",
+    "undici": "^7.8.0",
+    "uuid": "^11.1.0",
+    "werift": "^0.22.1",
+    "ws": "^8.18.1",
+    "zod": "^3.24.3"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "^2.12.1",
+    "@camera.ui/types": "^0.0.87",
+    "@stylistic/eslint-plugin": "^4.2.0",
     "@types/adm-zip": "^0.5.7",
     "@types/express-useragent": "^1.0.5",
     "@types/fs-extra": "^11.0.4",
     "@types/js-yaml": "^4.0.9",
-    "@types/jsonwebtoken": "^9.0.7",
-    "@types/node": "^22.10.2",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/node": "^22.15.3",
     "@types/node-forge": "^1.3.11",
     "@types/object-path": "^0.11.4",
     "@types/safe-timers": "^1.1.2",
-    "@types/semver": "^7.5.8",
+    "@types/semver": "^7.7.0",
     "@types/tail": "^2.2.3",
     "@types/tar": "^6.1.13",
     "@types/uuid": "^10.0.0",
-    "@types/ws": "^8.5.13",
-    "@typescript-eslint/parser": "^8.18.0",
-    "assemblyscript": "^0.27.31",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/parser": "^8.31.1",
+    "assemblyscript": "^0.27.36",
     "cpy-cli": "^5.0.0",
     "cross-env": "^7.0.3",
-    "eslint": "^9.17.0",
-    "globals": "^15.13.0",
-    "prettier": "^3.4.2",
+    "eslint": "^9.25.1",
+    "globals": "^16.0.0",
+    "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.0",
-    "updates": "^16.4.1"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.31.1",
+    "updates": "^16.4.2",
+    "vitest": "^3.1.2"
   },
   "bugs": {
     "url": "https://github.com/seydx/camera.ui/issues"
   },
   "engines": {
-    "node": ">=20.18.0"
+    "node": ">=22.0.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",
   "keywords": [

package/dist/server/requirements.txt

@@ -1,14 +1,15 @@
-camera-ui-python-types==0.2.5
-camera-ui-python-common==0.1.3
-nats-py==2.9.0
-deepdiff==7.0.1
-pyeecui==11.1.2
+camera-ui-python-types==2.0.3
+camera-ui-python-common==2.0.2
+nats-py==2.10.0
+deepdiff==8.4.2
+pyeecui==12.1.4
 reactivex==4.0.4
 numpy==1.26.4
 lmdbm==0.0.6
-lmdb==1.5.1
-cachetools==5.5.0
-aiohttp==3.11.10
-Pillow==11.0.0
-virtualenv==20.28.0
-setproctitle==1.3.4
+lmdb==1.6.2
+msgpack==1.1.0
+cachetools==5.5.2
+aiohttp==3.11.18
+Pillow==11.2.1
+virtualenv==20.30.0
+setproctitle==1.3.6

package/dist/server/src/_camera_ui_tools/camera_ui_common/__init__.py

@@ -0,0 +1,28 @@
+from .camera_utils.utils import build_target_url
+from .common_utils.object_path import ObjectPath, Path
+from .common_utils.reactive import ReactiveProperty
+from .common_utils.signal_handler import SignalHandler, SignalHandlerOptions
+from .common_utils.subscribed import Subscribed
+from .common_utils.task import TaskSet
+from .common_utils.thread import to_thread
+from .common_utils.utils import make_sync, merge, merge_with
+from .logger_service.ansicolor import Ansicolor
+from .logger_service.logger import LoggerOptions, LoggerService
+
+__all__ = [
+    "build_target_url",
+    "ObjectPath",
+    "Path",
+    "SignalHandler",
+    "SignalHandlerOptions",
+    "Subscribed",
+    "TaskSet",
+    "to_thread",
+    "make_sync",
+    "merge",
+    "merge_with",
+    "ReactiveProperty",
+    "Ansicolor",
+    "LoggerOptions",
+    "LoggerService",
+]

package/dist/server/src/_camera_ui_tools/camera_ui_common/camera_utils/utils.py

@@ -0,0 +1,52 @@
+from typing import Optional
+from urllib.parse import urlparse
+
+from camera_ui_python_types import RTSPUrlOptions
+
+
+def build_target_url(rtsp_url: str, options: Optional[RTSPUrlOptions] = None) -> str:
+    if options is None:
+        options = {}
+
+    parsed_url = urlparse(rtsp_url)
+    base_url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}"
+
+    video = options.get("video", True)
+    audio = options.get("audio", True)
+    audio_single_track = options.get("audioSingleTrack", True)
+    backchannel = options.get("backchannel", False)
+    timeout = options.get("timeout", 15)
+
+    validated_timeout = min(max(5, timeout), 30)
+    params: list[tuple[str, Optional[str]]] = []
+
+    # Video Parameter
+    if video:
+        params.append(("video", None))
+
+    # Audio Parameter
+    if audio:
+        if isinstance(audio, bool):
+            if audio:
+                params.append(("audio", None))
+        elif isinstance(audio, list):
+            if audio_single_track:
+                # One Track with multiple codec options: audio=codec1,codec2
+                params.append(("audio", ",".join(audio)))
+            else:
+                # Multiple Audio Tracks: audio=codec1&audio=codec2
+                for codec in audio:
+                    params.append(("audio", codec))
+        else:  # String
+            params.append(("audio", audio))
+
+    # Backchannel Parameter
+    if backchannel:
+        params.append(("backchannel", "1"))
+
+    # Timeout Parameter
+    params.append(("timeout", str(validated_timeout)))
+
+    query_string = "&".join([f"{key}" if value is None else f"{key}={value}" for key, value in params])
+
+    return f"{base_url}?{query_string}"

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/object_path.py

@@ -0,0 +1,198 @@
+from collections.abc import Sequence
+from typing import Any, Optional, TypeVar, Union, cast
+
+Path = Union[Sequence[Union[int, str]], str, int]
+T = TypeVar("T")
+
+
+def is_empty(value: list[int] | list[str] | Sequence[int | str] | None) -> bool:
+    if value is None:
+        return True
+    return len(value) == 0
+
+
+def get_key(key: Union[str, int]) -> Union[int, str]:
+    if isinstance(key, int):
+        return key
+    if key.isdigit():
+        return int(key)
+    return key
+
+
+class ObjectPath:
+    @staticmethod
+    def delete(obj: Union[dict[Any, Any], list[Any]], path: Path) -> Union[dict[Any, Any], list[Any]]:
+        if isinstance(path, int):
+            path = [path]
+        elif isinstance(path, str):
+            path = path.split(".")
+
+        if is_empty(path):
+            return obj
+
+        current_path = get_key(path[0])
+
+        if isinstance(obj, list):
+            if isinstance(current_path, int) and 0 <= current_path < len(obj):
+                if len(path) == 1:
+                    obj.pop(current_path)
+                else:
+                    next_obj = obj[current_path]
+                    if isinstance(next_obj, (dict, list)):
+                        ObjectPath.delete(cast(Any, next_obj), path[1:])
+        elif current_path in obj:
+            if len(path) == 1:
+                del obj[current_path]
+            else:
+                next_obj = obj[current_path]
+                if isinstance(next_obj, (dict, list)):
+                    ObjectPath.delete(cast(Any, next_obj), path[1:])
+
+        return obj
+
+    @staticmethod
+    def has(obj: Union[dict[Any, Any], list[Any]], path: Path) -> bool:
+        if isinstance(path, int):
+            path = [path]
+        elif isinstance(path, str):
+            path = path.split(".")
+
+        if not path:
+            return bool(obj)
+
+        current: Any = obj
+        for item in path:
+            key = get_key(item)
+
+            if isinstance(current, list):
+                if isinstance(key, int) and 0 <= key < len(cast(list[str], current)):
+                    current = current[key]
+                else:
+                    return False
+            elif isinstance(current, dict):
+                if key in current:
+                    current = current[key]
+                else:
+                    return False
+            else:
+                return False
+
+        return True
+
+    @staticmethod
+    def get(obj: Union[dict[Any, Any], list[Any]], path: Path, default_value: Any = None) -> Any:
+        # Handle leere Pfade
+        if isinstance(path, str) and not path or isinstance(path, Sequence) and not path:
+            return obj
+
+        # Konvertiere einzelne Zahlen oder Strings in eine Liste
+        if isinstance(path, int):
+            path = [path]
+        elif isinstance(path, str):
+            path = path.split(".")
+
+        # Ab hier wie gehabt
+        current_path = get_key(path[0])
+        next_obj = None
+
+        if isinstance(obj, list):
+            if isinstance(current_path, int) and 0 <= current_path < len(obj):
+                next_obj = obj[current_path]
+        else:
+            next_obj = obj.get(current_path)
+
+        if next_obj is None:
+            return default_value
+
+        if len(path) == 1:
+            return next_obj
+
+        return ObjectPath.get(next_obj, path[1:], default_value)
+
+    @staticmethod
+    def set(
+        obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any, do_not_replace: bool = False
+    ) -> Any:
+        if isinstance(path, int):
+            path = [path]
+        elif isinstance(path, str):
+            path = [get_key(key) for key in path.split(".") if key]
+
+        if not path:
+            return obj
+
+        current_path = path[0]
+
+        if isinstance(obj, list):
+            if isinstance(current_path, int):
+                while len(obj) <= current_path:
+                    obj.append(None)
+                if len(path) == 1:
+                    if not do_not_replace or obj[current_path] is None:
+                        obj[current_path] = value
+                else:
+                    if obj[current_path] is None:
+                        obj[current_path] = [] if isinstance(path[1], int) else {}
+                    return ObjectPath.set(obj[current_path], path[1:], value, do_not_replace)
+            return None
+
+        if len(path) == 1:
+            if not do_not_replace or current_path not in obj:
+                obj[current_path] = value
+            return obj.get(current_path)
+
+        if current_path not in obj:
+            obj[current_path] = [] if isinstance(path[1], int) else {}
+
+        return ObjectPath.set(obj[current_path], path[1:], value, do_not_replace)
+
+    @staticmethod
+    def push(obj: Union[dict[Any, Any], list[Any]], path: Path, *items: Any) -> None:
+        target = ObjectPath.get(obj, path)
+        if not isinstance(target, list):
+            target = []
+            ObjectPath.set(obj, path, target)
+        target.extend(items)
+
+    @staticmethod
+    def coalesce(
+        obj: Union[dict[Any, Any], list[Any]],
+        paths: Union[Path, list[Path]],
+        default_value: Optional[Any] = None,
+    ) -> Any:
+        paths_list = paths if isinstance(paths, list) else [paths]
+        for path in paths_list:
+            value = ObjectPath.get(obj, path)
+            if value is not None:
+                return value
+        return default_value
+
+    @staticmethod
+    def empty(obj: Union[dict[Any, Any], list[Any]], path: Path) -> Any:
+        value = ObjectPath.get(obj, path)
+
+        if value is None:
+            return None
+
+        if isinstance(value, str):
+            return ObjectPath.set(obj, path, "")
+        if isinstance(value, bool):
+            return ObjectPath.set(obj, path, False)
+        if isinstance(value, (int, float)):
+            return ObjectPath.set(obj, path, 0)
+        if isinstance(value, (list, dict)):
+            value.clear()
+            return cast(Any, value)
+        return ObjectPath.set(obj, path, None)
+
+    @staticmethod
+    def ensure_exists(obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any) -> Any:
+        return ObjectPath.set(obj, path, value, True)
+
+    @staticmethod
+    def insert(obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any, at: int = 0) -> None:
+        target = ObjectPath.get(obj, path)
+        if not isinstance(target, list):
+            target = []
+            ObjectPath.set(obj, path, target)
+        target.insert(at, value)

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/reactive.py

@@ -0,0 +1,42 @@
+from copy import deepcopy
+from typing import Generic, Optional, TypeVar, Union, cast
+
+from camera_ui_python_types.hybrid_observer import HybridObservable
+from reactivex import operators as ops
+from reactivex.subject import BehaviorSubject
+
+T = TypeVar("T")
+
+
+class ReactiveProperty(Generic[T]):
+    __subject: BehaviorSubject[T]
+    observable: HybridObservable[T]
+
+    def __init__(
+        self, initial_value: Union[T, BehaviorSubject[T]], observable: Optional[HybridObservable[T]] = None
+    ):
+        if isinstance(initial_value, BehaviorSubject):
+            self.__subject = cast(BehaviorSubject[T], initial_value)
+        else:
+            self.__subject = BehaviorSubject(initial_value)
+
+        self.observable = observable or self.__create_state_observable(self.__subject)
+
+    @property
+    def value(self) -> T:
+        val = self.__subject.value
+
+        if isinstance(val, (dict, list)) or hasattr(val, "__dict__"):
+            val = cast(T, val)
+            return deepcopy(val)
+
+        return val
+
+    def next(self, value: T) -> None:
+        self.__subject.on_next(value)
+
+    def complete(self) -> None:
+        self.__subject.on_completed()
+
+    def __create_state_observable(self, state_subject: BehaviorSubject[T]) -> HybridObservable[T]:
+        return HybridObservable(state_subject.pipe(ops.distinct_until_changed(), ops.share()))

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/signal_handler.py

@@ -0,0 +1,92 @@
+import asyncio
+import contextlib
+import signal
+import traceback
+from collections.abc import Coroutine
+from typing import Any, Callable, TypedDict
+
+from camera_ui_python_types import LoggerService
+
+
+class SignalHandlerOptions(TypedDict):
+    display_name: str
+    logger: LoggerService
+    timeout_duration: int
+    close_function: Callable[..., Coroutine[Any, Any, Any]]
+
+
+class SignalHandler:
+    display_name: str
+    logger: LoggerService
+    timeout_duration: int
+    close_function: Callable[..., Coroutine[Any, Any, Any]]
+    is_shutting_down: bool
+    shutdown_event: asyncio.Event
+
+    def __init__(self, options: SignalHandlerOptions):
+        self.display_name: str = options["display_name"]
+        self.logger = options["logger"]
+        self.timeout_duration = options.get("timeout_duration", 5)
+        self.close_function = options["close_function"]
+        self.is_shutting_down = False
+        self.shutdown_event = asyncio.Event()
+
+    def setup_handlers(self) -> None:
+        loop = asyncio.get_running_loop()
+        with contextlib.suppress(NotImplementedError):
+            for signame in ("SIGINT", "SIGTERM"):
+
+                def signal_callback() -> None:
+                    with contextlib.suppress(asyncio.CancelledError):
+                        asyncio.create_task(self.gracefully_close(signame))
+
+                sig = getattr(signal, signame)
+                loop.add_signal_handler(sig, signal_callback)
+
+        loop.set_exception_handler(self.handle_exception)
+
+    async def gracefully_close(self, signame: str) -> None:
+        if self.is_shutting_down:
+            return
+
+        self.is_shutting_down = True
+        self.logger.log(f"{self.display_name} Received {signame}. Stopping...")
+
+        try:
+            close_task = asyncio.create_task(self.close_function())
+            await asyncio.wait_for(close_task, timeout=self.timeout_duration)
+        except asyncio.TimeoutError:
+            self.logger.warn(
+                f"{self.display_name} Failed to gracefully close before timeout. Force quitting!"
+            )
+        except Exception as e:
+            self.logger.error(f"Error during shutdown: {str(e)}\n{traceback.format_exc()}")
+        finally:
+            self.shutdown_event.set()
+
+    def handle_exception(self, loop: asyncio.AbstractEventLoop, context: dict[str, Any]) -> None:
+        exception = context.get("exception")
+        message = context.get("message")
+        task = context.get("task")  # Das Task Objekt
+
+        if isinstance(exception, asyncio.CancelledError) and self.is_shutting_down:
+            return
+
+        error_message = f"{self.display_name} Caught exception: {message}"
+        if task:
+            # Task Stack ausgeben
+            stack = task.get_stack()
+            if stack:
+                error_message += "\nTask Stack:"
+                for frame in stack:
+                    error_message += f"\n  File {frame.f_code.co_filename}, line {frame.f_lineno}, in {frame.f_code.co_name}"
+
+        if exception:
+            error_message += f"\n{type(exception).__name__}: {str(exception)}"
+            if not isinstance(exception, asyncio.CancelledError):
+                error_message += f"\n{traceback.format_exc()}"
+
+        self.logger.error(error_message)
+
+        if not self.is_shutting_down:
+            asyncio.create_task(self.gracefully_close("uncaughtException"))

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/subscribed.py

@@ -0,0 +1,21 @@
+from typing import Protocol
+
+
+class Unsubscribable(Protocol):
+    def dispose(self) -> None: ...
+
+
+class Subscribed:
+    _subscriptions: list[Unsubscribable]
+    _additional_subscriptions: list[Unsubscribable]
+
+    def __init__(self) -> None:
+        self._subscriptions = []
+        self._additional_subscriptions = []
+
+    def add_subscriptions(self, *subscriptions: Unsubscribable) -> None:
+        self._subscriptions.extend(subscriptions)
+
+    def unsubscribe(self) -> None:
+        for subscription in self._subscriptions:
+            subscription.dispose()

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/task.py

@@ -0,0 +1,39 @@
+import asyncio
+from collections.abc import Coroutine
+from typing import Any, Optional
+
+
+class TaskSet:
+    tasks: set[asyncio.Task[Any]]
+    name: Optional[str]
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.tasks = set[asyncio.Task[Any]]()
+        self.name = name
+
+    def log_prefix(self) -> str:
+        return f"[{self.name}]"
+
+    def add(self, coroutine: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
+        task = asyncio.create_task(coroutine, name=self.name)
+        self.tasks.add(task)
+        task.add_done_callback(lambda _: self.remove(task))
+
+        return task
+
+    def remove(self, task: asyncio.Task[Any]) -> None:
+        if task in self.tasks:
+            if not task.cancelled():
+                task.cancel()
+
+            self.tasks.remove(task)
+
+    def remove_all(self) -> None:
+        tasks = self.tasks.copy()
+        for task in tasks:
+            self.remove(task)
+
+        self.tasks.clear()
+
+    def __await__(self) -> Any:
+        return asyncio.gather(*self.tasks).__await__()