pumpkin-api-py 0.1.0.dev1__py3-none-any.whl → 0.1.0.dev2__py3-none-any.whl

pumpkin_api/__init__.py

@@ -1,139 +1,41 @@
-# pumpkin-api-py: Pumpkin plugin API for Python
-# Copyright (C) 2024 alex
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import sys
-import os
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'wit'))
-
-from typing import Dict, Callable, Any, Type, Optional, List, Union
-
-from .wit.wit_world.imports import (
-    server, event, command, context, text, scheduler, 
-    logging, gui, scoreboard, i18n, player, world, 
-    common, block_entity, permission
+from wit_world.exports import metadata
+from wit_world.imports import (
+    block_entity,
+    command,
+    common,
+    context,
+    event,
+    gui,
+    i18n,
+    logging,
+    permission,
+    player,
+    scheduler,
+    scoreboard,
+    server,
+    text,
+    world,
 )
-from .wit.wit_world.exports import metadata
-from componentize_py_types import Err
-
-class PluginMetadata(metadata.PluginMetadata):
-    pass
-
-_PLUGIN_INSTANCE: Optional['Plugin'] = None
-_EVENT_HANDLERS: Dict[int, Callable[[server.Server, Any], Any]] = {}
-_COMMAND_HANDLERS: Dict[int, Callable[[command.CommandSender, server.Server, command.ConsumedArgs], int]] = {}
-_TASK_HANDLERS: Dict[int, Callable[[server.Server], None]] = {}
-_NEXT_HANDLER_ID: int = 0
-
-def _get_next_handler_id() -> int:
-    global _NEXT_HANDLER_ID
-    handler_id = _NEXT_HANDLER_ID
-    _NEXT_HANDLER_ID += 1
-    return handler_id
-
-class Plugin:
-    def __init__(self):
-        self._pending_events = []
-
-    def metadata(self) -> PluginMetadata:
-        raise NotImplementedError
-
-    def on_load(self, ctx: context.Context) -> None:
-        for event_type, handler, priority, blocking in self._pending_events:
-            self.register_event(ctx, event_type, handler, priority, blocking)
-
-    def on_unload(self, ctx: context.Context) -> None:
-        pass
-
-    def register_event(self, ctx: context.Context, event_type: event.EventType, handler: Callable[[server.Server, Any], Any], priority=event.EventPriority.NORMAL, blocking=True):
-        handler_id = _get_next_handler_id()
-        _EVENT_HANDLERS[handler_id] = handler
-        ctx.register_event(handler_id, event_type, priority, blocking)
-
-    def register_command(self, ctx: context.Context, cmd: command.Command, handler: Callable[[command.CommandSender, server.Server, command.ConsumedArgs], int], permission: str = ""):
-        handler_id = _get_next_handler_id()
-        _COMMAND_HANDLERS[handler_id] = handler
-        cmd.execute_with_handler_id(handler_id)
-        ctx.register_command(cmd, permission)
-
-    def schedule_delayed_task(self, delay_ticks: int, handler: Callable[[server.Server], None]) -> int:
-        handler_id = _get_next_handler_id()
-        _TASK_HANDLERS[handler_id] = handler
-        return scheduler.schedule_delayed_task(handler_id, delay_ticks)
-
-    def schedule_repeating_task(self, delay_ticks: int, period_ticks: int, handler: Callable[[server.Server], None]) -> int:
-        handler_id = _get_next_handler_id()
-        _TASK_HANDLERS[handler_id] = handler
-        return scheduler.schedule_repeating_task(handler_id, delay_ticks, period_ticks)
-
-    def event_handler(self, event_type: event.EventType, priority=event.EventPriority.NORMAL, blocking=True):
-        def decorator(func):
-            self._pending_events.append((event_type, func, priority, blocking))
-            return func
-        return decorator
-
-def register_plugin(plugin_class: Type[Plugin]):
-    global _PLUGIN_INSTANCE
-    _PLUGIN_INSTANCE = plugin_class()
-
-class WitWorldImpl:
-    def init_plugin(self) -> None:
-        pass
-
-    def on_load(self, ctx: context.Context) -> None:
-        if _PLUGIN_INSTANCE:
-            try:
-                # In WIT, on-load returns result<_, string>
-                # componentize-py handles this by expecting None or raising Err
-                _PLUGIN_INSTANCE.on_load(ctx)
-            except Exception as e:
-                raise Err(str(e))
-
-    def on_unload(self, ctx: context.Context) -> None:
-        if _PLUGIN_INSTANCE:
-            try:
-                _PLUGIN_INSTANCE.on_unload(ctx)
-            except Exception as e:
-                raise Err(str(e))
-
-    def handle_event(self, event_id: int, srv: server.Server, evt: event.Event) -> event.Event:
-        if event_id in _EVENT_HANDLERS:
-            # Pass the inner event data to the handler
-            result = _EVENT_HANDLERS[event_id](srv, evt.value)
-            # If the handler returns something, assume it's the updated event data
-            if result is not None:
-                evt.value = result
-        return evt
-
-    def handle_command(self, command_id: int, sender: command.CommandSender, srv: server.Server, args: command.ConsumedArgs) -> int:
-        if command_id in _COMMAND_HANDLERS:
-            try:
-                return _COMMAND_HANDLERS[command_id](sender, srv, args)
-            except Exception as e:
-                if hasattr(e, 'value') and isinstance(e.value, (command.CommandError_InvalidConsumption, command.CommandError_InvalidRequirement, command.CommandError_PermissionDenied, command.CommandError_CommandFailed)):
-                     raise e
-                raise Err(command.CommandError_CommandFailed(text.TextComponent_text(str(e))))
-
-        raise Err(command.CommandError_CommandFailed(text.TextComponent_text(f"no handler registered for command id {command_id}")))
-
-    def handle_task(self, handler_id: int, srv: server.Server) -> None:
-        if handler_id in _TASK_HANDLERS:
-            _TASK_HANDLERS[handler_id](srv)
 
-class MetadataImpl:
-    def get_metadata(self) -> metadata.PluginMetadata:
-        if _PLUGIN_INSTANCE:
-            return _PLUGIN_INSTANCE.metadata()
-        return PluginMetadata("unknown", "0.0.0", [], "No metadata")
+from .impl import Plugin, register_plugin
+
+__all__ = [
+    "Plugin",
+    "register_plugin",
+    "block_entity",
+    "command",
+    "common",
+    "context",
+    "event",
+    "gui",
+    "i18n",
+    "logging",
+    "metadata",
+    "permission",
+    "player",
+    "scheduler",
+    "server",
+    "scoreboard",
+    "text",
+    "world",
+]

pumpkin_api/build.py

@@ -1,40 +1,69 @@
 import argparse
-import subprocess
-import sys
 import os
+import tempfile
+
+import componentize_py
+
+
+def _build_entrypoint_wrapper(app_module: str, wrapper_dir: str) -> str:
+    wrapper_name = "_pumpkin_componentize_entry"
+    wrapper_path = os.path.join(wrapper_dir, f"{wrapper_name}.py")
+
+    with open(wrapper_path, "w", encoding="utf-8") as wrapper_file:
+        wrapper_file.write(
+            "from pathlib import Path\n"
+            "from pumpkin_api.impl import MetadataImpl, WitWorldImpl\n\n"
+            "WitWorld = WitWorldImpl\n"
+            "Metadata = MetadataImpl\n\n"
+            f"import {app_module}\n"
+        )
+    return wrapper_name
+
 
 def main():
     parser = argparse.ArgumentParser(description="Build a Pumpkin Python plugin")
-    parser.add_argument("app_module", help="The python module containing the plugin (e.g. 'main')")
-    parser.add_argument("-o", "--output", default="plugin.wasm", help="Output wasm file name")
+    parser.add_argument(
+        "app_module", help="The python module containing the plugin (e.g. 'main')"
+    )
+    parser.add_argument(
+        "-o", "--output", default="plugin.wasm", help="Output wasm file name"
+    )
     args = parser.parse_args()
 
     import pumpkin_api
+
     pkg_dir = os.path.dirname(pumpkin_api.__file__)
-    # Check if we are in a source checkout with the submodule
-    repo_wit_dir = os.path.join(os.path.dirname(os.path.dirname(pkg_dir)), "pumpkin-wit", "pumpkin-plugin-wit", "v0.1.0")
-    if os.path.exists(repo_wit_dir):
-        wit_dir = repo_wit_dir
-    else:
-        wit_dir = os.path.join(pkg_dir, "wit_files")
-    
+    # In source checkout, they are in wit_files/repo/...
+    # In installed package, they are directly in wit_files/
+    wit_dir = os.path.join(
+        pkg_dir, "..", "..", "wit", "repo", "pumpkin-plugin-wit", "v0.1.0"
+    )
+    if not os.path.exists(wit_dir):
+        wit_dir = os.path.join(pkg_dir, "wit")
+
     # Pass the parent directory of pumpkin_api to componentize-py so it can resolve `pumpkin_api` module
     # in case it's not installed in a standard site-packages (e.g. editable install or no venv)
     pkg_parent_dir = os.path.dirname(pkg_dir)
 
-    cmd = [
-        "componentize-py",
-        "-d", wit_dir,
-        "-w", "plugin",
-        "componentize", args.app_module,
-        "-o", args.output,
-        "-p", ".",
-        "-p", pkg_parent_dir
-    ]
-
-    print(f"Running: {' '.join(cmd)}")
-    result = subprocess.run(cmd)
-    sys.exit(result.returncode)
+    with tempfile.TemporaryDirectory(prefix="pumpkin-api-build-") as wrapper_dir:
+        wrapper_module = _build_entrypoint_wrapper(args.app_module, wrapper_dir)
+
+        componentize_py.componentize(
+            wit_path=[wit_dir],
+            worlds=[],
+            features=[],
+            all_features=False,
+            world_module="wit_world",
+            python_path=[".", pkg_parent_dir, wrapper_dir],
+            module_worlds=[],
+            app_name=wrapper_module,
+            output_path=args.output,
+            stub_wasi=False,
+            import_interface_names=[],
+            export_interface_names=[],
+            full_names=False,
+        )
+
 
 if __name__ == "__main__":
     main()

pumpkin_api/impl.py

@@ -0,0 +1,216 @@
+# pumpkin-api-py: Pumpkin plugin API for Python
+# Copyright (C) 2024 alex
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import traceback
+from typing import Any, Callable, Dict, Optional, Type
+
+import wit_world
+import wit_world.exports
+from componentize_py_types import Err
+from wit_world.exports import metadata
+from wit_world.imports import command, context, event, scheduler, server, text
+
+_PLUGIN_INSTANCE: Optional["Plugin"] = None
+_EVENT_HANDLERS: Dict[int, Callable[[server.Server, Any], Any]] = {}
+_COMMAND_HANDLERS: Dict[
+    int, Callable[[command.CommandSender, server.Server, command.ConsumedArgs], int]
+] = {}
+_TASK_HANDLERS: Dict[int, Callable[[server.Server], None]] = {}
+_NEXT_HANDLER_ID: int = 0
+
+
+def _exception_message(exc: Exception) -> str:
+    if hasattr(exc, "value"):
+        value = getattr(exc, "value")
+        if value is not None:
+            return str(value)
+    message = str(exc)
+    if message:
+        return message
+    return "".join(traceback.format_exception_only(type(exc), exc)).strip()
+
+
+def _format_exception(exc: Exception) -> str:
+    details = "".join(
+        traceback.format_exception(type(exc), exc, exc.__traceback__)
+    ).strip()
+    if details:
+        return details
+    return _exception_message(exc)
+
+
+def _get_next_handler_id() -> int:
+    global _NEXT_HANDLER_ID
+    handler_id = _NEXT_HANDLER_ID
+    _NEXT_HANDLER_ID += 1
+    return handler_id
+
+
+class Plugin:
+    def __init__(self):
+        self._pending_events = []
+
+    def metadata(self) -> metadata.PluginMetadata:
+        raise NotImplementedError
+
+    def on_load(self, ctx: context.Context) -> None:
+        for event_type, handler, priority, blocking in self._pending_events:
+            self.register_event(ctx, event_type, handler, priority, blocking)
+
+    def on_unload(self, ctx: context.Context) -> None:
+        pass
+
+    def register_event(
+        self,
+        ctx: context.Context,
+        event_type: event.EventType,
+        handler: Callable[[server.Server, Any], Any],
+        priority=event.EventPriority.NORMAL,
+        blocking=True,
+    ):
+        handler_id = _get_next_handler_id()
+        _EVENT_HANDLERS[handler_id] = handler
+        ctx.register_event(handler_id, event_type, priority, blocking)
+
+    def register_command(
+        self,
+        ctx: context.Context,
+        cmd: command.Command,
+        handler: Callable[
+            [command.CommandSender, server.Server, command.ConsumedArgs], int
+        ],
+        permission: str = "",
+    ):
+        handler_id = _get_next_handler_id()
+        _COMMAND_HANDLERS[handler_id] = handler
+        cmd.execute_with_handler_id(handler_id)
+        ctx.register_command(cmd, permission)
+
+    def schedule_delayed_task(
+        self, delay_ticks: int, handler: Callable[[server.Server], None]
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _TASK_HANDLERS[handler_id] = handler
+        return scheduler.schedule_delayed_task(handler_id, delay_ticks)
+
+    def schedule_repeating_task(
+        self,
+        delay_ticks: int,
+        period_ticks: int,
+        handler: Callable[[server.Server], None],
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _TASK_HANDLERS[handler_id] = handler
+        return scheduler.schedule_repeating_task(handler_id, delay_ticks, period_ticks)
+
+    def event_handler(
+        self,
+        event_type: event.EventType,
+        priority=event.EventPriority.NORMAL,
+        blocking=True,
+    ):
+        def decorator(func):
+            self._pending_events.append((event_type, func, priority, blocking))
+            return func
+
+        return decorator
+
+
+def register_plugin(plugin_class: Type[Plugin]):
+    global _PLUGIN_INSTANCE
+    _PLUGIN_INSTANCE = plugin_class()
+
+
+class WitWorldImpl(wit_world.WitWorld):
+    def init_plugin(self) -> None:
+        pass
+
+    def on_load(self, context: context.Context) -> None:
+        if _PLUGIN_INSTANCE:
+            try:
+                # In WIT, on-load returns result<_, string>
+                # componentize-py handles this by expecting None or raising Err
+                _PLUGIN_INSTANCE.on_load(context)
+            except Err as e:
+                raise Err(_exception_message(e))
+            except Exception as e:
+                raise Err(_format_exception(e))
+
+    def on_unload(self, context: context.Context) -> None:
+        if _PLUGIN_INSTANCE:
+            try:
+                _PLUGIN_INSTANCE.on_unload(context)
+            except Err as e:
+                raise Err(_exception_message(e))
+            except Exception as e:
+                raise Err(_format_exception(e))
+
+    def handle_event(
+        self, event_id: int, server: server.Server, event: event.Event
+    ) -> event.Event:
+        if event_id in _EVENT_HANDLERS:
+            # Pass the inner event data to the handler
+            result = _EVENT_HANDLERS[event_id](server, event.value)
+            # If the handler returns something, assume it's the updated event data
+            if result is not None:
+                event.value = result
+        return event
+
+    def handle_command(
+        self,
+        command_id: int,
+        sender: command.CommandSender,
+        server: server.Server,
+        args: command.ConsumedArgs,
+    ) -> int:
+        if command_id in _COMMAND_HANDLERS:
+            try:
+                return _COMMAND_HANDLERS[command_id](sender, server, args)
+            except Exception as e:
+                if hasattr(e, "value") and isinstance(
+                    e.value,
+                    (
+                        command.CommandError_InvalidConsumption,
+                        command.CommandError_InvalidRequirement,
+                        command.CommandError_PermissionDenied,
+                        command.CommandError_CommandFailed,
+                    ),
+                ):
+                    raise e
+                raise Err(
+                    command.CommandError_CommandFailed(
+                        text.TextComponent.text(_format_exception(e))
+                    )
+                )
+
+        raise Err(
+            command.CommandError_CommandFailed(
+                text.TextComponent.text(
+                    f"no handler registered for command id {command_id}"
+                )
+            )
+        )
+
+    def handle_task(self, handler_id: int, server: server.Server) -> None:
+        if handler_id in _TASK_HANDLERS:
+            _TASK_HANDLERS[handler_id](server)
+
+
+class MetadataImpl:
+    def get_metadata(self) -> metadata.PluginMetadata:
+        if _PLUGIN_INSTANCE:
+            return _PLUGIN_INSTANCE.metadata()
+        return metadata.PluginMetadata("unknown", "0.0.0", [], "No metadata", [])

pumpkin_api/wit/boss-bar.wit

@@ -0,0 +1,82 @@
+interface boss-bar {
+    use text.{text-component};
+    use player.{player};
+
+    /// Represents the color of a boss bar.
+    enum boss-bar-color {
+        pink,
+        blue,
+        red,
+        green,
+        yellow,
+        purple,
+        white,
+    }
+
+    /// Represents the notches/divisions of a boss bar.
+    enum boss-bar-division {
+        no-division,
+        notches-6,
+        notches-10,
+        notches-12,
+        notches-20,
+    }
+
+    /// Metadata flags that can be toggled on a boss bar.
+    record boss-bar-metadata {
+        /// Darkens the sky for players who see the boss bar.
+        darken-sky: bool,
+        /// If true, the bar is considered a "dragon bar" (used for Ender Dragon).
+        dragon-bar: bool,
+        /// If true, fog is created around the players who see the boss bar.
+        create-fog: bool,
+    }
+
+    /// Represents a boss bar that can be shown to players.
+    resource boss-bar {
+        /// Creates a new boss bar.
+        constructor(title: text-component, color: boss-bar-color, division: boss-bar-division);
+        
+        /// Returns the title of this boss bar.
+        get-title: func() -> text-component;
+        
+        /// Sets the title of this boss bar.
+        set-title: func(title: text-component);
+        
+        /// Returns the health (0.0 to 1.0) of this boss bar.
+        get-health: func() -> f32;
+        
+        /// Sets the health (0.0 to 1.0) of this boss bar.
+        set-health: func(health: f32);
+        
+        /// Returns the color of this boss bar.
+        get-color: func() -> boss-bar-color;
+        
+        /// Sets the color of this boss bar.
+        set-color: func(color: boss-bar-color);
+        
+        /// Returns the division of this boss bar.
+        get-division: func() -> boss-bar-division;
+        
+        /// Sets the division of this boss bar.
+        set-division: func(division: boss-bar-division);
+
+        /// Returns the currently active metadata on this boss bar.
+        get-metadata: func() -> boss-bar-metadata;
+
+        /// Updates the metadata on this boss bar.
+        set-metadata: func(metadata: boss-bar-metadata);
+        
+        /// Adds a player to this boss bar, making it visible to them.
+        add-player: func(player: player);
+        
+        /// Removes a player from this boss bar, hiding it from them.
+        remove-player: func(player: player);
+        
+        /// Returns a list of all players currently seeing this boss bar.
+        get-players: func() -> list<player>;
+        
+        /// Removes this boss bar from all players and cleans it up.
+        remove-all: func();
+    }
+}

pumpkin_api/{wit_files → wit}/event.wit

@@ -150,7 +150,6 @@ interface event {
         player: player,
         action: interact-action,
         clicked-pos: option<block-position>,
-        item: item-stack,
         block: string,
         cancelled: bool
     }

pumpkin_api/{wit_files → wit}/gui.wit

@@ -34,5 +34,17 @@ interface gui {
         constructor(%type: gui-type, title: text-component);
         set-item: func(slot: u32, item: item-stack);
         get-item: func(slot: u32) -> option<item-stack>;
+        
+        /// Returns the type of this GUI.
+        get-type: func() -> gui-type;
+        
+        /// Returns the title of this GUI.
+        get-title: func() -> text-component;
+        
+        /// Returns the number of slots in this GUI.
+        get-size: func() -> u32;
+        
+        /// Clears all items from the GUI.
+        clear-items: func();
     }
 }

pumpkin_api/{wit_files → wit}/player.wit

@@ -63,12 +63,25 @@ interface player {
         has-permission: func (node: string) -> bool;
         /// Returns the player's display name, which may include formatting.
         get-display-name: func () -> text-component;
+        /// Sets the player's display name.
+        set-display-name: func (display-name: text-component);
 
         // Messaging & titles
 
         /// Sends a system message to the player's chat.
         send-system-message: func (text: text-component, overlay: bool);
+        /// Sets the header and footer of the player's Tab list.
+        set-tab-list-header-footer: func (header: text-component, footer: text-component);
+
+        /// Sets the sorting order of the player in the Tab list.
+        set-tab-list-order: func (order: s32);
+        /// Sets the latency (ping) shown for the player in the Tab list.
+        set-tab-list-latency: func (latency: s32);
+        /// Sets whether the player is visible in the Tab list.
+        set-tab-list-listed: func (listed: bool);
+
         /// Shows a large title on the player's screen.
+
         show-title: func (text: text-component);
         /// Shows a smaller subtitle on the player's screen.
         show-subtitle: func (text: text-component);

pumpkin_api/{wit_files → wit}/plugin.wit

@@ -1,7 +1,7 @@
 /// The main entry point for a Pumpkin plugin.
 /// This world defines the exports that the plugin must provide to the host
 /// and the imports that the host provides to the plugin.
-package pumpkin:plugin;
+package pumpkin:plugin@0.1.0;
 
 world plugin {
     use context.{context};
@@ -33,6 +33,8 @@ world plugin {
     import %world;
     /// Provides entity types and manipulation.
     import entity;
+    /// Provides boss bar creation and management.
+    import boss-bar;
 
     // --- Plugin-provided exports ---
 
@@ -51,9 +53,6 @@ world plugin {
     /// Provides plugin metadata (name, version, etc.) to the host.
     export metadata;
 
-    /// Common types used across the API.
-    export common;
-
     /// Dispatches an event to the plugin for handling.
     export handle-event: func(event-id: u32, server: server-instance, event: event) -> event;