pumpkin-api-py 0.1.0.dev0__py3-none-any.whl

pumpkin_api/wit_files/componentize_py_async_support/streams.py

@@ -0,0 +1,189 @@
+import componentize_py_runtime
+import componentize_py_async_support
+import weakref
+
+from typing import TypeVar, Generic, Self, cast
+from types import TracebackType
+from componentize_py_async_support import _ReturnCode
+
+class ByteStreamReader:
+    def __init__(self, type_: int, handle: int):
+        self.writer_dropped = False
+        self.type_ = type_
+        self.handle: int | None = handle
+        self.finalizer = weakref.finalize(self, componentize_py_runtime.stream_drop_readable, type_, handle)
+
+    async def read(self, max_count: int) -> bytes:
+        if self.writer_dropped:
+            return bytes()
+        
+        code, values = await self._read(max_count)
+
+        if code == _ReturnCode.DROPPED:
+            self.writer_dropped = True
+        
+        return values
+        
+    async def _read(self, max_count: int) -> tuple[int, bytes]:
+        if self.handle is not None:
+            return cast(tuple[int, bytes], await componentize_py_async_support.await_result(
+                componentize_py_runtime.stream_read(self.type_, self.handle, max_count)
+            ))
+        else:
+            raise AssertionError
+
+    def __enter__(self) -> Self:
+        return self
+        
+    def __exit__(self,
+                 exc_type: type[BaseException] | None,
+                 exc_value: BaseException | None,
+                 traceback: TracebackType | None) -> bool | None:
+        self.finalizer.detach()
+        handle = self.handle
+        self.handle = None
+        if handle is not None:
+            componentize_py_runtime.stream_drop_readable(self.type_, handle)
+        return None
+
+class ByteStreamWriter:
+    def __init__(self, type_: int, handle: int):
+        self.reader_dropped = False
+        self.type_ = type_
+        self.handle: int | None = handle
+        self.finalizer = weakref.finalize(self, componentize_py_runtime.stream_drop_writable, type_, handle)
+
+    async def write(self, source: bytes) -> int:
+        if self.reader_dropped:
+            return 0
+        
+        code, count = await self._write(source)
+
+        if code == _ReturnCode.DROPPED:
+            self.reader_dropped = True
+        
+        return count
+
+    async def _write(self, source: bytes) -> tuple[int, int]:
+        if self.handle is not None:
+            return await componentize_py_async_support.await_result(
+                componentize_py_runtime.stream_write(self.type_, self.handle, source)
+            )
+        else:
+            raise AssertionError
+
+    async def write_all(self, source: bytes) -> int:
+        total = 0
+        
+        while len(source) > 0 and not self.reader_dropped:
+            count = await self.write(source)
+            source = source[count:]
+            total += count
+            
+        return total
+
+    def __enter__(self) -> Self:
+        return self
+        
+    def __exit__(self,
+                 exc_type: type[BaseException] | None,
+                 exc_value: BaseException | None,
+                 traceback: TracebackType | None) -> bool | None:
+        self.finalizer.detach()
+        handle = self.handle
+        self.handle = None
+        if handle is not None:
+            componentize_py_runtime.stream_drop_writable(self.type_, handle)
+        return None
+
+T = TypeVar('T')
+
+class StreamReader(Generic[T]):
+    def __init__(self, type_: int, handle: int):
+        self.writer_dropped = False
+        self.type_ = type_
+        self.handle: int | None = handle
+        self.finalizer = weakref.finalize(self, componentize_py_runtime.stream_drop_readable, type_, handle)
+
+    async def read(self, max_count: int) -> list[T]:
+        if self.writer_dropped:
+            return []
+        
+        code, values = await self._read(max_count)
+
+        if code == _ReturnCode.DROPPED:
+            self.writer_dropped = True
+        
+        return values
+        
+    async def _read(self, max_count: int) -> tuple[int, list[T]]:
+        if self.handle is not None:
+            return cast(tuple[int, list[T]], await componentize_py_async_support.await_result(
+                componentize_py_runtime.stream_read(self.type_, self.handle, max_count)
+            ))
+        else:
+            raise AssertionError        
+
+    def __enter__(self) -> Self:
+        return self
+        
+    def __exit__(self,
+                 exc_type: type[BaseException] | None,
+                 exc_value: BaseException | None,
+                 traceback: TracebackType | None) -> bool | None:
+        self.finalizer.detach()
+        handle = self.handle
+        self.handle = None
+        if handle is not None:
+            componentize_py_runtime.stream_drop_readable(self.type_, handle)
+        return None
+
+class StreamWriter(Generic[T]):
+    def __init__(self, type_: int, handle: int):
+        self.reader_dropped = False
+        self.type_ = type_
+        self.handle: int | None = handle
+        self.finalizer = weakref.finalize(self, componentize_py_runtime.stream_drop_writable, type_, handle)
+
+    async def write(self, source: list[T]) -> int:
+        if self.reader_dropped:
+            return 0
+        
+        code, count = await self._write(source)
+
+        if code == _ReturnCode.DROPPED:
+            self.reader_dropped = True
+        
+        return count
+
+    async def _write(self, source: list[T]) -> tuple[int, int]:
+        if self.handle is not None:
+            return await componentize_py_async_support.await_result(
+                componentize_py_runtime.stream_write(self.type_, self.handle, source)
+            )
+        else:
+            raise AssertionError        
+
+    async def write_all(self, source: list[T]) -> int:
+        total = 0
+        
+        while len(source) > 0 and not self.reader_dropped:
+            count = await self.write(source)
+            source = source[count:]
+            total += count
+            
+        return total
+
+    def __enter__(self) -> Self:
+        return self
+        
+    def __exit__(self,
+                 exc_type: type[BaseException] | None,
+                 exc_value: BaseException | None,
+                 traceback: TracebackType | None) -> bool | None:
+        self.finalizer.detach()
+        handle = self.handle
+        self.handle = None
+        if handle is not None:
+            componentize_py_runtime.stream_drop_writable(self.type_, handle)
+        return None

pumpkin_api/wit_files/componentize_py_runtime.pyi

@@ -0,0 +1,34 @@
+from typing import Any
+from componentize_py_types import Result
+
+def call_task_return(index: int, borrows: int, result: Any) -> None: ...
+
+def waitable_set_drop(set: int) -> None: ...
+
+def context_set(value: Any) -> None: ...
+
+def context_get() -> Any: ...
+
+def waitable_join(waitable: int, set: int) -> None: ...
+
+def subtask_drop(task: int) -> None: ...
+
+def waitable_set_new() -> int: ...
+
+def promise_get_result(event: int, promise: int) -> Any: ...
+
+def future_read(ty: int, future: int) -> Result[Any, tuple[int, int]]: ...
+
+def future_write(ty: int, future: int, value: Any) -> Result[tuple[int, int], tuple[int, int]]: ...
+
+def future_drop_readable(ty: int, future: int) -> None: ...
+
+def future_drop_writable(ty: int, future: int) -> None: ...
+
+def stream_read(ty: int, stream: int, max_count: int) -> Result[tuple[int, bytes | list[Any]], tuple[int, int]]: ...
+
+def stream_write(ty: int, stream: int, values: bytes | list[Any]) -> Result[tuple[int, int], tuple[int, int]]: ...
+
+def stream_drop_readable(ty: int, stream: int) -> None: ...
+
+def stream_drop_writable(ty: int, stream: int) -> None: ...

pumpkin_api/wit_files/componentize_py_types.py

@@ -0,0 +1,19 @@
+from typing import TypeVar, Generic, Union
+from dataclasses import dataclass
+
+S = TypeVar('S')
+@dataclass
+class Some(Generic[S]):
+    value: S
+
+T = TypeVar('T')
+@dataclass
+class Ok(Generic[T]):
+    value: T
+
+E = TypeVar('E')
+@dataclass(frozen=True)
+class Err(Generic[E], Exception):
+    value: E
+
+Result = Union[Ok[T], Err[E]]

pumpkin_api/wit_files/context.wit

@@ -0,0 +1,33 @@
+/// The core context provided to a plugin during initialization and event handling.
+interface context {
+    use server.{server};
+    use event.{event-type, event-priority};
+    use command.{command};
+    use permission.{permission};
+
+    /// A contextual handle for plugin-related operations.
+    resource context {
+        /// Registers a handler for a specific event.
+        ///
+        /// * `handler-id`: Unique ID for the event handler.
+        /// * `event-type`: The type of event to listen for.
+        /// * `event-priority`: When this handler should be called relative to others.
+        /// * `blocking`: Whether the event should wait for this handler to finish.
+        register-event: func(handler-id: u32, event-type: event-type, event-priority: event-priority, blocking: bool);
+
+        /// Registers a new command.
+        ///
+        /// * `command`: The command definition.
+        /// * `permission`: The required permission node to execute this command.
+        register-command: func(command: command, permission: string);
+
+        /// Registers a permission node with the server.
+        register-permission: func(permission: permission) -> result<_, string>;
+
+        /// Returns the path to the plugin's private data folder.
+        get-data-folder: func() -> string;
+
+        /// Returns the global server instance.
+        get-server: func() -> server;
+    }
+}

pumpkin_api/wit_files/entity.wit

@@ -0,0 +1,36 @@
+interface entity {
+    use common.{block-position};
+
+    resource block-entity {
+        resource-location: func() -> string;
+        get-position: func() -> block-position;
+        get-id: func() -> u32;
+        // write-nbt: func(nbt: nbt-compound);
+        // from-nbt: func(nbt: nbt-compound, position: block-position) -> entity;
+        // tick: func(world: simple-world);
+        // write-internal: func(nbt: nbt-compound);
+        // chunk-data-nbt: func() -> option<nbt-compound;
+        // get-inventory: func() -> option<inventory>;
+        // set-block-state: func(block-state: block-state-id);
+        // on-block-replaced: func(world: simple-world, position: block-position);
+        is-dirty: func() -> bool;
+        clear-dirty: func();
+        // to-property-delegate: func() -> option<property-delegate>;
+        // to-experience-container: func() -> option<experience-container>;
+    }
+
+    resource command-block-entity {
+        get-block-entity: func () -> block-entity;
+        last-output: func() -> string;
+        track-output: func() -> bool;
+        success-count: func() -> u32;
+        command: func() -> string;
+        auto: func() -> bool;
+        condition-met: func() -> bool;
+        powered: func() -> bool;
+    }
+
+    variant entity {
+        command-block-entity(command-block-entity),
+    }
+}

pumpkin_api/wit_files/event.wit

@@ -0,0 +1,311 @@
+interface event {
+    use common.{block-position, game-mode, hand, item-stack, position};
+    use player.{player};
+    use text.{text-component};
+    use %world.{%world};
+
+    enum event-priority {
+        highest,
+        high,
+        normal,
+        low,
+        lowest,
+    }
+
+    record player-join-event-data {
+        player: player,
+        join-message: text-component,
+        cancelled: bool
+    }
+
+    record player-leave-event-data {
+        player: player,
+        leave-message: text-component,
+        cancelled: bool
+    }
+
+    record player-login-event-data {
+        player: player,
+        kick-message: text-component,
+        cancelled: bool
+    }
+
+    record player-chat-event-data {
+        player: player,
+        message: string,
+        recipients: list<player>,
+        cancelled: bool
+    }
+
+    record player-command-send-event-data {
+        player: player,
+        command: string,
+        cancelled: bool
+    }
+
+    record player-permission-check-event-data {
+        player: player,
+        permission: string,
+        permission-result: bool
+    }
+
+    record player-move-event-data {
+        player: player,
+        from-position: position,
+        to-position: position,
+        cancelled: bool
+    }
+
+    record player-teleport-event-data {
+        player: player,
+        from-position: position,
+        to-position: position,
+        cancelled: bool
+    }
+
+    record player-change-world-event-data {
+        player: player,
+        previous-world: %world,
+        new-world: %world,
+        position: position,
+        yaw: f32,
+        pitch: f32,
+        cancelled: bool
+    }
+
+    record player-exp-change-event-data {
+        player: player,
+        amount: s32
+    }
+
+    record player-item-held-event-data {
+        player: player,
+        previous-slot: u8,
+        new-slot: u8,
+        cancelled: bool
+    }
+
+    record player-changed-main-hand-event-data {
+        player: player,
+        main-hand: hand
+    }
+
+    record player-gamemode-change-event-data {
+        player: player,
+        previous-gamemode: game-mode,
+        new-gamemode: game-mode,
+        cancelled: bool
+    }
+
+    record player-custom-payload-event-data {
+        player: player,
+        channel: string,
+        data: list<u8>
+    }
+
+    enum player-fish-state {
+        fishing,
+        caught-fish,
+        caught-entity,
+        in-ground,
+        failed-attempt,
+        reel-in,
+        bite,
+    }
+
+    record player-fish-event-data {
+        player: player,
+        caught-uuid: option<string>,
+        caught-type: string,
+        hook-uuid: string,
+        state: player-fish-state,
+        hand: hand,
+        exp-to-drop: s32,
+        cancelled: bool
+    }
+
+    record player-egg-throw-event-data {
+        player: player,
+        egg-uuid: string,
+        hatching: bool,
+        num-hatches: u8,
+        hatching-type: string,
+        cancelled: bool
+    }
+
+    enum entity-interaction-action {
+        interact,
+        attack,
+        interact-at,
+    }
+
+    enum interact-action {
+        left-click-block,
+        left-click-air,
+        right-click-air,
+        right-click-block,
+    }
+
+    record player-interact-event-data {
+        player: player,
+        action: interact-action,
+        clicked-pos: option<block-position>,
+        item: item-stack,
+        block: string,
+        cancelled: bool
+    }
+
+    record player-toggle-sneak-event-data {
+        player: player,
+        is-sneaking: bool,
+        cancelled: bool
+    }
+
+    record player-toggle-sprint-event-data {
+        player: player,
+        is-sprinting: bool,
+        cancelled: bool
+    }
+
+    record player-interact-unknown-entity-event-data {
+        player: player,
+        entity-id: s32,
+        action: entity-interaction-action,
+        cancelled: bool
+    }
+
+    record block-redstone-event-data {
+        target-world: %world,
+        state-id: u16,
+        block-position: block-position,
+        old-current: s32,
+        new-current: s32,
+        cancelled: bool
+    }
+
+    record block-break-event-data {
+        player: option<player>,
+        block: string,
+        block-position: block-position,
+        exp: u32,
+        should-drop: bool,
+        cancelled: bool
+    }
+
+    record block-burn-event-data {
+        igniting-block: string,
+        block: string,
+        cancelled: bool
+    }
+
+    record block-can-build-event-data {
+        block-to-build: string,
+        buildable: bool,
+        player: player,
+        block: string,
+        cancelled: bool
+    }
+
+    record block-grow-event-data {
+        target-world: %world,
+        old-block: string,
+        old-state-id: u16,
+        new-block: string,
+        new-state-id: u16,
+        block-position: block-position,
+        cancelled: bool
+    }
+
+    record block-place-event-data {
+        player: player,
+        block-placed: string,
+        block-placed-against: string,
+        block-position: block-position,
+        can-build: bool,
+        cancelled: bool
+    }
+    record server-command-event-data {
+        command: string,
+        cancelled: bool
+    }
+
+    record spawn-change-event-data {
+        target-world: %world,
+        previous-position: block-position,
+        previous-yaw: f32,
+        previous-pitch: f32,
+        new-position: block-position,
+        new-yaw: f32,
+        new-pitch: f32
+    }
+
+    record server-broadcast-event-data {
+        message: text-component,
+        sender: text-component,
+        cancelled: bool
+    }
+
+    enum event-type {
+        player-join-event,
+        player-leave-event,
+        player-login-event,
+        player-chat-event,
+        player-command-send-event,
+        player-permission-check-event,
+        player-move-event,
+        player-teleport-event,
+        player-change-world-event,
+        player-exp-change-event,
+        player-item-held-event,
+        player-changed-main-hand-event,
+        player-gamemode-change-event,
+        player-custom-payload-event,
+        player-fish-event,
+        player-egg-throw-event,
+        player-interact-unknown-entity-event,
+        player-interact-event,
+        player-toggle-sneak-event,
+        player-toggle-sprint-event,
+        block-redstone-event,
+        block-break-event,
+        block-burn-event,
+        block-can-build-event,
+        block-grow-event,
+        block-place-event,
+        server-command-event,
+        spawn-change-event,
+        server-broadcast-event,
+    }
+
+    variant event {
+        player-join-event(player-join-event-data),
+        player-leave-event(player-leave-event-data),
+        player-login-event(player-login-event-data),
+        player-chat-event(player-chat-event-data),
+        player-command-send-event(player-command-send-event-data),
+        player-permission-check-event(player-permission-check-event-data),
+        player-move-event(player-move-event-data),
+        player-teleport-event(player-teleport-event-data),
+        player-change-world-event(player-change-world-event-data),
+        player-exp-change-event(player-exp-change-event-data),
+        player-item-held-event(player-item-held-event-data),
+        player-changed-main-hand-event(player-changed-main-hand-event-data),
+        player-gamemode-change-event(player-gamemode-change-event-data),
+        player-custom-payload-event(player-custom-payload-event-data),
+        player-fish-event(player-fish-event-data),
+        player-egg-throw-event(player-egg-throw-event-data),
+        player-interact-unknown-entity-event(player-interact-unknown-entity-event-data),
+        player-interact-event(player-interact-event-data),
+        player-toggle-sneak-event(player-toggle-sneak-event-data),
+        player-toggle-sprint-event(player-toggle-sprint-event-data),
+        block-redstone-event(block-redstone-event-data),
+        block-break-event(block-break-event-data),
+        block-burn-event(block-burn-event-data),
+        block-can-build-event(block-can-build-event-data),
+        block-grow-event(block-grow-event-data),
+        block-place-event(block-place-event-data),
+        server-command-event(server-command-event-data),
+        spawn-change-event(spawn-change-event-data),
+        server-broadcast-event(server-broadcast-event-data),
+    }
+}

pumpkin_api/wit_files/gui.wit

@@ -0,0 +1,38 @@
+interface gui {
+    use text.{text-component};
+    use common.{item-stack};
+
+    enum gui-type {
+        generic-9x1,
+        generic-9x2,
+        generic-9x3,
+        generic-9x4,
+        generic-9x5,
+        generic-9x6,
+        generic-3x3,
+        crafter-3x3,
+        anvil,
+        beacon,
+        blast-furnace,
+        brewing-stand,
+        crafting,
+        enchantment,
+        furnace,
+        grindstone,
+        hopper,
+        lectern,
+        loom,
+        merchant,
+        shulker-box,
+        smithing,
+        smoker,
+        cartography-table,
+        stonecutter,
+    }
+
+    resource gui {
+        constructor(%type: gui-type, title: text-component);
+        set-item: func(slot: u32, item: item-stack);
+        get-item: func(slot: u32) -> option<item-stack>;
+    }
+}

pumpkin_api/wit_files/i18n.wit

@@ -0,0 +1,21 @@
+interface i18n {
+    use common.{locale};
+
+    /// Retrieves a translated string from the host.
+    ///
+    /// # Arguments
+    /// * `key`: The namespaced translation key (e.g. `pumpkin:my_key`).
+    /// * `locale`: The target locale.
+    ///
+    /// # Returns
+    /// The localized string, falling back to English or the key itself.
+    translate: func(key: string, locale: locale) -> string;
+
+    /// Loads custom translations from a JSON string.
+    ///
+    /// # Arguments
+    /// * `namespace`: The namespace to associate these keys with.
+    /// * `json`: A JSON string containing a flat map of translations.
+    /// * `locale`: The target locale for these translations.
+    load-translations: func(namespace: string, json: string, locale: locale);
+}

pumpkin_api/wit_files/log.wit

@@ -0,0 +1,14 @@
+interface logging {
+    enum level {
+        trace,
+        debug,
+        info,
+        warn,
+        error,
+    }
+
+    /// log any general purpose message
+    log: func(level: level, message: string);
+    /// This function is meant to be used by the tracing crate.
+    log-tracing: func(event: list<u8>);
+}