pygkit 1.0.2__tar.gz → 1.0.4__tar.gz

{pygkit-1.0.2 → pygkit-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygkit
-Version: 1.0.2
+Version: 1.0.4
 Summary: General-purpose Pygame CE runtime kit: UI widgets, audio, timers, interpolation, and more.
 Author: pygkit contributors
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -708,8 +708,11 @@ import pygkit
 
 ## Features
 
-- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers
+- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers, dialog system
+- **Dialog**: Typewriter effect with customizable speeds, speaker names, and progress indicators
+- **Inventory**: Grid-based item management with stacking, weight tracking, events, and serialization
 - **Audio**: SoundManager with channel pools and explicit targeting
+- **Transitions**: Screen transitions with fade, wipe, and custom effects
 - **Utils**: Timer, interpolation/easing functions
 
 ## Installation

{pygkit-1.0.2 → pygkit-1.0.4}/README.md

@@ -10,8 +10,11 @@ import pygkit
 
 ## Features
 
-- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers
+- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers, dialog system
+- **Dialog**: Typewriter effect with customizable speeds, speaker names, and progress indicators
+- **Inventory**: Grid-based item management with stacking, weight tracking, events, and serialization
 - **Audio**: SoundManager with channel pools and explicit targeting
+- **Transitions**: Screen transitions with fade, wipe, and custom effects
 - **Utils**: Timer, interpolation/easing functions
 
 ## Installation

{pygkit-1.0.2 → pygkit-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygkit"
-version = "1.0.2"
+version = "1.0.4"
 description = "General-purpose Pygame CE runtime kit: UI widgets, audio, timers, interpolation, and more."
 readme = "README.md"
 requires-python = ">=3.10"

{pygkit-1.0.2 → pygkit-1.0.4}/src/pygkit/__init__.py

@@ -2,6 +2,7 @@ from .audio import *
 from .transitions import *
 from .ui import *
 from .utils import *
+from .signals import *
 
 __all__ = [
     "SoundManager",
@@ -43,4 +44,7 @@ __all__ = [
     "wrap",
     "render_multiline",
     "fit",
+    "Signal",
+    "SignalBus",
+    "signal",
 ]

pygkit-1.0.4/src/pygkit/signals/__init__.py

@@ -0,0 +1,3 @@
+from .core import Signal, SignalBus, signal
+
+__all__ = ["Signal", "SignalBus", "signal"]

pygkit-1.0.4/src/pygkit/signals/core.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Signal(Generic[T]):
+    def __init__(self, name: str = ""):
+        self.name = name
+        self._connections: list[Callable[..., Any]] = []
+
+    def connect(self, callback: Callable[..., Any]) -> None:
+        if callback in self._connections:
+            return
+        self._connections.append(callback)
+
+    def disconnect(self, callback: Callable[..., Any]) -> None:
+        self._connections = [c for c in self._connections if c is not callback]
+
+    def disconnect_all(self) -> None:
+        self._connections.clear()
+
+    def emit(self, *args: Any, **kwargs: Any) -> None:
+        for callback in list(self._connections):
+            try:
+                callback(*args, **kwargs)
+            except Exception as e:
+                print(f"Error in signal {self.name}: {e}")
+
+    def __iadd__(self, callback: Callable[..., Any]) -> Signal[T]:
+        self.connect(callback)
+        return self
+
+    def __isub__(self, callback: Callable[..., Any]) -> Signal[T]:
+        self.disconnect(callback)
+        return self
+
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        self.emit(*args, **kwargs)
+
+
+class SignalBus:
+    def __init__(self):
+        self._signals: dict[str, Signal[Any]] = {}
+
+    def create_signal(self, name: str) -> Signal[Any]:
+        if name not in self._signals:
+            self._signals[name] = Signal(name)
+        return self._signals[name]
+
+    def get_signal(self, name: str) -> Signal[Any] | None:
+        return self._signals.get(name)
+
+    def emit(self, name: str, *args: Any, **kwargs: Any) -> None:
+        sig = self.get_signal(name)
+        if sig:
+            sig.emit(*args, **kwargs)
+
+    def connect(self, name: str, callback: Callable[..., Any]) -> None:
+        sig = self.get_signal(name)
+        if sig:
+            sig.connect(callback)
+
+    def disconnect(self, name: str, callback: Callable[..., Any]) -> None:
+        sig = self.get_signal(name)
+        if sig:
+            sig.disconnect(callback)
+
+
+class signal:
+    def __init__(self, name: str | None = None):
+        self.name = name
+
+    def __set_name__(self, owner, name):
+        if self.name is None:
+            self.name = name
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        try:
+            return obj.__dict__[self.name]
+        except KeyError:
+            sig = Signal(self.name)
+            obj.__dict__[self.name] = sig
+            return sig

{pygkit-1.0.2 → pygkit-1.0.4}/src/pygkit/ui/dialog.py

@@ -275,25 +275,21 @@ class DialogBox(UIBase):
             return
 
         if not self._is_complete:
-            self._typewriter_timer.reset()
-
-            chars_to_add = 0
+            text_len = len(self._current_line.text)
             elapsed = self._typewriter_timer.elapsed()
             interval = self._typewriter_timer.interval
 
-            if interval > 0:
+            if elapsed >= interval and interval > 0:
                 chars_to_add = max(1, int(elapsed / interval))
 
-            text_len = len(self._current_line.text)
-            if self._char_index < text_len:
-                old_index = self._char_index
-                self._char_index = min(text_len, self._char_index + chars_to_add)
-                self._displayed_text = self._current_line.text[: self._char_index]
+                if self._char_index < text_len:
+                    old_index = self._char_index
+                    self._char_index = min(text_len, self._char_index + chars_to_add)
+                    self._displayed_text = self._current_line.text[: self._char_index]
 
-                if self._char_index != old_index:
-                    self._needs_rebuild = True
+                    if self._char_index != old_index:
+                        self._needs_rebuild = True
 
-                if self._char_index < text_len:
                     self._typewriter_timer.reset()
 
             if self._char_index >= text_len:
@@ -400,7 +396,7 @@ class DialogBox(UIBase):
             pos_offset: Position offset (x, y) on the screen
         """
 
-        if self._needs_rebuild and self._is_complete:
+        if self._needs_rebuild:
             self._rebuild_text_surfaces()
 
         self.draw_base()

{pygkit-1.0.2 → pygkit-1.0.4}/src/pygkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygkit
-Version: 1.0.2
+Version: 1.0.4
 Summary: General-purpose Pygame CE runtime kit: UI widgets, audio, timers, interpolation, and more.
 Author: pygkit contributors
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -708,8 +708,11 @@ import pygkit
 
 ## Features
 
-- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers
+- **UI**: Box-model widgets with plugin compositing — progress bars, cooldown overlays, containers, dialog system
+- **Dialog**: Typewriter effect with customizable speeds, speaker names, and progress indicators
+- **Inventory**: Grid-based item management with stacking, weight tracking, events, and serialization
 - **Audio**: SoundManager with channel pools and explicit targeting
+- **Transitions**: Screen transitions with fade, wipe, and custom effects
 - **Utils**: Timer, interpolation/easing functions
 
 ## Installation

{pygkit-1.0.2 → pygkit-1.0.4}/src/pygkit.egg-info/SOURCES.txt

@@ -15,6 +15,8 @@ src/pygkit/inventory/assets.py
 src/pygkit/inventory/core.py
 src/pygkit/inventory/data.py
 src/pygkit/inventory/ui.py
+src/pygkit/signals/__init__.py
+src/pygkit/signals/core.py
 src/pygkit/transitions/__init__.py
 src/pygkit/transitions/base.py
 src/pygkit/transitions/effects.py
@@ -34,6 +36,7 @@ tests/test_box_model.py
 tests/test_dialog.py
 tests/test_interpolation.py
 tests/test_inventory.py
+tests/test_signals.py
 tests/test_text.py
 tests/test_timer.py
 tests/test_transitions.py

pygkit-1.0.4/tests/test_signals.py

@@ -0,0 +1,222 @@
+from pygkit.signals import Signal, SignalBus, signal
+
+
+class TestSignal:
+    def test_connect_and_emit(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda: results.append("called"))
+        sig.emit()
+        assert results == ["called"]
+
+    def test_connect_multiple(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda: results.append("a"))
+        sig.connect(lambda: results.append("b"))
+        sig.emit()
+        assert results == ["a", "b"]
+
+    def test_disconnect(self):
+        sig = Signal("test")
+        results = []
+        cb = lambda: results.append("called")
+        sig.connect(cb)
+        sig.disconnect(cb)
+        sig.emit()
+        assert results == []
+
+    def test_disconnect_all(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda: results.append("a"))
+        sig.connect(lambda: results.append("b"))
+        sig.disconnect_all()
+        sig.emit()
+        assert results == []
+
+    def test_duplicate_connect(self):
+        sig = Signal("test")
+        results = []
+        cb = lambda: results.append("called")
+        sig.connect(cb)
+        sig.connect(cb)
+        sig.emit()
+        assert results == ["called"]
+
+    def test_emit_args(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda x, y: results.append((x, y)))
+        sig.emit(1, 2)
+        assert results == [(1, 2)]
+
+    def test_emit_kwargs(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda a=0, b=0: results.append((a, b)))
+        sig.emit(a=3, b=4)
+        assert results == [(3, 4)]
+
+    def test_iadd(self):
+        sig = Signal("test")
+        results = []
+        sig += lambda: results.append("called")
+        sig.emit()
+        assert results == ["called"]
+
+    def test_isub(self):
+        sig = Signal("test")
+        results = []
+        cb = lambda: results.append("called")
+        sig += cb
+        sig -= cb
+        sig.emit()
+        assert results == []
+
+    def test_call_syntax(self):
+        sig = Signal("test")
+        results = []
+        sig += lambda: results.append("called")
+        sig()
+        assert results == ["called"]
+
+    def test_name(self):
+        sig = Signal("my_signal")
+        assert sig.name == "my_signal"
+
+    def test_emit_error_does_not_break(self):
+        sig = Signal("test")
+        results = []
+        sig.connect(lambda: (_ for _ in ()).throw(ValueError("bad")))
+        sig.connect(lambda: results.append("ok"))
+        sig.emit()
+        assert results == ["ok"]
+
+    def test_weak_ref_allows_gc(self):
+        sig = Signal("test")
+        results = []
+        def cb():
+            results.append("called")
+        sig.connect(cb)
+        sig.emit()
+        assert results == ["called"]
+
+
+class TestSignalBus:
+    def test_create_signal(self):
+        bus = SignalBus()
+        sig = bus.create_signal("test")
+        assert isinstance(sig, Signal)
+        assert sig.name == "test"
+
+    def test_create_signal_idempotent(self):
+        bus = SignalBus()
+        sig1 = bus.create_signal("test")
+        sig2 = bus.create_signal("test")
+        assert sig1 is sig2
+
+    def test_get_signal(self):
+        bus = SignalBus()
+        bus.create_signal("test")
+        sig = bus.get_signal("test")
+        assert sig is not None
+        assert sig.name == "test"
+
+    def test_get_signal_missing(self):
+        bus = SignalBus()
+        assert bus.get_signal("nonexistent") is None
+
+    def test_emit_via_bus(self):
+        bus = SignalBus()
+        bus.create_signal("test")
+        results = []
+        bus.connect("test", lambda: results.append("called"))
+        bus.emit("test")
+        assert results == ["called"]
+
+    def test_emit_missing_signal(self):
+        bus = SignalBus()
+        bus.emit("nonexistent")
+
+    def test_connect_missing_signal(self):
+        bus = SignalBus()
+        bus.connect("nonexistent", lambda: None)
+
+    def test_disconnect_missing_signal(self):
+        bus = SignalBus()
+        bus.disconnect("nonexistent", lambda: None)
+
+    def test_disconnect_via_bus(self):
+        bus = SignalBus()
+        bus.create_signal("test")
+        results = []
+        cb = lambda: results.append("called")
+        bus.connect("test", cb)
+        bus.disconnect("test", cb)
+        bus.emit("test")
+        assert results == []
+
+    def test_bus_with_args(self):
+        bus = SignalBus()
+        bus.create_signal("test")
+        results = []
+        bus.connect("test", lambda x: results.append(x))
+        bus.emit("test", 42)
+        assert results == [42]
+
+
+class TestSignalDescriptor:
+    def test_descriptor_is_signal_on_instance(self):
+        class Obj:
+            sig = signal()
+
+        obj = Obj()
+        assert isinstance(obj.sig, Signal)
+
+    def test_descriptor_unique_per_instance(self):
+        class Obj:
+            sig = signal()
+
+        a = Obj()
+        b = Obj()
+        assert a.sig is not b.sig
+
+    def test_descriptor_connect_and_emit(self):
+        class Obj:
+            sig = signal()
+
+        obj = Obj()
+        results = []
+        obj.sig += lambda: results.append("called")
+        obj.sig()
+        assert results == ["called"]
+
+    def test_descriptor_assign_allows_override(self):
+        class Obj:
+            sig = signal()
+
+        obj = Obj()
+        sig = obj.sig
+        obj.sig = "nope"
+        assert obj.sig == "nope"
+
+    def test_descriptor_multiple_signals(self):
+        class Obj:
+            a = signal()
+            b = signal()
+
+        obj = Obj()
+        results = []
+        obj.a += lambda: results.append("a")
+        obj.b += lambda: results.append("b")
+        obj.a()
+        assert results == ["a"]
+        obj.b()
+        assert results == ["a", "b"]
+
+    def test_descriptor_class_access(self):
+        class Obj:
+            sig = signal()
+
+        assert isinstance(Obj.sig, signal)