pyglet 3.0.dev3__py3-none-any.whl → 3.0.dev4__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.dev4'
 __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

@@ -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

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

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()

pyglet/experimental/win32priority.py

@@ -0,0 +1,68 @@
+# Utilities to patch Pyglet to provide more precise event timing on Windows.
+# HighTimerResolution is generally the most important of the bunch,
+# since most 60+fps games in Windows will not work right without
+# changing the timer resolution for the app
+
+import pyglet
+import ctypes
+
+try:
+    winmm = ctypes.windll.winmm
+    k32 = ctypes.windll.kernel32
+except AttributeError:
+    raise NotImplementedError("This is not a Win32 compatible platform.")
+
+
+class HighTimerResolution:
+    """
+    A context manager to adjust the main Win32 platform event loop.    
+    
+    Events inside the context manager will use the specified resolution of the
+    multimedia timer to provide proper timings for 60fps+ framerates.    
+    On exiting the context manager, the default resolution timer is restored.
+
+    Most 60fps games can use a resolution of 4, but you may need to go as low
+    as 1 to get the most consistent results.
+
+    Example:
+
+    with HighTimerResolution():
+        pyglet.app.run()
+
+    """
+
+    def __init__(self, resolution=1):
+        self.resolution = resolution
+
+    def __enter__(self):
+        winmm.timeBeginPeriod(self.resolution)
+
+    def __exit__(self, *a):
+        winmm.timeEndPeriod()
+
+
+def pin_thread(pin_thread_mask=0x01):
+    """
+    Pin the main Pyglet app thread to one or more cores by way of a thread affinity mask.
+    The default thread mask is 1.
+    """
+    k32.SetThreadAffinityMask(
+        pyglet.app.platform_event_loop._event_thread, pin_thread_mask
+    )
+
+
+def pin_process():
+    """
+    Pins the entire Python interpreter process to the first CPU core.
+    This may slightly improve performance due to affinity.
+    """
+    k32.SetProcessAffinityMask(k32.GetCurrentProcess(), 1)
+
+
+def raise_priority(
+    priority_class=0x080,
+):
+    """
+    Raises the process priority to High. Other priorities can be provided.
+    """
+    k32.SetPriorityClass(-1, priority_class)

pyglet/font/dwrite/__init__.py

@@ -108,7 +108,7 @@ from pyglet.font.dwrite.dwrite_lib import (
     DWRITE_INFORMATIONAL_STRING_FULL_NAME,
 )
 from pyglet.font.harfbuzz import get_harfbuzz_shaped_glyphs, get_resource_from_dw_font, harfbuzz_available
-from pyglet.image.codecs.wincodec_lib import GUID_WICPixelFormat32bppPBGRA, IWICBitmap
+from pyglet.libs.win32.wincodec import GUID_WICPixelFormat32bppPBGRA, IWICBitmap
 from pyglet.libs.win32 import UINT16, UINT32, UINT64, com
 from pyglet.libs.win32 import _kernel32 as kernel32
 from pyglet.libs.win32.constants import (

pyglet/font/dwrite/d2d1_lib.py

@@ -28,7 +28,7 @@ from pyglet.font.dwrite.dwrite_lib import (
     IDWriteTextFormat,
     IDWriteTextLayout,
 )
-from pyglet.image.codecs.wincodec_lib import IWICBitmap, IWICBitmapSource
+from pyglet.libs.win32.wincodec import IWICBitmap, IWICBitmapSource
 from pyglet.libs.win32 import c_void, com
 from pyglet.libs.win32.types import BYTE, UINT32, UINT64
 

pyglet/font/fontconfig.py

@@ -196,7 +196,7 @@ class FontConfig:
         return FontConfigSearchPattern(self._fontconfig)
 
     def style_from_face(self, font_face: FT_Face):
-        pattern = self._fontconfig.FcFreeTypeQueryFace(font_face, None, 0, None)
+        pattern = self._fontconfig.FcFreeTypeQueryFace(font_face, b'', 0, None)
         result = FontConfigSearchResult(self._fontconfig, pattern)
         return result.weight, result.italic, result.stretch