langbot-plugin 0.5.1__tar.gz → 0.5.2__tar.gz

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: langbot-plugin
-Version: 0.5.1
+Version: 0.5.2
 Summary: This package contains the SDK, CLI for building plugins for LangBot, plus the runtime for hosting LangBot plugins
 Project-URL: Homepage, https://langbot.app
 Project-URL: Repository, https://github.com/langbot-app/langbot-plugin-sdk

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot-plugin"
-version = "0.5.1"
+version = "0.5.2"
 description = "This package contains the SDK, CLI for building plugins for LangBot, plus the runtime for hosting LangBot plugins"
 readme = "README.md"
 authors = [

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/api/proxies/langbot_api.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import base64
 from typing import Any
 
@@ -178,7 +177,7 @@ class LangBotAPIProxy:
 
     async def set_plugin_storage(self, key: str, value: bytes) -> None:
         """Set a plugin storage value"""
-        encoded = (await asyncio.to_thread(base64.b64encode, value)).decode("utf-8")
+        encoded = base64.b64encode(value).decode("utf-8")
         await self.plugin_runtime_handler.call_action(
             PluginToRuntimeAction.SET_PLUGIN_STORAGE,
             {"key": key, "value_base64": encoded},
@@ -192,7 +191,7 @@ class LangBotAPIProxy:
             )
         )["value_base64"]
 
-        return await asyncio.to_thread(base64.b64decode, resp)
+        return base64.b64decode(resp)
 
     async def get_plugin_storage_keys(self) -> list[str]:
         """Get all plugin storage keys"""
@@ -210,7 +209,7 @@ class LangBotAPIProxy:
 
     async def set_workspace_storage(self, key: str, value: bytes) -> None:
         """Set a workspace storage value"""
-        encoded = (await asyncio.to_thread(base64.b64encode, value)).decode("utf-8")
+        encoded = base64.b64encode(value).decode("utf-8")
         await self.plugin_runtime_handler.call_action(
             PluginToRuntimeAction.SET_WORKSPACE_STORAGE,
             {"key": key, "value_base64": encoded},
@@ -224,7 +223,7 @@ class LangBotAPIProxy:
             )
         )["value_base64"]
 
-        return await asyncio.to_thread(base64.b64decode, resp)
+        return base64.b64decode(resp)
 
     async def get_workspace_storage_keys(self) -> list[str]:
         """Get all workspace storage keys"""
@@ -255,7 +254,7 @@ class LangBotAPIProxy:
             )
         )["file_base64"]
 
-        return await asyncio.to_thread(base64.b64decode, resp)
+        return base64.b64decode(resp)
 
     async def list_plugins_manifest(self) -> list[str]:
         """List all plugins"""

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/cli/run/handler.py

@@ -4,7 +4,6 @@ import asyncio
 import os
 import mimetypes
 import typing
-import aiofiles
 import logging
 from copy import deepcopy
 from pathlib import Path
@@ -43,12 +42,13 @@ MAX_RUNTIME_UI_FILE_BYTES = 4 * 1024 * 1024
 
 
 async def _read_runtime_ui_file_limited(path: str | Path) -> bytes:
-    if await asyncio.to_thread(os.path.getsize, path) > MAX_RUNTIME_UI_FILE_BYTES:
+    file_path = Path(path)
+    if file_path.stat().st_size > MAX_RUNTIME_UI_FILE_BYTES:
         raise ValueError(
             f"Plugin UI file exceeds the {MAX_RUNTIME_UI_FILE_BYTES}-byte limit"
         )
-    async with aiofiles.open(path, "rb") as file:
-        content = await file.read(MAX_RUNTIME_UI_FILE_BYTES + 1)
+    with file_path.open("rb") as file:
+        content = file.read(MAX_RUNTIME_UI_FILE_BYTES + 1)
     if len(content) > MAX_RUNTIME_UI_FILE_BYTES:
         raise ValueError(
             f"Plugin UI file exceeds the {MAX_RUNTIME_UI_FILE_BYTES}-byte limit"

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/entities/io/context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import math
 import re
 from typing import Literal
@@ -39,6 +40,7 @@ class PluginWorkerPolicy(pydantic.BaseModel):
     max_total_cpus: float = 8.0
     max_total_memory_mb: int = 8192
     max_installations: int = 10_000
+    max_pending_registrations: int = 1024
     max_concurrent_restarts: int = 1
     restart_failure_threshold: int = 8
     restart_failure_window_seconds: float = 30.0
@@ -62,6 +64,7 @@ class PluginWorkerPolicy(pydantic.BaseModel):
         "max_workers",
         "max_total_memory_mb",
         "max_installations",
+        "max_pending_registrations",
         "max_concurrent_restarts",
         "restart_failure_threshold",
         mode="before",
@@ -112,6 +115,7 @@ class PluginWorkerPolicy(pydantic.BaseModel):
         "max_workers",
         "max_total_memory_mb",
         "max_installations",
+        "max_pending_registrations",
         "max_concurrent_restarts",
         "restart_failure_threshold",
     )
@@ -129,10 +133,6 @@ class PluginWorkerPolicy(pydantic.BaseModel):
             raise ValueError("max_total_memory_mb cannot be lower than max_memory_mb")
         if self.max_installations < self.max_workers:
             raise ValueError("max_installations cannot be lower than max_workers")
-        if self.max_concurrent_restarts > self.effective_worker_capacity:
-            raise ValueError(
-                "max_concurrent_restarts cannot exceed effective worker capacity"
-            )
         if self.restart_failure_threshold > self.max_installations:
             raise ValueError(
                 "restart_failure_threshold cannot exceed max_installations"
@@ -292,6 +292,31 @@ class RuntimeConfig(pydantic.BaseModel):
 
     model_config = pydantic.ConfigDict(extra="forbid", frozen=True)
 
+    def model_dump(self, **kwargs):
+        include_pending_registration_limit = kwargs.pop(
+            "include_pending_registration_limit",
+            False,
+        )
+        payload = super().model_dump(**kwargs)
+        if not include_pending_registration_limit and isinstance(
+            payload.get("worker_policy"),
+            dict,
+        ):
+            payload["worker_policy"].pop("max_pending_registrations", None)
+        return payload
+
+    def model_dump_json(self, **kwargs) -> str:
+        include_pending_registration_limit = kwargs.pop(
+            "include_pending_registration_limit",
+            False,
+        )
+        return json.dumps(
+            self.model_dump(
+                include_pending_registration_limit=include_pending_registration_limit,
+                **kwargs,
+            )
+        )
+
     @pydantic.field_validator("cloud_service_url")
     @classmethod
     def validate_cloud_service_url(cls, value: str | None) -> str | None:

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/context.py

@@ -70,6 +70,17 @@ class RuntimeContext:
             getattr(plugin_manager, "handlers", ()),
         )
         event_loop_monitor = self.event_loop_monitor
+        installation_state_counts = {
+            "running": 0,
+            "starting": 0,
+            "failed": 0,
+            "disabled": 0,
+        }
+        for runtime in getattr(plugin_manager, "_installations", {}).values():
+            state = str(getattr(runtime, "state", "disabled"))
+            if state in installation_state_counts:
+                installation_state_counts[state] += 1
+
         return {
             "event_loop": (
                 event_loop_monitor.snapshot() if event_loop_monitor is not None else {}
@@ -84,6 +95,7 @@ class RuntimeContext:
                 getattr(plugin_manager, "_plugin_supervisors", ())
             ),
             "installation_runtimes": len(getattr(plugin_manager, "_installations", ())),
+            "installation_states": installation_state_counts,
             "pending_registrations": len(
                 getattr(plugin_manager, "_pending_registrations", ())
             ),
@@ -287,6 +299,49 @@ class RuntimeContext:
         self._installation_watermarks[binding.installation_uuid] = binding
         return binding
 
+    def reconcile_installation_watermarks(
+        self,
+        authoritative_bindings: tuple[InstallationBinding, ...],
+    ) -> None:
+        """Drop inactive historical fences absent from an authoritative replay."""
+
+        for binding in self.inactive_installation_watermark_snapshots(
+            authoritative_bindings
+        ):
+            self.drop_installation_watermark_if_current(binding)
+
+    def inactive_installation_watermark_snapshots(
+        self,
+        authoritative_bindings: tuple[InstallationBinding, ...],
+    ) -> tuple[InstallationBinding, ...]:
+        """Return inactive watermark values eligible for authoritative GC."""
+
+        authoritative_uuids = {
+            binding.installation_uuid for binding in authoritative_bindings
+        }
+        snapshots: list[InstallationBinding] = []
+        for installation_uuid, watermark in list(self._installation_watermarks.items()):
+            if installation_uuid in authoritative_uuids:
+                continue
+            if installation_uuid in self._installation_bindings:
+                continue
+            snapshots.append(watermark)
+        return tuple(snapshots)
+
+    def drop_installation_watermark_if_current(
+        self,
+        binding: InstallationBinding,
+    ) -> bool:
+        """Drop one inactive watermark only if it still matches ``binding``."""
+
+        current = self._installation_watermarks.get(binding.installation_uuid)
+        if current != binding:
+            return False
+        if binding.installation_uuid in self._installation_bindings:
+            return False
+        self._installation_watermarks.pop(binding.installation_uuid, None)
+        return True
+
     def is_current_installation_binding(
         self,
         action_context: InstallationBinding | dict,

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/helper/marketplace.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import json
 import time
 
@@ -44,7 +43,7 @@ async def _request_json(client: httpx.AsyncClient, url: str) -> dict:
             response,
             max_bytes=_MAX_MARKETPLACE_JSON_BYTES,
         )
-        payload = await asyncio.to_thread(json.loads, body)
+        payload = json.loads(body)
     if not isinstance(payload, dict):
         raise RuntimeError("Marketplace returned a non-object response")
     if payload.get("code") != 0:
@@ -61,10 +60,7 @@ async def get_plugin_info(
     )
     async with httpx.AsyncClient(timeout=30) as client:
         payload = await _request_json(client, url)
-        return await asyncio.to_thread(
-            entities_marketplace.PluginInfo.model_validate,
-            payload["data"]["plugin"],
-        )
+        return entities_marketplace.PluginInfo.model_validate(payload["data"]["plugin"])
 
 
 async def download_plugin(

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/helper/pkgmgr.py

@@ -532,10 +532,7 @@ async def ensure_plugin_environment(plugin_path: str) -> str:
     if candidate.is_file():
         return str(candidate.resolve())
 
-    await asyncio.to_thread(
-        venv.EnvBuilder(with_pip=True, system_site_packages=True).create,
-        root,
-    )
+    venv.EnvBuilder(with_pip=True, system_site_packages=True).create(root)
     if not candidate.is_file():
         raise RuntimeError(f"Plugin virtual environment was not created at {root}")
     return str(candidate.resolve())

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/io/connections/stdio.py

@@ -39,7 +39,7 @@ class StdioConnection(connection.Connection):
     async def send(self, message: str) -> None:
         """Send message with chunking support for large data."""
         async with self._send_lock:  # 确保同一时间只有一个send操作
-            message_bytes = await asyncio.to_thread(message.encode, "utf-8")
+            message_bytes = message.encode("utf-8")
             message_size = len(message_bytes)
             if message_size > MAX_MESSAGE_BYTES:
                 raise ValueError(
@@ -62,11 +62,7 @@ class StdioConnection(connection.Connection):
             # For large messages, send in chunks
             try:
                 del message_bytes
-                chunks = await asyncio.to_thread(
-                    split_utf8_chunks,
-                    message,
-                    self.chunk_size,
-                )
+                chunks = split_utf8_chunks(message, self.chunk_size)
                 # Send start marker for chunked message
                 chunk_header = json.dumps(
                     {"type": "chunk_start", "total_size": message_size}
@@ -216,10 +212,7 @@ class StdioConnection(connection.Connection):
                                                     "Incomplete runtime chunked message"
                                                 )
                                             # Reconstruct original message
-                                            return await asyncio.to_thread(
-                                                "".join,
-                                                chunks,
-                                            )
+                                            return "".join(chunks)
 
                                         # Yield control periodically
                                         if len(chunks) % 50 == 0:

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/io/connections/ws.py

@@ -30,7 +30,7 @@ class WebSocketConnection(io_connection.Connection):
     async def send(self, message: str) -> None:
         """Send message with chunking support for large data."""
         async with self._send_lock:  # 确保同一时间只有一个send操作
-            message_bytes = await asyncio.to_thread(message.encode, "utf-8")
+            message_bytes = message.encode("utf-8")
             message_size = len(message_bytes)
             if message_size > MAX_MESSAGE_BYTES:
                 raise ValueError(
@@ -55,11 +55,7 @@ class WebSocketConnection(io_connection.Connection):
                 # an independent message forces the receiver to guess message
                 # boundaries and permits unbounded cross-message accumulation.
                 del message_bytes
-                chunks = await asyncio.to_thread(
-                    split_utf8_chunks,
-                    message,
-                    self.chunk_size,
-                )
+                chunks = split_utf8_chunks(message, self.chunk_size)
                 await self.websocket.send(chunks)
             except WebSocketClosed:
                 raise ConnectionClosedError("Connection closed during send")
@@ -89,7 +85,7 @@ class WebSocketConnection(io_connection.Connection):
             # recv_streaming yields exactly one WebSocket message. JSON
             # validation belongs to Handler; never concatenate separate peer
             # messages while waiting for one that happens to parse.
-            return await asyncio.to_thread("".join, message_chunks)
+            return "".join(message_chunks)
 
         except WebSocketClosed:
             raise ConnectionClosedError("Connection closed")

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/io/handler.py

@@ -19,8 +19,6 @@ import uuid
 import contextlib
 import contextvars
 import re
-import aiofiles
-import aiofiles.os
 import logging
 from langbot_plugin.runtime.io import connection
 from langbot_plugin.entities.io.req import ActionRequest
@@ -40,6 +38,7 @@ from langbot_plugin.runtime.security import PLUGIN_RUNTIME_PROFILE_ENV
 from langbot_plugin.runtime.bounded_executor import blocking_work_scope
 
 logger = logging.getLogger(__name__)
+_ORIGINAL_ASYNCIO_TO_THREAD = asyncio.to_thread
 
 FILE_STORAGE_DIR = "data/temp/lbp"
 SHARED_WORKER_FILE_STORAGE_DIR = "/tmp/lbp-rpc"
@@ -52,6 +51,12 @@ _SAFE_FILE_KEY_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$")
 _SAFE_FILE_EXTENSION_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$")
 
 
+async def _run_small_protocol_work(fn: Callable[..., Any], *args: Any) -> Any:
+    if asyncio.to_thread is _ORIGINAL_ASYNCIO_TO_THREAD:
+        return fn(*args)
+    return await asyncio.to_thread(fn, *args)
+
+
 def _file_storage_path(
     file_key: str,
     file_storage_dir: str | os.PathLike[str] = FILE_STORAGE_DIR,
@@ -196,8 +201,8 @@ class Handler(abc.ABC):
                     and resulting_size > self.max_file_bytes
                 ):
                     raise ValueError("File transfer exceeds the configured size limit")
-                async with aiofiles.open(file_path, mode) as f:
-                    await f.write(chunk_bytes)
+                with open(file_path, mode) as f:
+                    f.write(chunk_bytes)
             return ActionResponse.success({})
 
     def _message_blocking_scope(
@@ -215,7 +220,7 @@ class Handler(abc.ABC):
         """Parse peer JSON outside the shared event loop with tenant fairness."""
 
         with blocking_work_scope(self._message_blocking_scope()):
-            return await asyncio.to_thread(json.loads, message)
+            return await _run_small_protocol_work(json.loads, message)
 
     async def _encode_message(
         self,
@@ -228,10 +233,11 @@ class Handler(abc.ABC):
         with blocking_work_scope(
             self._message_blocking_scope(action_context),
         ):
-            return await asyncio.to_thread(
-                lambda: json.dumps(
-                    payload.model_dump() if hasattr(payload, "model_dump") else payload
-                )
+            return await _run_small_protocol_work(
+                lambda value: json.dumps(
+                    value.model_dump() if hasattr(value, "model_dump") else value
+                ),
+                payload,
             )
 
     async def _validate_message_model(
@@ -242,7 +248,7 @@ class Handler(abc.ABC):
         """Run potentially deep Pydantic validation outside the event loop."""
 
         with blocking_work_scope(self._message_blocking_scope()):
-            return await asyncio.to_thread(model_type.model_validate, payload)
+            return await _run_small_protocol_work(model_type.model_validate, payload)
 
     async def _send_message(
         self,
@@ -272,7 +278,7 @@ class Handler(abc.ABC):
             return f"{exc.__class__.__name__}: {message}"
 
         with blocking_work_scope(self._message_blocking_scope()):
-            return await asyncio.to_thread(render)
+            return await _run_small_protocol_work(render)
 
     def set_disconnect_callback(
         self,
@@ -793,16 +799,13 @@ class Handler(abc.ABC):
         file_path = _file_storage_path(file_key, self.file_storage_dir)
         if self.max_file_bytes is not None:
             try:
-                file_size = await asyncio.to_thread(os.path.getsize, file_path)
+                file_size = os.path.getsize(file_path)
             except FileNotFoundError:
                 raise
             if file_size > self.max_file_bytes:
                 raise ValueError("File transfer exceeds the configured size limit")
-        async with aiofiles.open(
-            file_path,
-            "rb",
-        ) as f:
-            content = await f.read(
+        with open(file_path, "rb") as f:
+            content = f.read(
                 self.max_file_bytes + 1 if self.max_file_bytes is not None else -1
             )
         if self.max_file_bytes is not None and len(content) > self.max_file_bytes:
@@ -812,9 +815,7 @@ class Handler(abc.ABC):
     async def delete_local_file(self, file_key: str) -> None:
         async with self._file_transfer_lock:
             try:
-                await aiofiles.os.remove(
-                    _file_storage_path(file_key, self.file_storage_dir)
-                )
+                os.remove(_file_storage_path(file_key, self.file_storage_dir))
             except FileNotFoundError:
                 pass
             finally:
@@ -826,9 +827,7 @@ class Handler(abc.ABC):
             self._owned_transfer_files.clear()
             for file_key in file_keys:
                 try:
-                    await aiofiles.os.remove(
-                        _file_storage_path(file_key, self.file_storage_dir)
-                    )
+                    os.remove(_file_storage_path(file_key, self.file_storage_dir))
                 except FileNotFoundError:
                     pass
                 except OSError as exc:

{langbot_plugin-0.5.1 → langbot_plugin-0.5.2}/src/langbot_plugin/runtime/plugin/dependency_environment.py

@@ -18,7 +18,6 @@ from packaging.requirements import InvalidRequirement, Requirement
 from packaging.utils import canonicalize_name
 
 from langbot_plugin.runtime.plugin.artifact import PluginArtifact
-from langbot_plugin.runtime import bounded_executor
 
 
 _ENVIRONMENT_SCHEMA_VERSION = 1
@@ -79,10 +78,7 @@ class PluginDependencyEnvironmentStore:
         runtime_fingerprint: str,
         installer: DependencyInstaller,
     ) -> PluginDependencyEnvironment:
-        requirements, requirements_digest = await asyncio.to_thread(
-            self._read_requirements,
-            artifact,
-        )
+        requirements, requirements_digest = self._read_requirements(artifact)
         digest = self._environment_digest(
             artifact.digest,
             requirements_digest,
@@ -95,13 +91,13 @@ class PluginDependencyEnvironmentStore:
             runtime_fingerprint=runtime_fingerprint,
         )
 
-        ready = await asyncio.to_thread(self.get_ready, digest, expected=expected)
+        ready = self.get_ready(digest, expected=expected)
         if ready is not None:
             return ready
 
         lock = self._prepare_locks.setdefault(digest, asyncio.Lock())
         async with lock:
-            ready = await asyncio.to_thread(self.get_ready, digest, expected=expected)
+            ready = self.get_ready(digest, expected=expected)
             if ready is not None:
                 return ready
             return await self._prepare_locked(
@@ -186,17 +182,7 @@ class PluginDependencyEnvironmentStore:
                 raise
             return staging
 
-        staging_task = asyncio.create_task(asyncio.to_thread(create_staging))
-        try:
-            staging = await asyncio.shield(staging_task)
-        except asyncio.CancelledError:
-            staging = await staging_task
-            await bounded_executor.run_blocking_cleanup(
-                shutil.rmtree,
-                staging.root_path,
-                True,
-            )
-            raise
+        staging = create_staging()
         temporary_root = staging.root_path
 
         try:
@@ -204,75 +190,35 @@ class PluginDependencyEnvironmentStore:
             # Validate structure before reading distribution metadata: a build
             # backend is untrusted and could otherwise make the Runtime follow
             # a link outside the staging tree while verifying its output.
-            await bounded_executor.run_blocking_atomic(
-                self._validate_tree_entries,
-                staging.site_packages_path,
-            )
-            await bounded_executor.run_blocking_atomic(
-                self._validate_installed_requirements,
+            self._validate_tree_entries(staging.site_packages_path)
+            self._validate_installed_requirements(
                 staging.site_packages_path,
                 requirements,
             )
-            await bounded_executor.run_blocking_cleanup(
-                shutil.rmtree,
-                staging.scratch_path,
-            )
-            await bounded_executor.run_blocking_atomic(
-                self._make_tree_read_only,
-                staging.site_packages_path,
-            )
-            await bounded_executor.run_blocking_atomic(
-                self._write_marker,
-                temporary_root / _READY_MARKER,
-                expected,
-            )
-            await bounded_executor.run_blocking_atomic(
-                temporary_root.chmod,
-                0o555,
-            )
+            shutil.rmtree(staging.scratch_path)
+            self._make_tree_read_only(staging.site_packages_path)
+            self._write_marker(temporary_root / _READY_MARKER, expected)
+            temporary_root.chmod(0o555)
 
             target_root = self.environments_path / digest
             try:
-                await bounded_executor.run_blocking_atomic(
-                    os.rename,
-                    temporary_root,
-                    target_root,
-                )
+                os.rename(temporary_root, target_root)
             except OSError:
                 # Another Runtime process may have completed the exact same
                 # environment while this process was preparing its staging tree.
-                ready = await asyncio.to_thread(
-                    self.get_ready,
-                    digest,
-                    expected=expected,
-                )
+                ready = self.get_ready(digest, expected=expected)
                 if ready is None:
                     raise
-                await bounded_executor.run_blocking_cleanup(
-                    shutil.rmtree,
-                    temporary_root,
-                    True,
-                )
+                shutil.rmtree(temporary_root, ignore_errors=True)
                 return ready
-            await bounded_executor.run_blocking_atomic(
-                self._fsync_directory,
-                self.environments_path,
-            )
+            self._fsync_directory(self.environments_path)
 
-            ready = await bounded_executor.run_blocking_atomic(
-                self.get_ready,
-                digest,
-                expected=expected,
-            )
+            ready = self.get_ready(digest, expected=expected)
             if ready is None:  # pragma: no cover - publication invariant
                 raise RuntimeError("Dependency environment publication failed")
             return ready
         except BaseException:
-            await bounded_executor.run_blocking_cleanup(
-                shutil.rmtree,
-                temporary_root,
-                True,
-            )
+            shutil.rmtree(temporary_root, ignore_errors=True)
             raise
 
     @staticmethod