pyglet 3.0.dev3__py3-none-any.whl → 3.0.dev5__py3-none-any.whl

pyglet/__init__.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '3.0.dev3'
+version = '3.0.dev5'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -103,7 +103,7 @@ class Options:
 
     debug_graphics_batch: bool = False
     """If ``True``, prints batch information being drawn, including :py:class:`~pyglet.graphics.Group`'s, VertexDomains,
-    and :py:class:`~pyglet.graphics.Texture` information. This can be useful to see how many Group's are being
+    and :py:class:`~pyglet.graphics.texture.Texture` information. This can be useful to see how many Group's are being
     consolidated."""
 
     debug_lib: bool = False

pyglet/app/cocoa.py

@@ -6,7 +6,7 @@ import time
 from pyglet import app
 from pyglet.app.base import PlatformEventLoop, EventLoop
 from pyglet.libs.darwin import cocoapy, AutoReleasePool, ObjCSubclass, PyObjectEncoding, ObjCInstance, send_super, \
-    ObjCClass, get_selector
+    ObjCClass, get_selector, set_realtime_thread_policy
 
 NSApplication = cocoapy.ObjCClass('NSApplication')
 NSMenu = cocoapy.ObjCClass('NSMenu')
@@ -161,6 +161,7 @@ class CocoaPlatformEventLoop(PlatformEventLoop):
 
     def __init__(self):
         super().__init__()
+        set_realtime_thread_policy()
         self._timer = None
 
         with AutoReleasePool():

pyglet/customtypes.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ctypes
 import sys
 
-from typing import Union, Literal, Type, Protocol, Tuple
+from typing import Union, Literal, Type, Protocol, Tuple, runtime_checkable
 
 from ctypes import _SimpleCData, _Pointer  # type: ignore  # noqa: PGH003
 
@@ -22,8 +22,8 @@ MediaTypes = Literal["audio", "video", "image"]
 
 Number = Union[int, float]
 
-RGBColor = Tuple[Number, Number, Number]
-RGBAColor = Tuple[Number, Number, Number, Number]
+RGBColor = Tuple[int, int, int]
+RGBAColor = Tuple[int, int, int, int]
 
 DataTypes = Literal[
     'f',  # float
@@ -44,11 +44,16 @@ CTypesPointer = _Pointer
 
 
 
+@runtime_checkable
 class ScissorProtocol(Protocol):
-    x: int
-    y: int
-    width: int
-    height: int
+    """Protocol for an object that holds information for scissor states."""
+
+    @property
+    def area(self) -> tuple[int, int, int, int]:
+        """Return the region of the scissor area.
+
+        Requires the x, y, width, and height in screen space coordinates.
+        """
 
 
 
@@ -64,4 +69,5 @@ __all__ = [
     "MediaTypes",
     "RGBAColor",
     "RGBColor",
+    "ScissorProtocol",
 ]

pyglet/event.py

@@ -356,8 +356,16 @@ class EventDispatcher:
             if not handler:
                 continue
             if isinstance(handler, WeakMethod):
-                handler = handler()
-                assert handler is not None
+                weak_handler = handler
+                handler = weak_handler()
+                if handler is None:
+                    # Weak handlers can expire before their callback is removed from stack.
+                    # Skip and remove stale handlers
+                    if frame.get(event_type) is weak_handler:
+                        del frame[event_type]
+                        if not frame and frame in self._event_stack:
+                            self._event_stack.remove(frame)
+                    continue
             try:
                 invoked = True
                 if handler(*args):

pyglet/experimental/README.md

@@ -3,4 +3,29 @@ Experimental modules
 
 This package contains experimental modules, which are included here for
 wider testing and feedback. Anything contained within may be broken, refactored,
-or removed without notice.
+or removed without notice.
+
+A module may belong in `experimental` when it meets one or more of the following criteria:
+
+- The API is still being designed.
+- The implementation needs wider testing.
+- The feature depends on external tools, generated assets, or optional workflows.
+- The feature is useful, but too specialized for the core package.
+- The feature introduces complexity that should not be required for normal users.
+- The feature may eventually move into the stable package after review.
+
+## Requirements 
+
+Each experimental module should include documentation explaining:
+
+- What the module solves or does.
+- What tools, files, or assets are required.
+- A minimal example, either as a `"__main__"` execution, or docstring.
+
+## Graduation to stable API
+
+An experimental module may be considered for promotion to the stable package when:
+
+- The API has proven useful and reasonably stable.
+- The feature has documentation and examples.
+- Maintainers are willing to support it long-term.

pyglet/experimental/flaccodec.py

@@ -0,0 +1,380 @@
+import re
+import struct
+
+from concurrent.futures import ProcessPoolExecutor
+
+from pyglet.util import DecodeException
+from pyglet.media.codecs.base import StreamingSource, AudioData, AudioFormat, StaticSource
+from pyglet.media.codecs import MediaDecoder
+
+
+# This module uses code from Project Nayuki:
+# https://www.nayuki.io/page/simple-flac-implementation
+
+
+class FLACDecodeException(DecodeException):
+    pass
+
+
+FIXED_PREDICTION_COEFFICIENTS = ((), (1,), (2, -1), (3, -3, 1), (4, -6, 4, -1))
+
+
+def _initializer(filename, numchannels, sample_size):
+    """Function to open a copy of the file locally in each Process."""
+    global _file
+    global _numchannels
+    global _sample_size
+    _file = open(filename, 'rb')
+    _numchannels = numchannels
+    _sample_size = sample_size
+
+
+def decode_frame(offset):
+    try:
+        # Read a ton of header fields, and ignore most of them
+        numchannels = _numchannels
+        sample_size = _sample_size
+        _file.seek(offset)
+        inp = BitInputStream(_file)
+
+        temp = inp.read_byte()
+        if temp == -1:
+            return False
+        sync = temp << 6 | inp.read_uint(6)
+        if sync != 0x3FFE:
+            raise FLACDecodeException("Sync code expected")
+
+        inp.read_uint(1)
+        inp.read_uint(1)
+        blocksizecode = inp.read_uint(4)
+        sampleratecode = inp.read_uint(4)
+        chanasgn = inp.read_uint(4)
+        inp.read_uint(3)
+        inp.read_uint(1)
+
+        temp = inp.read_uint(8)
+        while temp >= 0b11000000:
+            inp.read_uint(8)
+            temp = (temp << 1) & 0xFF
+
+        if blocksizecode == 1:
+            blocksize = 192
+        elif 2 <= blocksizecode <= 5:
+            blocksize = 576 << blocksizecode - 2
+        elif blocksizecode == 6:
+            blocksize = inp.read_uint(8) + 1
+        elif blocksizecode == 7:
+            blocksize = inp.read_uint(16) + 1
+        elif 8 <= blocksizecode <= 15:
+            blocksize = 256 << (blocksizecode - 8)
+        else:
+            raise FLACDecodeException("Invalid Blocksize")
+
+        if sampleratecode == 12:
+            inp.read_uint(8)
+        elif sampleratecode in (13, 14):
+            inp.read_uint(16)
+
+        crc8 = inp.read_byte()
+
+        # Decode each channel's subframe, then skip footer
+        if 0 <= chanasgn <= 7:
+            samples = [decode_subframe(inp, blocksize, sample_size) for _ in range(chanasgn + 1)]
+        elif 8 <= chanasgn <= 10:
+            temp0 = decode_subframe(inp, blocksize, sample_size + (1 if (chanasgn == 9) else 0))
+            temp1 = decode_subframe(inp, blocksize, sample_size + (0 if (chanasgn == 9) else 1))
+            if chanasgn == 8:
+                for i in range(blocksize):
+                    temp1[i] = temp0[i] - temp1[i]
+            elif chanasgn == 9:
+                for i in range(blocksize):
+                    temp0[i] += temp1[i]
+            elif chanasgn == 10:
+                for i in range(blocksize):
+                    side = temp1[i]
+                    right = temp0[i] - (side >> 1)
+                    temp1[i] = right
+                    temp0[i] = right + side
+            samples = [temp0, temp1]
+        else:
+            raise FLACDecodeException("Reserved channel assignment")
+
+        inp.align_to_byte()
+        inp.read_byte()
+        inp.read_byte()
+
+        # Write the decoded samples
+        fmt = str(blocksize * numchannels) + 'h'
+        if sample_size == 8:
+            return struct.pack(fmt, *(samples[i][j] + 128 for j in range(blocksize) for i in range(numchannels)))
+        else:
+            return struct.pack(fmt, *(samples[i][j] for j in range(blocksize) for i in range(numchannels)))
+    except:
+        return b""
+
+
+def decode_subframe(inp, blocksize, sampledepth):
+    inp.read_uint(1)
+    subframe_type = inp.read_uint(6)
+    shift = inp.read_uint(1)
+    if shift == 1:
+        while inp.read_uint(1) == 0:
+            shift += 1
+    sampledepth -= shift
+
+    if subframe_type == 0:  # Constant coding
+        result = [inp.read_signed_int(sampledepth)] * blocksize
+    elif subframe_type == 1:  # Verbatim coding
+        result = [inp.read_signed_int(sampledepth) for _ in range(blocksize)]
+    elif 8 <= subframe_type <= 12:
+        result = decode_fixed_prediction_subframe(inp, subframe_type - 8, blocksize, sampledepth)
+    elif 32 <= subframe_type <= 63:
+        result = decode_linear_predictive_coding_subframe(inp, subframe_type - 31, blocksize, sampledepth)
+    else:
+        raise FLACDecodeException("Reserved subframe type")
+    return [(v << shift) for v in result]
+
+
+def decode_fixed_prediction_subframe(inp, predorder, blocksize, sampledepth):
+    result = [inp.read_signed_int(sampledepth) for _ in range(predorder)]
+    decode_residuals(inp, blocksize, result)
+    restore_linear_prediction(result, FIXED_PREDICTION_COEFFICIENTS[predorder], 0)
+    return result
+
+
+def decode_linear_predictive_coding_subframe(inp, lpcorder, blocksize, sampledepth):
+    result = [inp.read_signed_int(sampledepth) for _ in range(lpcorder)]
+    precision = inp.read_uint(4) + 1
+    shift = inp.read_signed_int(5)
+    coefs = [inp.read_signed_int(precision) for _ in range(lpcorder)]
+    decode_residuals(inp, blocksize, result)
+    restore_linear_prediction(result, coefs, shift)
+    return result
+
+
+def decode_residuals(inp, blocksize, result):
+    method = inp.read_uint(2)
+    if method >= 2:
+        raise FLACDecodeException("Reserved residual coding method")
+    parambits = [4, 5][method]
+    escapeparam = [0xF, 0x1F][method]
+
+    partitionorder = inp.read_uint(4)
+    numpartitions = 1 << partitionorder
+    if blocksize % numpartitions != 0:
+        raise FLACDecodeException("Block size not divisible by number of Rice partitions")
+
+    for i in range(numpartitions):
+        count = blocksize >> partitionorder
+        if i == 0:
+            count -= len(result)
+        param = inp.read_uint(parambits)
+        if param < escapeparam:
+            result.extend(inp.read_rice_signed_int(param) for _ in range(count))
+        else:
+            numbits = inp.read_uint(5)
+            result.extend(inp.read_signed_int(numbits) for _ in range(count))
+
+
+def restore_linear_prediction(result, coefs, shift):
+    for i in range(len(coefs), len(result)):
+        result[i] += sum((result[i - 1 - j] * c) for (j, c) in enumerate(coefs)) >> shift
+
+
+class BitInputStream:
+    __slots__ = 'inp', 'bitbuffer', 'bitbufferlen'
+
+    def __init__(self, inp):
+        self.inp = inp
+        self.bitbuffer = 0
+        self.bitbufferlen = 0
+
+    def align_to_byte(self):
+        self.bitbufferlen -= self.bitbufferlen % 8
+
+    def read_byte(self):
+        if self.bitbufferlen >= 8:
+            return self.read_uint(8)
+        else:
+            result = self.inp.read(1)
+            if len(result) == 0:
+                return -1
+            return result[0]
+
+    def read_uint(self, n):
+        bitbuffer = self.bitbuffer
+        bitbufferlen = self.bitbufferlen
+
+        while bitbufferlen < n:
+            temp = self.inp.read(1)
+            if len(temp) == 0:
+                raise EOFError()
+            temp = temp[0]
+            bitbuffer = (bitbuffer << 8) | temp
+            bitbufferlen += 8
+        bitbufferlen -= n
+        result = (bitbuffer >> bitbufferlen) & ((1 << n) - 1)
+        bitbuffer &= (1 << bitbufferlen) - 1
+
+        self.bitbuffer = bitbuffer
+        self.bitbufferlen = bitbufferlen
+        return result
+
+    def read_signed_int(self, n):
+        temp = self.read_uint(n)
+        temp -= (temp >> (n - 1)) << n
+        return temp
+
+    def read_rice_signed_int(self, param):
+        read_uint = self.read_uint
+        val = 0
+        while read_uint(1) == 0:
+            val += 1
+        val = (val << param) | read_uint(param)
+        return (val >> 1) ^ -(val & 1)
+
+    def close(self):
+        self.inp.close()
+
+
+def _find_frame_indicies(data):
+    magic1 = struct.pack('BB', int('11111111', 2), int('11111000', 2))
+    magic2 = struct.pack('BB', int('11111111', 2), int('11111001', 2))
+    indices1 = [m.start() for m in re.finditer(magic1, data)]
+    indices2 = [m.start() for m in re.finditer(magic2, data)]
+    indices = indices1 + indices2
+    indices.sort()
+    return indices
+
+
+#########################################
+#   Source class:
+#########################################
+class FLACSource(StreamingSource):
+    def __init__(self, filename, file=None):
+        if file is None:
+            file = open(filename, 'rb')
+
+        self.frame_indices = _find_frame_indicies(file.read())
+        self.frame_index = 0
+        file.seek(0)
+        self._file = BitInputStream(file)
+        self._filename = filename
+
+        if file.read(4) != b'fLaC':
+            raise FLACDecodeException("Does not appear to be a FLAC file.")
+
+        samplerate = numchannels = bits_per_sample = numsamples = None
+
+        last = False
+        while not last:
+            last = self._file.read_uint(1) != 0
+            block_type = self._file.read_uint(7)
+            length = self._file.read_uint(24)
+            if block_type == 0:  # Stream info block
+                min_block_size = self._file.read_uint(16)  # in samples
+                max_block_size = self._file.read_uint(16)  # in samples
+                min_frame_size = self._file.read_uint(24)  # in bytes,  0 == unknown
+                max_frame_size = self._file.read_uint(24)  # in bytes,  0 == unknown
+                samplerate = self._file.read_uint(20)
+                numchannels = self._file.read_uint(3) + 1
+                bits_per_sample = self._file.read_uint(5) + 1
+                numsamples = self._file.read_uint(36)
+                self._file.read_uint(128)
+            else:   # Skip other metadata blocks
+                for i in range(length):
+                    self._file.read_byte()
+
+        for offset in self.frame_indices:
+            if offset < self._file.inp.tell():
+                self.frame_indices.remove(offset)
+
+        if not samplerate:
+            raise FLACDecodeException("Stream info metadata block absent")
+        if bits_per_sample % 8 != 0:
+            raise FLACDecodeException("Sample depth {} not supported".format(bits_per_sample))
+
+        self._numsamples = numsamples
+        self._duration = float(numsamples) / samplerate / 60
+        self.audio_format = AudioFormat(numchannels, bits_per_sample, samplerate)
+
+        self.executor = ProcessPoolExecutor(max_workers=3, initializer=_initializer,
+                                            initargs=(filename, numchannels, bits_per_sample))
+
+    def __del__(self):
+        self._file.close()
+
+    def get_audio_data(self, num_bytes, compensation_time=0.0):
+
+        data = b''
+
+        while not data and (self.frame_index <= len(self.frame_indices)):
+            offset = self.frame_indices[self.frame_index]
+            future = self.executor.submit(decode_frame, offset)
+            data += future.result()
+            self.frame_index += 1
+
+        if not data:
+            return None
+
+        return AudioData(data, len(data), timestamp=0.1, duration=0.5, events=[])
+
+    def save(self, filename="output.wav"):
+        with open(filename, 'wb') as out:
+            numsamples = self._numsamples
+            numchannels = self.audio_format.channels
+            samplerate = self.audio_format.sample_rate
+            sample_size = self.audio_format.sample_size
+
+            # Start writing WAV file headers
+            sampledatalen = numsamples * numchannels * (sample_size // 8)
+
+            out.write(b"RIFF")
+            out.write(struct.pack("<I", sampledatalen + 36))
+            out.write(b"WAVE")
+            out.write(b"fmt ")
+            out.write(struct.pack("<IHHIIHH",
+                                  16,
+                                  0x0001,
+                                  numchannels,
+                                  samplerate,
+                                  samplerate * numchannels * (sample_size // 8),
+                                  numchannels * (sample_size // 8),
+                                  sample_size))
+            out.write(b"data")
+            out.write(struct.pack("<I", sampledatalen))
+
+            import time
+            start = time.time()
+            futures = [self.executor.submit(decode_frame, offset) for offset in self.frame_indices]
+            print("elapsed future making", time.time() - start)
+
+            while futures:
+                data = futures.pop(0).result()
+                out.write(data)
+
+    def seek(self, timestamp):
+        pass
+
+
+#########################################
+#   Decoder class:
+#########################################
+class FLACDecoder(MediaDecoder):
+
+    def get_file_extensions(self):
+        return '.flac',
+
+    def decode(self, file, filename, streaming=True):
+        if streaming:
+            return FLACSource(filename, file)
+        else:
+            return StaticSource(FLACSource(filename, file))
+
+
+def get_decoders():
+    return [FLACDecoder()]
+
+
+def get_encoders():
+    return []

pyglet/experimental/geoshader_sprite.py

@@ -245,7 +245,7 @@ class Sprite(event.EventDispatcher):
         """Create a sprite.
 
         :Parameters:
-            `img` : `~pyglet.image.AbstractImage` or `~pyglet.image.Animation`
+            `img` :
                 Image or animation to display.
             `x` : int
                 X coordinate of the sprite.
@@ -418,11 +418,7 @@ class Sprite(event.EventDispatcher):
 
     @property
     def image(self):
-        """Image or animation to display.
-
-        :type: :py:class:`~pyglet.image.AbstractImage` or
-               :py:class:`~pyglet.image.Animation`
-        """
+        """Image or animation to display."""
         if self._animation:
             return self._animation
         return self._texture
@@ -772,9 +768,16 @@ class Sprite(event.EventDispatcher):
         efficiently.
         """
         ctx = pyglet.graphics.api.core.current_context
-        self._group.set_state_recursive(ctx)
+        draw_ctx = pyglet.graphics.draw.DrawContext(
+            surface_ctx=ctx,
+            backend_ctx=None,
+            draw_pass=pyglet.graphics.draw.BatchDrawOptions().resolve(ctx),
+            renderer=ctx.renderer,
+        )
+        draw_ctx.begin()
+        self._group.set_state_recursive(draw_ctx)
         self._vertex_list.draw(GeometryMode.POINTS)
-        self._group.unset_state_recursive(ctx)
+        self._group.unset_state_recursive(draw_ctx)
 
     def __del__(self):
         try:

pyglet/experimental/net.py

@@ -1,4 +1,4 @@
-"""Experimental networking
+"""Experimental networking.
 
 This module contains experiments in making user-friendly Server and Client
 classes that integrate with pyglet's event system. These are very basic,
@@ -56,7 +56,7 @@ _debug_net = debug_print('debug_net')
 
 
 class Client(_EventDispatcher):
-    def __init__(self, address, port):
+    def __init__(self, address: str, port: int):
         """Create a Client connection to a Server."""
         self._socket = _socket.create_connection((address, port))
         self._address = address
@@ -70,7 +70,7 @@ class Client(_EventDispatcher):
 
         self._sentinal = object()  # poison pill
 
-    def close(self):
+    def close(self) -> None:
         """Close the connection."""
         self._queue.put(self._sentinal)
         self._socket.shutdown(1)
@@ -78,15 +78,15 @@ class Client(_EventDispatcher):
             self._terminate.set()
             self.dispatch_event('on_disconnect', self)
 
-    def send(self, message):
+    def send(self, message: bytes) -> None:
         """Queue a message to send.
 
         Put a string of bytes into the queue to send.
         raises a `ConnectionError` if the connection
         has been closed or dropped.
 
-       :Parameters:
-            `message` : bytes
+        Args:
+            message:
                 A string of bytes to send.
         """
         if self._terminate.is_set():

pyglet/experimental/particles.py

@@ -393,3 +393,41 @@ class ParticleManager:
                           batch=self._batch, group=self._group)
         pyglet.clock.schedule_once(self._delete_callback, self.lifespan, emitter)
         return emitter
+
+
+if __name__ == "__main__":
+    window = pyglet.window.Window(960, 540, caption="ParticleManager Demo", resizable=True)
+
+    batch = graphics.Batch()
+
+    label = pyglet.text.Label("Click and drag.", x=5, y=5, batch=batch)
+
+    particle_img = image.SolidColorImagePattern((255, 255, 255, 255)).create_image(8, 8)
+    manager = ParticleManager(
+        particle_img,
+        lifespan=1.0,
+        count=12,
+        velocity=(100.0, 80.0),
+        spread=(0.30, 0.30),
+        color_start=(255, 200, 80, 220),
+        color_end=(255, 40, 20, 0),
+        scale_start=(0.4, 0.4),
+        scale_end=(1.2, 1.2),
+        rotation=0.0,
+        batch=batch,
+    )
+
+    @window.event
+    def on_draw():
+        window.clear()
+        batch.draw()
+
+    @window.event
+    def on_mouse_press(x, y, button, modifiers):
+        manager.create_emitter(x, y)
+
+    @window.event
+    def on_mouse_drag(x, y, dx, dy, buttons, modifiers):
+        manager.create_emitter(x, y)
+
+    pyglet.app.run()