levistone 0.9.3__2-cp39-cp39-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, __minecraft_version__
+
+
+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: __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,241 @@
+from __future__ import annotations
+
+import glob
+import importlib
+import os
+import os.path
+import shutil
+import site
+import subprocess
+import sys
+import traceback
+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 os.environ.get("ENDSTONE_PYTHON_EXECUTABLE", None) is not None:
+        paths.append(os.environ["ENDSTONE_PYTHON_EXECUTABLE"])
+
+    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"))
+
+    paths = set(paths)
+    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", "0.7", "0.8", "0.9"]
+
+    def __init__(self, server: Server):
+        PluginLoader.__init__(self, server)
+
+        self._plugins = []
+
+        # fix sys.executable variable
+        sys.executable = find_python()
+        sys._base_executable = sys.executable
+
+        # 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, 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 BaseException as e:
+            self.server.logger.error(f"Error occurred when trying to load plugin from entry point '{ep.name}':")
+            self.server.logger.error("".join(traceback.format_exception(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.9.3'
+__version_tuple__ = version_tuple = (0, 9, 3, '')

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,17 @@
+from endstone._internal.endstone_python import (
+    Command,
+    CommandExecutor,
+    CommandSender,
+    CommandSenderWrapper,
+    ConsoleCommandSender,
+    ProxiedCommandSender,
+)
+
+__all__ = [
+    "Command",
+    "CommandExecutor",
+    "CommandSender",
+    "CommandSenderWrapper",
+    "ConsoleCommandSender",
+    "ProxiedCommandSender",
+]

endstone/config/endstone.toml

@@ -0,0 +1,4 @@
+[settings]
+# Allow clients to use their own packs when texturepack-required is set to true in server.properties.
+# Has no effect if texturepack-required is false.
+allow-client-packs = false

endstone/damage.py

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

endstone/enchantments.py

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

endstone/event.py

@@ -0,0 +1,123 @@
+from endstone._internal.endstone_python import (
+    ActorDamageEvent,
+    ActorDeathEvent,
+    ActorEvent,
+    ActorExplodeEvent,
+    ActorKnockbackEvent,
+    ActorRemoveEvent,
+    ActorSpawnEvent,
+    ActorTeleportEvent,
+    BlockBreakEvent,
+    BlockEvent,
+    BlockPlaceEvent,
+    BroadcastMessageEvent,
+    Cancellable,
+    ChunkEvent,
+    ChunkLoadEvent,
+    ChunkUnloadEvent,
+    DimensionEvent,
+    Event,
+    EventPriority,
+    LevelEvent,
+    MobEvent,
+    PacketReceiveEvent,
+    PacketSendEvent,
+    PlayerChatEvent,
+    PlayerCommandEvent,
+    PlayerDeathEvent,
+    PlayerDropItemEvent,
+    PlayerEmoteEvent,
+    PlayerEvent,
+    PlayerGameModeChangeEvent,
+    PlayerInteractActorEvent,
+    PlayerInteractEvent,
+    PlayerItemConsumeEvent,
+    PlayerJoinEvent,
+    PlayerJumpEvent,
+    PlayerKickEvent,
+    PlayerLoginEvent,
+    PlayerMoveEvent,
+    PlayerPickupItemEvent,
+    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",
+    "ChunkEvent",
+    "ChunkLoadEvent",
+    "ChunkUnloadEvent",
+    "DimensionEvent",
+    "Event",
+    "EventPriority",
+    "LevelEvent",
+    "MobEvent",
+    "PacketReceiveEvent",
+    "PacketSendEvent",
+    "PlayerEvent",
+    "PlayerChatEvent",
+    "PlayerCommandEvent",
+    "PlayerDeathEvent",
+    "PlayerDropItemEvent",
+    "PlayerEmoteEvent",
+    "PlayerGameModeChangeEvent",
+    "PlayerInteractEvent",
+    "PlayerInteractActorEvent",
+    "PlayerItemConsumeEvent",
+    "PlayerJoinEvent",
+    "PlayerJumpEvent",
+    "PlayerKickEvent",
+    "PlayerLoginEvent",
+    "PlayerMoveEvent",
+    "PlayerPickupItemEvent",
+    "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,27 @@
+from endstone._internal.endstone_python import (
+    ActionForm,
+    Divider,
+    Dropdown,
+    Header,
+    Label,
+    MessageForm,
+    ModalForm,
+    Slider,
+    StepSlider,
+    TextInput,
+    Toggle,
+)
+
+__all__ = [
+    "ActionForm",
+    "MessageForm",
+    "ModalForm",
+    "Dropdown",
+    "Label",
+    "Slider",
+    "StepSlider",
+    "TextInput",
+    "Toggle",
+    "Divider",
+    "Header",
+]

endstone/inventory.py

@@ -0,0 +1,21 @@
+from endstone._internal.endstone_python import (
+    EquipmentSlot,
+    Inventory,
+    ItemFactory,
+    ItemMeta,
+    ItemStack,
+    ItemType,
+    MapMeta,
+    PlayerInventory,
+)
+
+__all__ = [
+    "EquipmentSlot",
+    "Inventory",
+    "ItemFactory",
+    "ItemMeta",
+    "ItemStack",
+    "ItemType",
+    "MapMeta",
+    "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/map.py

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

endstone/permissions.py

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