levistone 0.6.1__1-cp313-cp313-win_amd64.whl

endstone/_internal/metrics.py

@@ -0,0 +1,101 @@
+import platform
+from pathlib import Path
+from typing import Any, Dict
+
+import psutil
+from endstone_bstats import AdvancedPie, DrilldownPie, MetricsBase, MetricsConfig, SimplePie, SingleLineChart
+
+from endstone import Server
+
+
+class Metrics(MetricsBase):
+    def __init__(self, server: Server):
+        self._server = server
+
+        # Get the config file
+        bstats_folder = Path("plugins") / "bstats"
+        config_file = bstats_folder / "config.toml"
+        self._config = MetricsConfig(config_file, True)
+
+        super().__init__(
+            platform="server-implementation",
+            server_uuid=self._config.server_uuid,
+            service_id=23296,
+            log_errors=self._config.log_errors_enabled,
+            log_sent_data=self._config.log_sent_data_enabled,
+            log_response_status_text=self._config.log_response_status_text_enabled,
+        )
+
+        self.add_custom_chart(SingleLineChart("players", lambda: len(self._server.online_players)))
+        self.add_custom_chart(SimplePie("endstone_version", lambda: self._server.version))
+        self.add_custom_chart(SimplePie("minecraft_version", lambda: self._server.minecraft_version))
+        self.add_custom_chart(DrilldownPie("online_mode", self._get_online_mode))
+        self.add_custom_chart(DrilldownPie("python_version", self._get_python_version))
+        self.add_custom_chart(AdvancedPie("player_platform", self._get_player_platforms))
+        self.add_custom_chart(AdvancedPie("player_game_version", self._get_player_game_versions))
+
+    @property
+    def enabled(self) -> bool:
+        return self._config.enabled
+
+    @property
+    def service_enabled(self) -> bool:
+        return True
+
+    def append_platform_data(self, platform_data: Dict[str, Any]) -> None:
+        os_name = platform.system()
+        if os_name == "Windows":
+            platform_data["osName"] = f"Windows {platform.release()}"
+            platform_data["osVersion"] = platform.version()
+        elif os_name == "Linux":
+            platform_data["osName"] = "Linux"
+            platform_data["osVersion"] = platform.release()
+
+        os_arch = platform.machine().lower()
+        if os_arch == "x86_64":
+            os_arch = "amd64"
+        platform_data["osArch"] = os_arch
+        platform_data["coreCount"] = psutil.cpu_count(logical=False)
+
+    def log_info(self, message: str) -> None:
+        self._server.logger.info(message)
+
+    def log_error(self, message: str, exception: Exception) -> None:
+        self._server.logger.warning(f"{message}: {exception}")
+
+    def _get_online_mode(self) -> dict[str, dict[str, int]]:
+        value = "true" if self._server.online_mode else "false"
+        return {
+            value: {
+                value: 1,
+            },
+        }
+
+    def _get_python_version(self) -> dict[str, dict[str, int]]:
+        python_impl = platform.python_implementation()
+        major, minor, patch = platform.python_version_tuple()
+        return {
+            f"{python_impl} {major}.{minor}": {
+                f"{major}.{minor}.{patch}": 1,
+            },
+        }
+
+    def _get_player_platforms(self) -> dict[str, int]:
+        result: dict[str, int] = {}
+        for player in self._server.online_players:
+            if player.device_os not in result:
+                result[player.device_os] = 1
+            else:
+                result[player.device_os] += 1
+
+        return result
+
+    def _get_player_game_versions(self) -> dict[str, int]:
+        result: dict[str, int] = {}
+        for player in self._server.online_players:
+            if player.game_version not in result:
+                result[player.game_version] = 1
+            else:
+                result[player.game_version] += 1
+
+        return result

endstone/_internal/plugin_loader.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import glob
+import importlib
+import os
+import os.path
+import shutil
+import site
+import subprocess
+import sys
+import warnings
+
+import pkginfo
+from importlib_metadata import EntryPoint, distribution, entry_points, metadata
+
+from endstone import Server
+from endstone._internal.metrics import Metrics
+from endstone.command import Command
+from endstone.permissions import Permission, PermissionDefault
+from endstone.plugin import Plugin, PluginDescription, PluginLoader, PluginLoadOrder
+
+__all__ = ["PythonPluginLoader"]
+
+warnings.simplefilter(action="always", category=FutureWarning)
+
+
+def find_python():
+    paths = []
+    if sys.platform == "win32":
+        paths.append(os.path.join(sys.base_prefix, "python.exe"))
+    else:
+        paths.append(
+            os.path.join(sys.base_prefix, "bin", "python" + f"{sys.version_info.major}.{sys.version_info.minor}")
+        )
+        paths.append(os.path.join(sys.base_prefix, "bin", "python" + f"{sys.version_info.major}"))
+        paths.append(os.path.join(sys.base_prefix, "bin", "python"))
+
+    for path in paths:
+        if os.path.isfile(path):
+            return path
+
+    raise RuntimeError(f"Unable to find Python executable. Attempted paths: {paths}")
+
+
+class PythonPluginLoader(PluginLoader):
+    SUPPORTED_API = ["0.5", "0.6"]
+
+    def __init__(self, server: Server):
+        PluginLoader.__init__(self, server)
+
+        self._plugins = []
+
+        # fix sys.executable variable
+        sys.executable = find_python()
+
+        # invalidate previously loaded modules (in case of /reload)
+        importlib.invalidate_caches()
+        for module in list(sys.modules.keys()):
+            if module.startswith("endstone_"):
+                del sys.modules[module]
+
+        # prepare the temp site-dir
+        self._prefix = os.path.join("plugins", ".local")
+        shutil.rmtree(self._prefix, ignore_errors=True)
+        for site_dir in site.getsitepackages(prefixes=[self._prefix]):
+            site.addsitedir(site_dir)
+
+        # initialize the metrics
+        self._metrics = Metrics(self.server)
+
+    def __del__(self):
+        self._metrics.shutdown()
+
+    @staticmethod
+    def _build_commands(commands: dict) -> list[Command]:
+        results = []
+        for name, command in commands.items():
+            command = Command(name, **command)
+            results.append(command)
+        return results
+
+    @staticmethod
+    def _build_permissions(permissions: dict) -> list[Permission]:
+        results = []
+        for name, permission in permissions.items():
+            if "default" in permission:
+                value = permission["default"]
+                if isinstance(value, bool):
+                    permission["default"] = PermissionDefault.TRUE if value else PermissionDefault.FALSE
+                elif isinstance(value, str):
+                    permission["default"] = PermissionDefault.__members__[value.strip().replace(" ", "_").upper()]
+                elif not isinstance(value, PermissionDefault):
+                    raise TypeError(f"Invalid value for default permission: {value}")
+
+            permission = Permission(name, **permission)
+            results.append(permission)
+        return results
+
+    def load_plugin(self, file: str) -> Plugin | None:
+        env = os.environ.copy()
+        env.pop("LD_PRELOAD", "")
+
+        dist_name = pkginfo.Wheel(file).name
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                file,
+                "--prefix",
+                self._prefix,
+                "--quiet",
+                "--no-warn-script-location",
+                "--disable-pip-version-check",
+            ],
+            env=env,
+        )
+
+        eps = distribution(dist_name).entry_points.select(group="endstone")
+        for ep in eps:
+            plugin = self._load_plugin_from_ep(ep)
+            if plugin:
+                return plugin
+
+        return None
+
+    def load_plugins(self, directory: str) -> list[Plugin]:
+        loaded_plugins = []
+
+        if not self._plugins:
+            eps = entry_points(group="endstone")
+            for ep in eps:
+                plugin = self._load_plugin_from_ep(ep)
+                if plugin:
+                    loaded_plugins.append(plugin)
+
+        for file in glob.glob(os.path.join(directory, "*.whl")):
+            plugin = self.load_plugin(file)
+            if plugin:
+                loaded_plugins.append(plugin)
+
+        return loaded_plugins
+
+    def _load_plugin_from_ep(self, ep: EntryPoint) -> Plugin | None:
+        # enforce naming convention
+        if not ep.dist.name.replace("_", "-").startswith("endstone-"):
+            self.server.logger.error(
+                f"Error occurred when trying to load plugin from entry point '{ep.name}': Invalid name."
+            )
+            self.server.logger.error(
+                f"The name of distribution ({ep.dist.name}) does not start with 'endstone-' or 'endstone_'."
+            )
+            return None
+
+        dist_name = "endstone-" + ep.name.replace("_", "-")
+        if ep.dist.name.replace("_", "-") != dist_name:
+            self.server.logger.error(
+                f"Error occurred when trying to load plugin from entry point '{ep.name}': Invalid name."
+            )
+            self.server.logger.error("You need to make **ONE** of the following changes.")
+            self.server.logger.error(
+                f"* If you intend to use the current entry point name ({ep.name}), "
+                f"please change the distribution name from '{ep.dist.name}' to '{dist_name}'."
+            )
+            self.server.logger.error(
+                f"* If not, " f"please change the entry point name from '{ep.name}' to '{ep.dist.name[9:]}'."
+            )
+            return None
+
+        # get distribution metadata
+        try:
+            plugin_metadata = metadata(ep.dist.name).json
+            cls = ep.load()
+        except Exception as e:
+            self.server.logger.error(f"Error occurred when trying to load plugin from entry point '{ep.name}': {e}")
+            return None
+
+        # prepare plugin description
+        cls_attr = dict(cls.__dict__)
+        name = cls_attr.pop("name", ep.name.replace("-", "_"))
+        version = cls_attr.pop("version", plugin_metadata["version"])
+
+        api_version = cls_attr.pop("api_version", None)
+        if api_version is None:
+            self.server.logger.warning(
+                f"Plugin '{name}' does not specify an API version. This may prevent the plugin from loading in "
+                f"future releases."
+            )
+        elif api_version not in self.SUPPORTED_API:
+            self.server.logger.error(
+                f"Error occurred when trying to load plugin '{name}': plugin was designed for API version: "
+                f"{api_version} which is not compatible with this server."
+            )
+            return None
+
+        load = cls_attr.pop("load", None)
+        if load is not None:
+            if isinstance(load, str):
+                load = PluginLoadOrder.__members__[load.strip().replace(" ", "_").upper()]
+            elif not isinstance(load, PluginLoadOrder):
+                raise TypeError(f"Invalid value for load order: {load}")
+
+        description = cls_attr.pop("description", plugin_metadata.get("summary", None))
+        authors = cls_attr.pop("authors", plugin_metadata.get("author_email", "").split(","))
+        website = cls_attr.pop("website", "; ".join(plugin_metadata.get("project_url", [])))
+
+        commands = cls_attr.pop("commands", {})
+        commands = self._build_commands(commands)
+
+        permissions = cls_attr.pop("permissions", {})
+        permissions = self._build_permissions(permissions)
+
+        plugin_description = PluginDescription(
+            name=name,
+            version=version,
+            load=load,
+            description=description,
+            authors=authors,
+            website=website,
+            commands=commands,
+            permissions=permissions,
+            **cls_attr,
+        )
+
+        # instantiate plugin
+        plugin = cls()
+        if not isinstance(plugin, Plugin):
+            self.server.logger.error(f"Main class {ep.value} does not extend endstone.plugin.Plugin")
+            return None
+
+        plugin._description = plugin_description
+        self._plugins.append(plugin)
+        return plugin

endstone/_internal/version.py

@@ -0,0 +1,14 @@
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1, '')

endstone/actor.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Actor, Mob
+
+__all__ = ["Actor", "Mob"]

endstone/ban.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import IpBanEntry, IpBanList, PlayerBanEntry, PlayerBanList
+
+__all__ = ["IpBanEntry", "IpBanList", "PlayerBanEntry", "PlayerBanList"]

endstone/block.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Block, BlockData, BlockFace, BlockState
+
+__all__ = ["Block", "BlockData", "BlockFace", "BlockState"]

endstone/boss.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import BarColor, BarFlag, BarStyle, BossBar
+
+__all__ = ["BossBar", "BarColor", "BarFlag", "BarStyle"]

endstone/command.py

@@ -0,0 +1,11 @@
+from endstone._internal.endstone_python import (
+    Command,
+    CommandExecutor,
+    CommandSender,
+    CommandSenderWrapper,
+    ConsoleCommandSender,
+    ProxiedCommandSender,
+)
+
+__all__ = ["Command", "CommandExecutor", "CommandSender", "CommandSenderWrapper", "ConsoleCommandSender",
+           "ProxiedCommandSender", ]

endstone/damage.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import DamageSource
+
+__all__ = ["DamageSource"]

endstone/event.py

@@ -0,0 +1,99 @@
+from endstone._internal.endstone_python import (
+    ActorDamageEvent,
+    ActorDeathEvent,
+    ActorEvent,
+    ActorExplodeEvent,
+    ActorKnockbackEvent,
+    ActorRemoveEvent,
+    ActorSpawnEvent,
+    ActorTeleportEvent,
+    BlockBreakEvent,
+    BlockEvent,
+    BlockPlaceEvent,
+    BroadcastMessageEvent,
+    Cancellable,
+    Event,
+    EventPriority,
+    MobEvent,
+    PlayerChatEvent,
+    PlayerCommandEvent,
+    PlayerDeathEvent,
+    PlayerEmoteEvent,
+    PlayerEvent,
+    PlayerGameModeChangeEvent,
+    PlayerInteractActorEvent,
+    PlayerInteractEvent,
+    PlayerJoinEvent,
+    PlayerKickEvent,
+    PlayerLoginEvent,
+    PlayerQuitEvent,
+    PlayerRespawnEvent,
+    PlayerTeleportEvent,
+    PluginDisableEvent,
+    PluginEnableEvent,
+    ScriptMessageEvent,
+    ServerCommandEvent,
+    ServerEvent,
+    ServerListPingEvent,
+    ServerLoadEvent,
+    ThunderChangeEvent,
+    WeatherChangeEvent,
+    WeatherEvent,
+)
+
+__all__ = [
+    "event_handler",
+    "ActorEvent",
+    "ActorDamageEvent",
+    "ActorDeathEvent",
+    "ActorExplodeEvent",
+    "ActorKnockbackEvent",
+    "ActorRemoveEvent",
+    "ActorSpawnEvent",
+    "ActorTeleportEvent",
+    "BlockEvent",
+    "BlockBreakEvent",
+    "BlockPlaceEvent",
+    "Cancellable",
+    "Event",
+    "EventPriority",
+    "MobEvent",
+    "PlayerEvent",
+    "PlayerChatEvent",
+    "PlayerCommandEvent",
+    "PlayerDeathEvent",
+    "PlayerEmoteEvent",
+    "PlayerGameModeChangeEvent",
+    "PlayerInteractEvent",
+    "PlayerInteractActorEvent",
+    "PlayerJoinEvent",
+    "PlayerKickEvent",
+    "PlayerLoginEvent",
+    "PlayerQuitEvent",
+    "PlayerRespawnEvent",
+    "PlayerTeleportEvent",
+    "BroadcastMessageEvent",
+    "PluginEnableEvent",
+    "PluginDisableEvent",
+    "ScriptMessageEvent",
+    "ServerEvent",
+    "ServerCommandEvent",
+    "ServerListPingEvent",
+    "ServerLoadEvent",
+    "ThunderChangeEvent",
+    "WeatherEvent",
+    "WeatherChangeEvent",
+]
+
+
+def event_handler(func=None, *, priority: EventPriority = EventPriority.NORMAL, ignore_cancelled: bool = False):
+    def decorator(f):
+        setattr(f, "_is_event_handler", True)
+        setattr(f, "_priority", priority)
+        setattr(f, "_ignore_cancelled", ignore_cancelled)
+        return f
+
+    if func:
+        return decorator(func)
+
+    return decorator

endstone/form.py

@@ -0,0 +1,13 @@
+from endstone._internal.endstone_python import (
+    ActionForm,
+    Dropdown,
+    Label,
+    MessageForm,
+    ModalForm,
+    Slider,
+    StepSlider,
+    TextInput,
+    Toggle,
+)
+
+__all__ = ["ActionForm", "MessageForm", "ModalForm", "Dropdown", "Label", "Slider", "StepSlider", "TextInput", "Toggle"]

endstone/inventory.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Inventory, ItemStack, PlayerInventory
+
+__all__ = ["ItemStack", "Inventory", "PlayerInventory"]

endstone/lang.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Language, Translatable
+
+__all__ = ["Language", "Translatable"]

endstone/level.py

@@ -0,0 +1,9 @@
+from endstone._internal.endstone_python import Chunk, Dimension, Level, Location, Position
+
+__all__ = [
+    "Chunk",
+    "Dimension",
+    "Level",
+    "Location",
+    "Position",
+]

endstone/network.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Packet, PacketType, SpawnParticleEffectPacket
+
+__all__ = ["Packet", "PacketType", "SpawnParticleEffectPacket"]

endstone/permissions.py

@@ -0,0 +1,9 @@
+from endstone._internal.endstone_python import (
+    Permissible,
+    Permission,
+    PermissionAttachment,
+    PermissionAttachmentInfo,
+    PermissionDefault,
+)
+
+__all__ = ["Permission", "Permissible", "PermissionAttachment", "PermissionAttachmentInfo", "PermissionDefault"]

endstone/plugin.py

@@ -0,0 +1,137 @@
+import inspect
+import os
+import shutil
+import typing
+from pathlib import Path
+
+import tomlkit
+from importlib_resources import as_file, files
+
+from endstone._internal import endstone_python
+from endstone._internal.endstone_python import (
+    PluginCommand,
+    PluginDescription,
+    PluginLoader,
+    PluginLoadOrder,
+    PluginManager,
+)
+from endstone.event import Event
+
+__all__ = [
+    "Plugin",
+    "PluginCommand",
+    "PluginDescription",
+    "PluginLoader",
+    "PluginLoadOrder",
+    "PluginManager",
+]
+
+
+class Plugin(endstone_python.Plugin):
+    # Metadata
+    name = None
+    version = None
+    api_version = None
+
+    # Optional metadata
+    description = None
+    load = None
+    authors = None
+    contributors = None
+    website = None
+    prefix = None
+
+    # Dependencies
+    provides = None
+    depend = None
+    soft_depend = None
+    load_before = None
+
+    # Command
+    commands = None
+
+    # Permissions
+    default_permission = None
+    permissions = None
+
+    def __init__(self):
+        endstone_python.Plugin.__init__(self)
+        self._description: typing.Optional[PluginDescription] = None
+        self._config = None
+        self._listeners = []
+
+    def _get_description(self) -> PluginDescription:
+        return self._description
+
+    def register_events(self, listener: object) -> None:
+        if not self.is_enabled:
+            raise RuntimeError(f"Plugin {self.name} attempted to register events while not enabled")
+
+        if listener is None:
+            raise ValueError("Listener cannot be None")
+
+        self._listeners.append(listener)
+
+        for attr_name in dir(listener):
+            if attr_name == "config":
+                continue
+
+            func = getattr(listener, attr_name)
+            if not callable(func) or not getattr(func, "_is_event_handler", False):
+                continue
+
+            sig = inspect.signature(func)
+            params = list(sig.parameters.values())
+            if (
+                len(params) != 1
+                or not inspect.isclass(params[0].annotation)
+                or not issubclass(params[0].annotation, Event)
+            ):
+                self.logger.error(
+                    f"Plugin {self.name} attempted to register an invalid "
+                    f"event handler signature: {attr_name}: {sig}"
+                )
+                continue
+
+            event_cls = params[0].annotation
+            priority = getattr(func, "_priority")
+            ignore_cancelled = getattr(func, "_ignore_cancelled")
+            self.server.plugin_manager.register_event(
+                getattr(event_cls, "NAME", event_cls.__name__), func, priority, self, ignore_cancelled
+            )
+
+    @property
+    def config(self) -> dict:
+        if self._config is None:
+            self._config = self.reload_config()
+
+        return self._config
+
+    def reload_config(self) -> dict:
+        with (Path(self.data_folder) / "config.toml").open("r", encoding="utf-8") as f:
+            self._config = tomlkit.load(f)
+
+        return self._config
+
+    def save_config(self) -> None:
+        if self._config is None:
+            return
+
+        with (Path(self.data_folder) / "config.toml").open("w", encoding="utf-8") as f:
+            tomlkit.dump(self._config, f)
+
+    def save_default_config(self) -> None:
+        if not (Path(self.data_folder) / "config.toml").exists():
+            self.save_resources("config.toml", False)
+
+    def save_resources(self, path: str, replace: bool = False) -> None:
+        path = path.replace(os.pathsep, "/")
+        out_path = Path(self.data_folder) / path
+        if not out_path.exists() or replace:
+            out_path.parent.mkdir(exist_ok=True)
+            resource = files(self.__class__.__module__).joinpath(path)
+            with as_file(resource) as f:
+                shutil.copy(f, out_path)
+        else:
+            self.logger.warning(f"Could not save {out_path.name} to {out_path}: file already exists.")
+            return

endstone/scheduler.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Scheduler, Task
+
+__all__ = ["Scheduler", "Task"]

endstone/scoreboard.py

@@ -0,0 +1,3 @@
+from endstone._internal.endstone_python import Criteria, DisplaySlot, Objective, ObjectiveSortOrder, Score, Scoreboard
+
+__all__ = ["Criteria", "DisplaySlot", "Objective", "ObjectiveSortOrder", "Score", "Scoreboard"]