mini-arcade-core 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

mini_arcade_core/utils/profiler.py

@@ -0,0 +1,283 @@
+"""
+Game core module defining the Game class and configuration.
+"""
+
+from __future__ import annotations
+
+import enum
+import logging
+from dataclasses import dataclass, field
+from time import perf_counter
+from typing import Dict, Iterable, Mapping
+
+perf_logger = logging.getLogger("mini-arcade-core.perf")
+
+
+class Ansi(enum.Enum):
+    """
+    ANSI escape codes for terminal text formatting.
+
+    cvar RESET (str): Reset all formatting.
+    cvar BOLD (str): Bold text.
+    cvar DIM (str): Dim text.
+    cvar RED (str): Red text.
+    cvar GREEN (str): Green text.
+    cvar YELLOW (str): Yellow text.
+    cvar CYAN (str): Cyan text.
+    cvar MAGENTA (str): Magenta text.
+    cvar WHITE (str): White text.
+    """
+
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+
+    RED = "\033[91m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    CYAN = "\033[96m"
+    MAGENTA = "\033[95m"
+    WHITE = "\033[97m"
+
+
+def _c(text: str, *codes: str) -> str:
+    """Convenience function to wrap text with ANSI codes."""
+    return "".join(codes) + text + Ansi.RESET.value
+
+
+@dataclass(frozen=True)
+class FrameTimingReport:
+    """
+    Report of frame timing data.
+
+    :ivar frame_index (int): Index of the frame.
+    :ivar diffs_ms (Dict[str, float]): Dictionary of time differences in milliseconds.
+    :ivar total_ms (float): Total time in milliseconds.
+    :ivar budget_ms (float): Frame budget in milliseconds.
+    """
+
+    frame_index: int
+    diffs_ms: Dict[str, float]
+    total_ms: float
+    budget_ms: float
+
+
+@dataclass(frozen=True)
+class FrameTimingFormatter:
+    """
+    Formats a FrameTimingReport into a colored, multi-line table string.
+    Keeps FrameTimer lean and avoids pylint complexity in the timer itself.
+
+    :ivar target_fps (int): Target frames per second for budget calculation.
+    :ivar top_n (int): Number of top time-consuming segments to display.
+    :ivar min_ms (float): Minimum time in milliseconds to include in the top list.
+    :ivar phases (tuple[tuple[str, str], ...]): Tuples of (display name, mark key)
+        for table columns.
+    """
+
+    target_fps: int = 60
+    top_n: int = 6
+    min_ms: float = 0.05
+
+    # These are the “headline” segments you want as columns.
+    phases: tuple[tuple[str, str], ...] = (
+        ("events", "frame_start->events_polled"),
+        ("input", "events_polled->input_built"),
+        ("tick", "tick_start->tick_end"),
+        ("render", "render_start->render_done"),
+        ("sleep", "sleep_start->sleep_end"),
+    )
+
+    def make_report(
+        self, frame_index: int, diffs_ms: Dict[str, float]
+    ) -> FrameTimingReport:
+        """
+        Create a FrameTimingReport from the given diffs.
+
+        :param frame_index: Index of the frame.
+        :type frame_index: int
+        :param diffs_ms: Dictionary of time differences in milliseconds.
+        :type diffs_ms: Dict[str, float]
+        :return: FrameTimingReport instance.
+        :rtype: FrameTimingReport
+        """
+        total = sum(diffs_ms.values()) if diffs_ms else 0.0
+        budget = (1000.0 / self.target_fps) if self.target_fps > 0 else 0.0
+        return FrameTimingReport(
+            frame_index=frame_index,
+            diffs_ms=diffs_ms,
+            total_ms=total,
+            budget_ms=budget,
+        )
+
+    def format(self, report: FrameTimingReport) -> str:
+        """
+        Format the FrameTimingReport into a colored string.
+
+        :param report: FrameTimingReport instance.
+        :type report: FrameTimingReport
+        :return: Formatted string.
+        :rtype: str
+        """
+        header = self._format_header(report)
+        table = self._format_table(report.diffs_ms)
+        top = self._format_top(report.diffs_ms)
+        return f"{header}\n{table}\n{top}\n"
+
+    def _format_header(self, report: FrameTimingReport) -> str:
+        over = report.budget_ms > 0 and report.total_ms > report.budget_ms
+        status = (
+            _c("OVER", Ansi.BOLD.value, Ansi.RED.value)
+            if over
+            else _c("OK", Ansi.BOLD.value, Ansi.GREEN.value)
+        )
+
+        frame = _c(
+            f"[Frame {report.frame_index}]", Ansi.BOLD.value, Ansi.WHITE.value
+        )
+        total = _c(
+            f"{report.total_ms:.2f}ms", Ansi.BOLD.value, Ansi.WHITE.value
+        )
+        budget = _c(f"{report.budget_ms:.2f}ms", Ansi.DIM.value)
+        dim = Ansi.DIM.value
+
+        return (
+            f"{frame} {_c('total', dim)}={total} "
+            f"{_c('budget', dim)}={budget} {_c('status', dim)}={status}"
+        )
+
+    def _format_table(self, diffs: Mapping[str, float]) -> str:
+        # Header line
+        headers = [name for name, _ in self.phases]
+        line_h = self._pipe_row((_c(h, Ansi.DIM.value) for h in headers))
+
+        # Values line
+        values = [diffs.get(key, 0.0) for _, key in self.phases]
+        line_v = self._pipe_row(self._color_values(values))
+
+        return f"{line_h}\n{line_v}"
+
+    def _color_values(self, values: Iterable[float]) -> list[str]:
+        # Keep coloring policy centralized and easy to tweak.
+        # events/input: cyan, tick: yellow, render: magenta, sleep: green
+        colors = [
+            Ansi.CYAN.value,
+            Ansi.CYAN.value,
+            Ansi.YELLOW.value,
+            Ansi.MAGENTA.value,
+            Ansi.GREEN.value,
+        ]
+        out: list[str] = []
+        for v, col in zip(values, colors):
+            out.append(_c(f"{v:6.2f}", col))
+        return out
+
+    def _format_top(self, diffs: Mapping[str, float]) -> str:
+        dim = Ansi.DIM.value
+        items = [
+            (k, float(v)) for k, v in diffs.items() if float(v) >= self.min_ms
+        ]
+        items.sort(key=lambda kv: kv[1], reverse=True)
+        items = items[: self.top_n]
+
+        if not items:
+            return f"{_c('top:', dim)} (none >= {self.min_ms:.2f}ms)"
+
+        top_str = ", ".join(f"{k}:{v:.2f}ms" for k, v in items)
+        return f"{_c('top:', dim)} {top_str}"
+
+    @staticmethod
+    def _pipe_row(cells: Iterable[str]) -> str:
+        # Keeps lines short and avoids long f-strings.
+        return " | ".join(cells)
+
+
+@dataclass
+class FrameTimerConfig:
+    """
+    Configuration for FrameTimer.
+
+    :ivar enabled (bool): Whether timing is enabled.
+    :ivar report_every (int): Number of frames between reports.
+    """
+
+    enabled: bool = False
+    report_every: int = 60
+
+
+@dataclass
+class FrameTimer:
+    """
+    Simple frame timer for marking and reporting time intervals.
+
+    :ivar config (FrameTimerConfig): Configuration for the timer.
+    :ivar formatter (FrameTimingFormatter): Formatter for timing reports.
+    :ivar marks (Dict[str, float]): Recorded time marks.
+    """
+
+    config: FrameTimerConfig = field(default_factory=FrameTimerConfig)
+    formatter: FrameTimingFormatter = field(
+        default_factory=FrameTimingFormatter
+    )
+    marks: Dict[str, float] = field(default_factory=dict)
+
+    def clear(self):
+        """Clear all recorded marks."""
+        if not self.config.enabled:
+            return
+        self.marks.clear()
+
+    def mark(self, name: str):
+        """
+        Record a time mark with the given name.
+
+        :param name: Name of the mark.
+        :type name: str
+        """
+        if not self.config.enabled:
+            return
+        self.marks[name] = perf_counter()
+
+    def report_ms(self) -> Dict[str, float]:
+        """
+        Returns diffs between consecutive marks in insertion order.
+
+        :return: Dictionary mapping "start->end" to time difference in milliseconds.
+        :rtype: Dict[str, float]
+        """
+        if not self.config.enabled:
+            return {}
+        keys = list(self.marks.keys())
+        out: Dict[str, float] = {}
+        for a, b in zip(keys, keys[1:]):
+            out[f"{a}->{b}"] = (self.marks[b] - self.marks[a]) * 1000.0
+        return out
+
+    def should_report(self, frame_index: int) -> bool:
+        """
+        Determine if a report should be emitted for the given frame index.
+
+        :param frame_index: Current frame index.
+        :type frame_index: int
+        :return: True if a report should be emitted, False otherwise.
+        :rtype: bool
+        """
+        return (
+            self.config.enabled
+            and self.config.report_every > 0
+            and frame_index > 0
+            and (frame_index % self.config.report_every == 0)
+        )
+
+    def emit(self, frame_index: int):
+        """
+        Emit a timing report to the performance logger.
+
+        :param frame_index: Current frame index.
+        :type frame_index: int
+        """
+        if not self.config.enabled:
+            return
+        diffs = self.report_ms()
+        report = self.formatter.make_report(frame_index, diffs)
+        perf_logger.info(self.formatter.format(report))

{mini_arcade_core-1.1.1.dist-info → mini_arcade_core-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-arcade-core
-Version: 1.1.1
+Version: 1.2.1
 Summary: Tiny scene-based game loop core for small arcade games.
 License: Copyright (c) 2025 Santiago Rincón
            

mini_arcade_core-1.2.1.dist-info/RECORD

@@ -0,0 +1,93 @@
+mini_arcade_core/__init__.py,sha256=AdhR8GzhJnPYBkwIdNag1cnB8e4JqCHNZxsZfrw5vCQ,2564
+mini_arcade_core/backend/__init__.py,sha256=J1wZBHX-aqmBP3zh_ey9PK2b_gnWp72zxMfKcs3iwSw,274
+mini_arcade_core/backend/backend.py,sha256=tJYjHqjWZst8P3uikStndEHIVWLvF0ypmibVtCErbag,8699
+mini_arcade_core/backend/events.py,sha256=5Ohve3CQ6n2CztiOhbCoz6yFDY4z0j4v4R9FBKRDRjc,2929
+mini_arcade_core/backend/keys.py,sha256=LTg20SwLBI3kpPIiTNpq2yBft_QUGj-iNFSNm9M-Fus,3010
+mini_arcade_core/backend/sdl_map.py,sha256=_yBRtvaFUcQKy1kcoIf-SPhbbKEW7dzvzBcI6TLmKjc,2060
+mini_arcade_core/backend/types.py,sha256=EW0bW4MvsEZKot0Z1h_5LuFSzoYGiJBphTquBz4oXf4,244
+mini_arcade_core/bus.py,sha256=2Etpoa-UWhk33xJjqDlY5YslPDJEjxNoIEVtF3C73vs,1558
+mini_arcade_core/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/cheats.py,sha256=jMx2a8YnaNCkCG5MPmIzz4uHuS7-_aYf0J45cv2-3v0,5569
+mini_arcade_core/engine/commands.py,sha256=Cw1tAwVRO5U2--hFX1Jq00LH_84oe1Oqw-Ngc0RnkGI,5383
+mini_arcade_core/engine/game.py,sha256=DDdvlv0cN4sjBKtoIuP19W3YQCF1LwZbC_jYCz-1E4U,5767
+mini_arcade_core/engine/game_config.py,sha256=4AP8n0Uk1HKEdPLOrV1xsySzBljAh8VhZASNrxPIMMc,1034
+mini_arcade_core/engine/gameplay_settings.py,sha256=W8WBwfAvGZftkL4aMnOTx6SsGxwG-9Ou1Ey0AeWPCxs,549
+mini_arcade_core/engine/loop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/loop/config.py,sha256=Sj1LrdnD_aACmHUuRQuKB7bDbDZy60WVe8sJHRmzmIU,461
+mini_arcade_core/engine/loop/hooks.py,sha256=nmZi-35iMsZoPedTdZzsIKJP6O_iFUeKjB8xc4-XTHU,2417
+mini_arcade_core/engine/loop/runner.py,sha256=uB4onDMO6lWFt40YNJsovkVHXiyaVdEuEFj8kYqWn6k,8858
+mini_arcade_core/engine/loop/state.py,sha256=fzXQ9GP05PVNXEBTgIwA4qjMujxdUae3CXM6uRQz92Y,858
+mini_arcade_core/engine/managers.py,sha256=eQJYe-xYtRha-FWxzJ3DcpwlcHwiT5sGt4oCD9ZPxEE,664
+mini_arcade_core/engine/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/render/context.py,sha256=igoBmsasv3AJtrIIe2IGkjHXEm5ouEobvdN7Gmm0vxY,1327
+mini_arcade_core/engine/render/effects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/render/effects/base.py,sha256=uix-kfzvN5j3dx655h_Yxe-a3rN1WTtN4tj5zeqFi3c,2357
+mini_arcade_core/engine/render/effects/crt.py,sha256=75ejQVNhftN_GwZV9CYkHv2D672V84zDygmO9h_fo1A,2154
+mini_arcade_core/engine/render/effects/registry.py,sha256=ZBbyyhF4K2gxb4f6hV35uh6RuSj7kOhQgcxwKocqJpY,1212
+mini_arcade_core/engine/render/effects/vignette.py,sha256=K87CjIWpjlWN_tJVrnY3tW2njOvLvnuRezCwk05OgVw,2610
+mini_arcade_core/engine/render/frame_packet.py,sha256=nYHvR7CHlIZa6ZazmPO2dU2P91vEkBjBzUVQGrOkaYc,624
+mini_arcade_core/engine/render/packet.py,sha256=OiAPwGoVHo04OcUWMAoA_N1AFPUMyf8yxNgJthGj4-c,1440
+mini_arcade_core/engine/render/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/render/passes/base.py,sha256=LWgWhfafbCvRKIFbt3koW-ibjYxMfKOIXyLNazCakcM,864
+mini_arcade_core/engine/render/passes/begin_frame.py,sha256=RowMYnkSSQVlMCDVRHXEiy4Hb5Ru-VPBqxsmMzzkXuU,706
+mini_arcade_core/engine/render/passes/end_frame.py,sha256=BBNyVhD8s7B9c_s373g9DDH_eVNGGVnMl5n0GhKIgiw,767
+mini_arcade_core/engine/render/passes/lighting.py,sha256=ugmHHNNZWArL_Xs6-1SQIxLptUTQwe4M2sSPEk8X-7s,677
+mini_arcade_core/engine/render/passes/postfx.py,sha256=YLLcJb1qwNwxg40f_6Nh1xXeGN1tsCnGd8_FdKsfRAM,1424
+mini_arcade_core/engine/render/passes/ui.py,sha256=cct8v0Jjqv6w77IlKz2medPkQjPvG8cCifRv943qyFM,1129
+mini_arcade_core/engine/render/passes/world.py,sha256=OhvDB8aPTkFGlHiROlL9A13pdjWAYGbo8NadkWCUK-c,1522
+mini_arcade_core/engine/render/pipeline.py,sha256=A-Pxw0t0RbW_pswVtBEGNIgC-1dSNqwaK8p7JoXiw8k,3288
+mini_arcade_core/engine/render/render_service.py,sha256=1ueir8MZ6Six5gAHt5StoICPAbyppX4DqzWb8HEuS9g,531
+mini_arcade_core/engine/render/viewport.py,sha256=Fi7O04KRC6d3s01sP0cfchdwegt6s_vOdwomck9yryc,5972
+mini_arcade_core/engine/scenes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/engine/scenes/models.py,sha256=UKKGUWyFf_XFC09hICTFQ6_szDXytoI5KauCmr9ugoM,1217
+mini_arcade_core/engine/scenes/scene_manager.py,sha256=xGzMH7tBsHExN9aYLZsx462aY9r5j-cDNqQvwnK3cI8,6455
+mini_arcade_core/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/audio/audio_adapter.py,sha256=lnP35txPzSKX1_il0nXcK7RMF5Qp9Qhi9YMh_7LTdPM,588
+mini_arcade_core/runtime/audio/audio_port.py,sha256=jBd9WabN41uK3MHjg_1n4AOw83NivJlGE2m430WZTnk,831
+mini_arcade_core/runtime/capture/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/capture/capture_adapter.py,sha256=T3Ca7qCB4ZtGDLE5iKxSWwStMen4RTWdQEn8Zs48tqk,5447
+mini_arcade_core/runtime/capture/capture_port.py,sha256=niHi0pAo10mC9p73FxFkYBIGLOLRN0PiOvxE4Zgo5fM,1162
+mini_arcade_core/runtime/capture/capture_worker.py,sha256=XAzL28jD8jnGoG3bvsd9yQW5S4Nv7licNJn94QTIzp4,5393
+mini_arcade_core/runtime/context.py,sha256=ONKQryO3KEOOqHaByxCUola07kdjrnvr4WfXwgwTobk,1777
+mini_arcade_core/runtime/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/file/file_adapter.py,sha256=09q7G9Qijml9d4AAjo6HLC1yuoVTjE_7xaT8apT4mk0,523
+mini_arcade_core/runtime/file/file_port.py,sha256=p1MouCSHXZw--rWNMw3aYBLU-of8mXaT_suopczPtM8,608
+mini_arcade_core/runtime/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/input/input_adapter.py,sha256=vExQiwFIWTI3zYD8lmnD9TvoQPZvJfI6IINPJUqAdQ0,1467
+mini_arcade_core/runtime/input/input_port.py,sha256=d4ptftwf92_LJdyaUMFxIsLHXBINzQyJACHn4laNyxQ,746
+mini_arcade_core/runtime/input_frame.py,sha256=34-RAfOD-YScVLyRQrarpm7byFTHjsWM77lIH0JsmT8,2384
+mini_arcade_core/runtime/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/render/render_port.py,sha256=Sqp-JBh-iRzzGtgnO_nU1KiJEqyrTYPRDQbg04HdR0A,507
+mini_arcade_core/runtime/scene/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/scene/scene_query_adapter.py,sha256=FNkqXgwxfugX_xqqFlZl0ELXsrW_gco5Au0tJhMGLgQ,909
+mini_arcade_core/runtime/scene/scene_query_port.py,sha256=qTikQVxOkJCdoMoH_lbe_ctJj7SWeJnnqDo6Ee0N_pQ,1019
+mini_arcade_core/runtime/services.py,sha256=iYcXt2CTapgDzSb54DsPasYZ4jTN7tA_B0lV1Sl5b1g,1243
+mini_arcade_core/runtime/window/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/runtime/window/window_adapter.py,sha256=VLZGYBVl7sGMmnk5mVowDleTyciAfE-Tc2woNFvRrgE,2890
+mini_arcade_core/runtime/window/window_port.py,sha256=HBy2OjsZzlxbBDQiTqlKEbIaejpN1zDp5whgvKxZxaY,2322
+mini_arcade_core/scenes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/scenes/autoreg.py,sha256=wsuY7YUSZFmDyToKHFriAG78OU48-7J4BfL_X6T5GBg,1037
+mini_arcade_core/scenes/debug_overlay.py,sha256=t7zWeTxosCUWj3gBDkYF2448EBM5zwLCOEmWVHXghMk,2495
+mini_arcade_core/scenes/registry.py,sha256=DHliUGGiSLWugtRU9R6JeH5gK3GUDICmS-3iie6GtH8,3631
+mini_arcade_core/scenes/sim_scene.py,sha256=32GVR9XHMak-afyyH9M6_UkCPAjRz8XiUKj2lcpAGAE,1061
+mini_arcade_core/scenes/systems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/scenes/systems/base_system.py,sha256=GfMrXsO8ynW3xOxWeav7Ug5XUbRnbF0vo8VzmG7gpec,1075
+mini_arcade_core/scenes/systems/system_pipeline.py,sha256=Cy9y1DclbMLZZ-yx7OKYe34ORoGLNa6dReQfOdiO8SY,1642
+mini_arcade_core/spaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/spaces/d2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/spaces/d2/boundaries2d.py,sha256=xeTnd0pW5DKfqaKsfSBXnufeb45aXNIspgHRyLXWejo,2804
+mini_arcade_core/spaces/d2/collision2d.py,sha256=5IvgLnyVb8i0uzzZuum1noWsNhoxcvHOLaHkmrTMTxQ,1710
+mini_arcade_core/spaces/d2/geometry2d.py,sha256=FuYzef-XdOyb1aeGLJbxINxr0WJHnqFFBgtbPi1WonY,1716
+mini_arcade_core/spaces/d2/kinematics2d.py,sha256=AJ3DhPXNgm6wZYwCljMIE4_2BYx3E2rPcwhXTgQALkU,2030
+mini_arcade_core/spaces/d2/physics2d.py,sha256=OQT7r-zMtmoKD2aWCSNmRAdI0OGIpxGX-pLR8LcAMbQ,1854
+mini_arcade_core/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_arcade_core/ui/menu.py,sha256=t2YpwiKqy4KZHfU9U7c6CUE3SNamBSyipWnd9Y4BVxA,25738
+mini_arcade_core/utils/__init__.py,sha256=id1C0au8r1oIzGha42xXwnI9ojcU1hxPgto6QSh9H8c,236
+mini_arcade_core/utils/deprecated_decorator.py,sha256=yrrW2ZqPskK-4MUTyIrMb465Wc54X2poV53ZQutZWqc,1140
+mini_arcade_core/utils/logging.py,sha256=ygKpey6nikp30PrNDP_yRs8pxPPRbsQ0ivR6LUuEn3Q,6413
+mini_arcade_core/utils/profiler.py,sha256=vLzrxDfAplgKGxpuzk4eFJx4t5DU5M3DQAn6sfS5D_4,8733
+mini_arcade_core-1.2.1.dist-info/METADATA,sha256=me0QR43UEolQONEt9HpCqPM-R9Khq6nq9YNa2GcePtw,8188
+mini_arcade_core-1.2.1.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+mini_arcade_core-1.2.1.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
+mini_arcade_core-1.2.1.dist-info/RECORD,,

{mini_arcade_core-1.1.1.dist-info → mini_arcade_core-1.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

mini_arcade_core/managers/inputs.py

@@ -1,284 +0,0 @@
-"""
-Input manager for handling input bindings and commands.
-"""
-
-# TODO: Implement this manager into the new input system
-# Justification: These module will be used later.
-# pylint: disable=no-name-in-module,import-error,used-before-assignment
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Dict, Optional
-
-from mini_arcade_core.backend import Event, EventType
-from mini_arcade_core.keymaps import Key
-
-if TYPE_CHECKING:
-    from mini_arcade_core.engine.commands import BaseCommand, BaseSceneCommand
-    from mini_arcade_core.scenes.scene import Scene
-
-logger = logging.getLogger(__name__)
-
-
-Predicate = Callable[["Event"], bool]
-
-
-@dataclass(frozen=True)
-class InputBinding:
-    """
-    Defines an input binding.
-
-    :ivar action (str): The action name.
-    :ivar command (BaseCommand): The command to execute.
-    :ivar predicate (Predicate): Predicate to match events.
-    """
-
-    action: str
-    command: BaseCommand
-    predicate: Predicate  # decides whether this binding matches an event
-
-
-class InputManager:
-    """
-    Manager for handling input bindings and commands.
-    """
-
-    def __init__(self):
-        # event_type -> key -> action -> command
-        self._bindings: Dict[EventType, Dict[Key, Dict[str, BaseCommand]]] = {}
-
-    # Justification: The method needs multiple optional parameters for flexibility.
-    # pylint: disable=too-many-arguments
-    def bind(
-        self,
-        event_type: EventType,
-        action: str,
-        command: BaseCommand,
-        *,
-        key: Optional[Key] = None,
-        button: Optional[int] = None,
-        predicate: Optional[Predicate] = None,
-    ):
-        """
-        Generic binding.
-
-        You can filter by:
-        - key: for KEYDOWN/KEYUP
-        - button: for MOUSEBUTTONDOWN/MOUSEBUTTONUP (if your Event exposes it)
-        - predicate: custom matcher (for anything)
-
-        :param event_type: The type of event to bind to.
-        :type event_type: EventType
-
-        :param action: The action name for the binding.
-        :type action: str
-
-        :param command: The command to execute when the binding is triggered.
-        :type command: BaseCommand
-
-        :param key: Optional key to filter KEYDOWN/KEYUP events.
-        :type key: Key | None
-
-        :param button: Optional button to filter MOUSEBUTTONDOWN/MOUSEBUTTONUP events.
-        :type button: int | None
-
-        :param predicate: Optional custom predicate to match events.
-        :type predicate: Predicate | None
-        """
-        logger.debug(
-            f"Binding {action} to {event_type} with key={key}, button={button}"
-        )
-
-        def default_predicate(ev: Event) -> bool:
-            if key is not None and getattr(ev, "key", None) != key:
-                return False
-            if button is not None and getattr(ev, "button", None) != button:
-                return False
-            return True
-
-        pred = predicate or default_predicate
-        self._bindings.setdefault(event_type, []).append(
-            InputBinding(action=action, command=command, predicate=pred)
-        )
-
-    # pylint: enable=too-many-arguments
-
-    def unbind(self, event_type: EventType, action: str):
-        """
-        Remove bindings by action for an event type.
-
-        :param event_type: The type of event to unbind from.
-        :type event_type: EventType
-
-        :param action: The action name of the binding to remove.
-        :type action: str
-        """
-        lst = self._bindings.get(event_type, [])
-        self._bindings[event_type] = [b for b in lst if b.action != action]
-
-    def clear(self):
-        """Clear all input bindings."""
-        self._bindings.clear()
-
-    def handle_event(self, event: Event, scene: Scene):
-        """
-        Handle an incoming event, executing any matching commands.
-
-        :param event: The event to handle.
-        :type event: Event
-
-        :param scene: The current scene context.
-        :type scene: Scene
-        """
-        et = event.type
-
-        for binding in self._bindings.get(et, []):
-            if binding.predicate(event):
-                to_inject = (
-                    scene.model
-                    if isinstance(binding.command, BaseSceneCommand)
-                    else scene.game
-                )
-                binding.command.execute(to_inject)
-
-    def on_quit(self, command: BaseCommand, action: str = "quit"):
-        """
-        Bind a command to the QUIT event.
-
-        :param command: The command to execute on quit.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.QUIT, action=action, command=command)
-
-    def on_key_down(self, key: Key, command: BaseCommand, action: str):
-        """
-        Bind a command to a key down event.
-
-        :param key: The key to bind to.
-        :type key: Key
-
-        :param command: The command to execute on key down.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.KEYDOWN, key=key, action=action, command=command)
-
-    def on_key_up(self, key: Key, command: BaseCommand, action: str):
-        """
-        Bind a command to a key up event.
-
-        :param key: The key to bind to.
-        :type key: Key
-
-        :param command: The command to execute on key up.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.KEYUP, key=key, action=action, command=command)
-
-    def on_mouse_button_down(
-        self, button: int, command: BaseCommand, action: str
-    ):
-        """
-        Bind a command to a mouse button down event.
-
-        :param button: The mouse button to bind to.
-        :type button: int
-
-        :param command: The command to execute on mouse button down.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(
-            EventType.MOUSEBUTTONDOWN,
-            button=button,
-            action=action,
-            command=command,
-        )
-
-    def on_mouse_button_up(
-        self, button: int, command: BaseCommand, action: str
-    ):
-        """
-        Bind a command to a mouse button up event.
-
-        :param button: The mouse button to bind to.
-        :type button: int
-
-        :param command: The command to execute on mouse button up.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(
-            EventType.MOUSEBUTTONUP,
-            button=button,
-            action=action,
-            command=command,
-        )
-
-    def on_mouse_motion(
-        self, command: BaseCommand, action: str = "mouse_motion"
-    ):
-        """
-        Bind a command to mouse motion events.
-
-        :param command: The command to execute on mouse motion.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.MOUSEMOTION, action=action, command=command)
-
-    def on_mouse_wheel(
-        self, command: BaseCommand, action: str = "mouse_wheel"
-    ):
-        """
-        Bind a command to mouse wheel events.
-
-        :param command: The command to execute on mouse wheel.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.MOUSEWHEEL, action=action, command=command)
-
-    def on_window_resized(
-        self, command: BaseCommand, action: str = "window_resized"
-    ):
-        """
-        Bind a command to window resized events.
-
-        :param command: The command to execute on window resize.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.WINDOWRESIZED, action=action, command=command)
-
-    def on_text_input(self, command: BaseCommand, action: str = "text_input"):
-        """
-        Bind a command to text input events.
-
-        :param command: The command to execute on text input.
-        :type command: BaseCommand
-
-        :param action: The action name for the binding.
-        :type action: str
-        """
-        self.bind(EventType.TEXTINPUT, action=action, command=command)