je-action-core 0.0.1__tar.gz

je_action_core-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 JE-Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

je_action_core-0.0.1/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: je_action_core
+Version: 0.0.1
+Summary: The keyword-driven action executor shared by APITestka, LoadDensity, MailThunder and FileAutomation
+Author-email: JE-Chen <jechenmailman@gmail.com>
+License-Expression: MIT
+Project-URL: Code, https://github.com/Integration-Automation/ActionCore
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Other Environment
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ActionCore
+
+**English** | [繁體中文](README/README_zh-TW.md) | [简体中文](README/README_zh-CN.md)
+
+`je_action_core` is the keyword-driven action executor shared by
+[APITestka](https://github.com/Integration-Automation/APITestka), [LoadDensity](https://github.com/Integration-Automation/LoadDensity),
+[MailThunder](https://github.com/Integration-Automation/MailThunder) and [FileAutomation](https://github.com/Integration-Automation/FileAutomation).
+Each of them carried its own copy of the same executor, package manager, callback executor, action-file reader
+and socket server. This package replaces those copies: a project configures it with its own command prefix,
+document key, exceptions and messages.
+
+It has no dependencies and supports Python 3.10 to 3.14.
+
+## Contents
+
+- [Installation](#installation)
+- [Actions](#actions)
+- [Quick start](#quick-start)
+- [The pieces](#the-pieces)
+- [Package gate](#package-gate)
+- [Socket server protocol](#socket-server-protocol)
+- [Who uses it](#who-uses-it)
+- [Development](#development)
+- [License](#license)
+
+## Installation
+
+```bash
+pip install je_action_core
+```
+
+A framework that is built on it installs it as a dependency.
+
+## Actions
+
+An action list is a JSON list of actions, or a document that keeps the list under one key
+(`{"api_testka": [...]}`). Each action takes one of three forms:
+
+| Action | Call |
+|---|---|
+| `["name"]` | `command()` |
+| `["name", {"a": 1}]` | `command(a=1)` |
+| `["name", [1, 2]]` | `command(1, 2)` |
+
+Running a list returns one record per action: the command's return value, or `repr(error)` when it raised. One
+failing action does not stop the rest.
+
+## Quick start
+
+```python
+from je_action_core import (
+    ActionExecutor, ActionListRules, CommandPolicy, CommandRegistry, ExecutorSettings, LoggingReporter,
+)
+import logging
+
+registry = CommandRegistry({"MY_add": lambda a, b: a + b}, policy=CommandPolicy.FUNCTIONS_ONLY)
+executor = ActionExecutor(
+    ExecutorSettings(rules=ActionListRules("my_tool"), reporter=LoggingReporter(logging.getLogger("my_tool"))),
+    registry,
+)
+
+executor.execute_action({"my_tool": [["MY_add", [1, 2]], ["MY_add", {"a": 3, "b": 4}]]})
+# {"execute: ['MY_add', [1, 2]]": 3, "execute: ['MY_add', {'a': 3, 'b': 4}]": 7}
+```
+
+## The pieces
+
+| Module | What it gives you | Settings |
+|---|---|---|
+| `registry` | `CommandRegistry`: commands by name, `event_dict` as the live mapping | `CommandPolicy.FUNCTIONS_ONLY` or `ANY_CALLABLE` for caller-added commands; the exception for a refused one |
+| `action_list` | `ActionListRules` (where the list is), `LegacyActionParser` and `StrictActionParser` | document key and legacy keys (with a `DeprecationWarning`); empty list raises or returns `{}`; error messages |
+| `executor` | `ActionExecutor`: `execute_action`, `execute_files`, `add_command_to_executor` | `ExecutorSettings`: rules, parser, reporter, file reader, record key (`execute: …` or `execute[i]: …`), action rewrite |
+| `reporting` | `LoggingReporter`, `PrintReporter`, or your own `ExecutionReporter` | where events, failures and records go |
+| `package_manager` | `PackageManager`: load an installed package's members as commands, behind the [package gate](#package-gate) | member naming (`<package>_<member>` or bare), predicates, name check, errors to log |
+| `callback` | `CallbackFunctionExecutor`: run a trigger, then a callback | legacy or strict checking; raise or log and return `None` |
+| `json_io` | `ActionJsonFile`, `read_action_json`, `write_action_json`: UTF-8, locked, non-ASCII kept | exception class and message templates |
+| `file_listing` | `get_dir_files_as_list`: action files under a directory | — |
+| `socket_server` | `start_action_socket_server`: the plain TCP action server | executor, payload check, errors answered, oversize policy |
+| `builtins_policy` | `SAFE_BUILTINS`: the builtins an action list may call | — |
+
+`__all__` in `je_action_core/__init__.py` is the supported import surface.
+
+## Package gate
+
+`PackageManager.add_package_to_executor` imports a package and registers its members as commands. An action list
+that can name `os` or `subprocess` could therefore run anything. The host program decides what may load:
+
+```python
+package_manager.allow_packages("my_helpers")          # these, and their submodules
+package_manager.set_allow_arbitrary_packages(False)   # refuse everything else before importing it
+```
+
+Neither switch should ever be exposed as an action command, so an action list cannot open its own gate. A
+refused package raises the project's `refused` exception, which the executor records as that action's result.
+Until the host calls either switch, any package still loads but raises a `DeprecationWarning`. A project can
+turn the gate off (`PackageGate.OFF`) while it moves to it.
+
+## Socket server protocol
+
+`start_action_socket_server(host, port, settings)` serves on a daemon thread. A client sends one JSON action
+document per connection. The server replies with each record value on its own line, then
+`Return_Data_Over_JE`. A failure replies with the error text and the same marker. `quit_server` stops the server
+and sets `close_flag`. The server has no authentication, so bind it only to a trust## Who uses it
+
+APITestka (`AT_`, port 9939), LoadDensity (`LD_`), MailThunder (`MT_`, port 9942) and FileAutomation (`FA_`) are
+the projects this package is for. `architecture.md` §6 lists which of them have moved to it and which pieces and
+settings each one uses. LoadDensity and FileAutomation keep their own socket servers: a gevent server with
+framing, a token and TLS, and a server with authentication and an ACL.
+
+n and an ACL.
+
+## Development
+
+```bash
+pip install -e .
+pip install pytest
+python -m pytest test/
+```
+
+`architecture.md` describes the layers and the contracts with the four projects. Outstanding work is in
+`progress.md`, and finished work is recorded in `docs/updates/`.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

je_action_core-0.0.1/README.md

@@ -0,0 +1,125 @@
+# ActionCore
+
+**English** | [繁體中文](README/README_zh-TW.md) | [简体中文](README/README_zh-CN.md)
+
+`je_action_core` is the keyword-driven action executor shared by
+[APITestka](https://github.com/Integration-Automation/APITestka), [LoadDensity](https://github.com/Integration-Automation/LoadDensity),
+[MailThunder](https://github.com/Integration-Automation/MailThunder) and [FileAutomation](https://github.com/Integration-Automation/FileAutomation).
+Each of them carried its own copy of the same executor, package manager, callback executor, action-file reader
+and socket server. This package replaces those copies: a project configures it with its own command prefix,
+document key, exceptions and messages.
+
+It has no dependencies and supports Python 3.10 to 3.14.
+
+## Contents
+
+- [Installation](#installation)
+- [Actions](#actions)
+- [Quick start](#quick-start)
+- [The pieces](#the-pieces)
+- [Package gate](#package-gate)
+- [Socket server protocol](#socket-server-protocol)
+- [Who uses it](#who-uses-it)
+- [Development](#development)
+- [License](#license)
+
+## Installation
+
+```bash
+pip install je_action_core
+```
+
+A framework that is built on it installs it as a dependency.
+
+## Actions
+
+An action list is a JSON list of actions, or a document that keeps the list under one key
+(`{"api_testka": [...]}`). Each action takes one of three forms:
+
+| Action | Call |
+|---|---|
+| `["name"]` | `command()` |
+| `["name", {"a": 1}]` | `command(a=1)` |
+| `["name", [1, 2]]` | `command(1, 2)` |
+
+Running a list returns one record per action: the command's return value, or `repr(error)` when it raised. One
+failing action does not stop the rest.
+
+## Quick start
+
+```python
+from je_action_core import (
+    ActionExecutor, ActionListRules, CommandPolicy, CommandRegistry, ExecutorSettings, LoggingReporter,
+)
+import logging
+
+registry = CommandRegistry({"MY_add": lambda a, b: a + b}, policy=CommandPolicy.FUNCTIONS_ONLY)
+executor = ActionExecutor(
+    ExecutorSettings(rules=ActionListRules("my_tool"), reporter=LoggingReporter(logging.getLogger("my_tool"))),
+    registry,
+)
+
+executor.execute_action({"my_tool": [["MY_add", [1, 2]], ["MY_add", {"a": 3, "b": 4}]]})
+# {"execute: ['MY_add', [1, 2]]": 3, "execute: ['MY_add', {'a': 3, 'b': 4}]": 7}
+```
+
+## The pieces
+
+| Module | What it gives you | Settings |
+|---|---|---|
+| `registry` | `CommandRegistry`: commands by name, `event_dict` as the live mapping | `CommandPolicy.FUNCTIONS_ONLY` or `ANY_CALLABLE` for caller-added commands; the exception for a refused one |
+| `action_list` | `ActionListRules` (where the list is), `LegacyActionParser` and `StrictActionParser` | document key and legacy keys (with a `DeprecationWarning`); empty list raises or returns `{}`; error messages |
+| `executor` | `ActionExecutor`: `execute_action`, `execute_files`, `add_command_to_executor` | `ExecutorSettings`: rules, parser, reporter, file reader, record key (`execute: …` or `execute[i]: …`), action rewrite |
+| `reporting` | `LoggingReporter`, `PrintReporter`, or your own `ExecutionReporter` | where events, failures and records go |
+| `package_manager` | `PackageManager`: load an installed package's members as commands, behind the [package gate](#package-gate) | member naming (`<package>_<member>` or bare), predicates, name check, errors to log |
+| `callback` | `CallbackFunctionExecutor`: run a trigger, then a callback | legacy or strict checking; raise or log and return `None` |
+| `json_io` | `ActionJsonFile`, `read_action_json`, `write_action_json`: UTF-8, locked, non-ASCII kept | exception class and message templates |
+| `file_listing` | `get_dir_files_as_list`: action files under a directory | — |
+| `socket_server` | `start_action_socket_server`: the plain TCP action server | executor, payload check, errors answered, oversize policy |
+| `builtins_policy` | `SAFE_BUILTINS`: the builtins an action list may call | — |
+
+`__all__` in `je_action_core/__init__.py` is the supported import surface.
+
+## Package gate
+
+`PackageManager.add_package_to_executor` imports a package and registers its members as commands. An action list
+that can name `os` or `subprocess` could therefore run anything. The host program decides what may load:
+
+```python
+package_manager.allow_packages("my_helpers")          # these, and their submodules
+package_manager.set_allow_arbitrary_packages(False)   # refuse everything else before importing it
+```
+
+Neither switch should ever be exposed as an action command, so an action list cannot open its own gate. A
+refused package raises the project's `refused` exception, which the executor records as that action's result.
+Until the host calls either switch, any package still loads but raises a `DeprecationWarning`. A project can
+turn the gate off (`PackageGate.OFF`) while it moves to it.
+
+## Socket server protocol
+
+`start_action_socket_server(host, port, settings)` serves on a daemon thread. A client sends one JSON action
+document per connection. The server replies with each record value on its own line, then
+`Return_Data_Over_JE`. A failure replies with the error text and the same marker. `quit_server` stops the server
+and sets `close_flag`. The server has no authentication, so bind it only to a trust## Who uses it
+
+APITestka (`AT_`, port 9939), LoadDensity (`LD_`), MailThunder (`MT_`, port 9942) and FileAutomation (`FA_`) are
+the projects this package is for. `architecture.md` §6 lists which of them have moved to it and which pieces and
+settings each one uses. LoadDensity and FileAutomation keep their own socket servers: a gevent server with
+framing, a token and TLS, and a server with authentication and an ACL.
+
+n and an ACL.
+
+## Development
+
+```bash
+pip install -e .
+pip install pytest
+python -m pytest test/
+```
+
+`architecture.md` describes the layers and the contracts with the four projects. Outstanding work is in
+`progress.md`, and finished work is recorded in `docs/updates/`.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

je_action_core-0.0.1/je_action_core/__init__.py

@@ -0,0 +1,73 @@
+"""
+je_action_core: the keyword-driven action executor shared by APITestka, LoadDensity, MailThunder and
+FileAutomation.
+
+Each project configures these pieces with its own command prefix, document key, exceptions and messages;
+``__all__`` is the supported import surface.
+"""
+from je_action_core.action_list import (
+    ActionListRules,
+    ActionParser,
+    BoundAction,
+    EmptyListPolicy,
+    LegacyActionParser,
+    ParsedAction,
+    StrictActionParser,
+)
+from je_action_core.builtins_policy import SAFE_BUILTINS, safe_builtin_commands
+from je_action_core.callback import CallbackErrorPolicy, CallbackFunctionExecutor, CallbackSettings, CallbackStyle
+from je_action_core.exceptions import (
+    ActionCoreException,
+    ActionExecuteException,
+    ActionJsonException,
+    AddCommandException,
+    CallbackExecutorException,
+    PackageNotAllowedException,
+)
+from je_action_core.executor import ActionExecutor, ExecutorSettings, indexed_record_key, plain_record_key
+from je_action_core.file_listing import get_dir_files_as_list
+from je_action_core.json_io import (
+    ActionJsonFile,
+    JsonFileMessages,
+    JsonFileSettings,
+    read_action_json,
+    write_action_json,
+)
+from je_action_core.package_manager import (
+    MemberNaming,
+    PackageGate,
+    PackageManager,
+    PackageManagerSettings,
+    is_identifier_path,
+    is_module_name,
+)
+from je_action_core.registry import Command, CommandPolicy, CommandRegistry
+from je_action_core.reporting import ExecutionReporter, LoggingReporter, PrintReporter
+from je_action_core.socket_server import (
+    END_MARKER,
+    MAX_PAYLOAD_BYTES,
+    QUIT_COMMAND,
+    ActionRequestHandler,
+    ActionTCPServer,
+    OversizePolicy,
+    SocketServerSettings,
+    start_action_socket_server,
+)
+
+__all__ = [
+    "ActionListRules", "ActionParser", "BoundAction", "EmptyListPolicy", "LegacyActionParser", "ParsedAction",
+    "StrictActionParser",
+    "SAFE_BUILTINS", "safe_builtin_commands",
+    "CallbackErrorPolicy", "CallbackFunctionExecutor", "CallbackSettings", "CallbackStyle",
+    "ActionCoreException", "ActionExecuteException", "ActionJsonException", "AddCommandException",
+    "CallbackExecutorException", "PackageNotAllowedException",
+    "ActionExecutor", "ExecutorSettings", "indexed_record_key", "plain_record_key",
+    "get_dir_files_as_list",
+    "ActionJsonFile", "JsonFileMessages", "JsonFileSettings", "read_action_json", "write_action_json",
+    "MemberNaming", "PackageGate", "PackageManager", "PackageManagerSettings", "is_identifier_path",
+    "is_module_name",
+    "Command", "CommandPolicy", "CommandRegistry",
+    "ExecutionReporter", "LoggingReporter", "PrintReporter",
+    "END_MARKER", "MAX_PAYLOAD_BYTES", "QUIT_COMMAND", "ActionRequestHandler", "ActionTCPServer",
+    "OversizePolicy", "SocketServerSettings", "start_action_socket_server",
+]

je_action_core-0.0.1/je_action_core/action_list.py

@@ -0,0 +1,173 @@
+"""
+Action documents and single actions.
+
+An action document is a list of actions, or a mapping that keeps the list under one key (``{"api_testka": [...]}``).
+An action is ``[name]``, ``[name, {kwargs}]`` or ``[name, [args]]``. :class:`ActionListRules` finds the list;
+a parser binds one action to its command.
+"""
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from enum import Enum
+from types import MappingProxyType
+from typing import Any, Callable, Iterable, Mapping, NamedTuple, Optional, Protocol, Tuple, Type
+
+from je_action_core.exceptions import ActionExecuteException
+
+Resolver = Callable[[Any], Optional[Callable[..., Any]]]
+_NAME_ONLY: int = 1
+_NAME_AND_PAYLOAD: int = 2
+# warnings.warn -> from_document -> extract -> ActionExecutor.execute_action -> the caller of execute_action
+_LEGACY_KEY_STACKLEVEL: int = 4
+
+
+class EmptyListPolicy(Enum):
+    """What an executor does with an empty action list, or with something that is not a list."""
+
+    RAISE = "raise"
+    RETURN_EMPTY = "return_empty"  # run nothing and return an empty record
+
+
+@dataclass(frozen=True)
+class ActionListRules:
+    """
+    Where a document keeps its action list and what is wrong with a bad one.
+
+    The messages are ``str.format`` templates: ``missing_message`` gets ``key``, ``not_list_message`` gets
+    ``type`` (the type name of what was found).
+    """
+
+    key: str
+    legacy_keys: Tuple[str, ...] = ()
+    error: Type[Exception] = ActionExecuteException
+    missing_message: str = "action document has no {key!r} list"
+    not_list_message: str = "action list must be a list, got {type}"
+    empty_message: str = "action list is empty"
+    empty: EmptyListPolicy = EmptyListPolicy.RAISE
+
+    def extract(self, action_list: Any) -> Optional[list]:
+        """
+        Return the actions to run, or ``None`` when :attr:`empty` says to run nothing.
+
+        :raises error: the document has no list under :attr:`key` (or a legacy key), or, under
+            :attr:`EmptyListPolicy.RAISE`, the list is not a list or is empty.
+        """
+        actions = action_list
+        if isinstance(action_list, Mapping):
+            actions = self.from_document(action_list, stacklevel=_LEGACY_KEY_STACKLEVEL)
+            if actions is None:
+                raise self.error(self.missing_message.format(key=self.key))
+        if isinstance(actions, list) and actions:
+            return actions
+        if self.empty is EmptyListPolicy.RETURN_EMPTY:
+            return None
+        if not isinstance(actions, list):
+            raise self.error(self.not_list_message.format(type=type(actions).__name__))
+        raise self.error(self.empty_message)
+
+    def from_document(self, document: Mapping[str, Any], stacklevel: int = 2) -> Any:
+        """
+        The value under :attr:`key`, else under the first legacy key present (with a ``DeprecationWarning``
+        attributed ``stacklevel`` frames up), else ``None``. The value is returned as found, unchecked.
+        """
+        if self.key in document:
+            return document[self.key]
+        for legacy_key in self.legacy_keys:
+            if legacy_key in document:
+                warnings.warn(f'the "{legacy_key}" key is deprecated; use "{self.key}"', DeprecationWarning,
+                              stacklevel=stacklevel)
+                return document[legacy_key]
+        return None
+
+
+class BoundAction(NamedTuple):
+    """An action bound to its command; calling it is ``command(*args, **kwargs)``."""
+
+    name: Any
+    command: Callable[..., Any]
+    args: Iterable[Any] = ()
+    kwargs: Mapping[str, Any] = MappingProxyType({})
+
+
+class ActionParser(Protocol):
+    """Binds one action to its command."""
+
+    def bind(self, action: Any, resolve: Resolver) -> BoundAction:
+        """Return ``action`` bound to the command ``resolve`` finds for its name; raise when it cannot."""
+
+
+@dataclass(frozen=True)
+class LegacyActionParser:
+    """
+    The rules APITestka, LoadDensity and MailThunder have always used.
+
+    The name is looked up first. A dict payload is passed as keyword arguments and any other payload is
+    unpacked as positional arguments. An unknown name or more than two elements raises ``error`` with
+    ``f"{message} {action}"``. An empty action raises ``IndexError``.
+    """
+
+    error: Type[Exception] = ActionExecuteException
+    message: str = "invalid action"
+
+    def bind(self, action: Any, resolve: Resolver) -> BoundAction:
+        """See the class docstring."""
+        command = resolve(action[0])
+        if command is None:
+            raise self.error(f"{self.message} {action}")
+        if len(action) == _NAME_AND_PAYLOAD:
+            payload = action[1]
+            if isinstance(payload, dict):
+                return BoundAction(action[0], command, (), payload)
+            return BoundAction(action[0], command, payload, {})
+        if len(action) == _NAME_ONLY:
+            return BoundAction(action[0], command)
+        raise self.error(f"{self.message} {action}")
+
+
+class ParsedAction(NamedTuple):
+    """A checked action: ``kind`` is ``"none"``, ``"kwargs"`` or ``"args"``."""
+
+    name: str
+    kind: str
+    payload: Any
+
+
+@dataclass(frozen=True)
+class StrictActionParser:
+    """
+    FileAutomation's rules: the action must be a non-empty list, the name a string and the payload a dict or a
+    list. The shape is checked before the name is looked up.
+    """
+
+    error: Type[Exception] = ActionExecuteException
+
+    def parse(self, action: Any) -> ParsedAction:
+        """Check the shape of ``action`` without looking its name up."""
+        if not isinstance(action, list) or not action:
+            raise self.error(f"malformed action: {action!r}")
+        name = action[0]
+        if not isinstance(name, str):
+            raise self.error(f"action name must be str: {action!r}")
+        if len(action) == _NAME_ONLY:
+            return ParsedAction(name, "none", None)
+        if len(action) == _NAME_AND_PAYLOAD:
+            payload = action[1]
+            if isinstance(payload, dict):
+                return ParsedAction(name, "kwargs", payload)
+            if isinstance(payload, list):
+                return ParsedAction(name, "args", payload)
+            raise self.error(f"action {name!r} payload must be dict or list, got {type(payload).__name__}")
+        raise self.error(f"action has too many elements: {action!r}")
+
+    def bind(self, action: Any, resolve: Resolver) -> BoundAction:
+        """:meth:`parse`, then look the name up; an unknown name raises ``error``."""
+        parsed = self.parse(action)
+        command = resolve(parsed.name)
+        if command is None:
+            raise self.error(f"unknown action: {parsed.name!r}")
+        if parsed.kind == "kwargs":
+            return BoundAction(parsed.name, command, (), parsed.payload)
+        if parsed.kind == "args":
+            return BoundAction(parsed.name, command, parsed.payload, {})
+        return BoundAction(parsed.name, command)

je_action_core-0.0.1/je_action_core/builtins_policy.py

@@ -0,0 +1,18 @@
+"""The Python builtins an action list may call: one allowlist for every executor that registers builtins."""
+from __future__ import annotations
+
+import builtins
+from typing import Callable, Dict, FrozenSet
+
+# Anything that can run code, reach attributes or namespaces, or touch files and stdin (eval, exec, compile,
+# __import__, open, input, getattr, globals, ...) is left out, because action lists also arrive over sockets.
+SAFE_BUILTINS: FrozenSet[str] = frozenset({
+    "abs", "all", "any", "ascii", "bin", "callable", "chr", "divmod",
+    "format", "hash", "hex", "len", "max", "min", "oct", "ord", "pow",
+    "print", "repr", "round", "sorted", "sum",
+})
+
+
+def safe_builtin_commands() -> Dict[str, Callable[..., object]]:
+    """Return ``{name: builtin}`` for every name in :data:`SAFE_BUILTINS`, in name order."""
+    return {name: getattr(builtins, name) for name in sorted(SAFE_BUILTINS)}