pyglet 2.0.9__zip → 2.0.10__zip

pyglet-2.0.10/pyglet/experimental/net.py

@@ -0,0 +1,247 @@
+"""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,
+socket server/client examples, and are not ready to be used in production.
+They are included here to solicit feedback, and possibly spark further
+development. Basic Server usage::
+
+    server = net.Server(address='0.0.0.0', port=1234)
+    active_connections = weakref.WeakSet()
+
+    def pong(connection, message):
+        print(f"Received '{message}' from '{connection}'")
+        connection.send(b'pong')
+
+    @server.event
+    def on_connection(connection):
+        print(f"New client connected: {connection}")
+        connection.set_handler('on_receive', pong)
+        active_connections.add(connection)
+
+    @server.event
+    def on_disconnect(connection):
+        print(f"Client disconnected: {connection}")
+        active_connections.discard(connection)
+
+
+Basic Client example::
+
+    client = net.Client(address='localhost', port=1234)
+
+    @client.event
+    def on_receive(client, message):
+        print(f"Received: {message}")
+
+    @client.event
+    def on_disconnect(client):
+        print(f"Disconnected: {client}")
+
+    client.send(b'ping')
+
+"""
+
+
+import queue as _queue
+import struct as _struct
+import socket as _socket
+import asyncio as _asyncio
+import threading as _threading
+
+from pyglet.event import EventDispatcher as _EventDispatcher
+
+from pyglet.util import debug_print
+
+_debug_net = debug_print(True)
+
+
+class Client(_EventDispatcher):
+    def __init__(self, address, port):
+        """Create a Client connection to a Server."""
+        self._socket = _socket.create_connection((address, port))
+        self._address = address
+        self._port = port
+
+        self._terminate = _threading.Event()
+        self._queue = _queue.Queue()
+
+        _threading.Thread(target=self._recv, daemon=True).start()
+        _threading.Thread(target=self._send, daemon=True).start()
+
+        self._sentinal = object()  # poison pill
+
+    def close(self):
+        """Close the connection."""
+        self._queue.put(self._sentinal)
+        self._socket.shutdown(1)
+        if not self._terminate.is_set():
+            self._terminate.set()
+            self.dispatch_event('on_disconnect', self)
+
+    def send(self, message):
+        """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
+                A string of bytes to send.
+        """
+        if self._terminate.is_set():
+            raise ConnectionError("Connection is closed.")
+        self._queue.put(message)
+
+    def _send(self):    # Thread
+        """Background Thread to send messages from the queue."""
+        while not self._terminate.is_set():
+            message = self._queue.get()
+            if message == self._sentinal:  # bail out on poison pill
+                break
+            try:
+                # Attach a 4byte header to the front of the message:
+                packet = _struct.pack('I', len(message)) + message
+                self._socket.sendall(packet)
+            except (ConnectionError, OSError):
+                self.close()
+                break
+
+        assert _debug_net("Exiting _send thread")
+
+
+    def _recv(self):    # Thread
+        socket = self._socket
+
+        while not self._terminate.is_set():
+            try:
+                header = socket.recv(4)
+                while len(header) < 4:
+                    header += socket.recv(4 - len(header))
+                size = _struct.unpack('I', header)[0]
+
+                message = socket.recv(size)
+                while len(message) < size:
+                    message += socket.recv(size)
+                self.dispatch_event('on_receive', self, message)
+            except (ConnectionError, OSError):
+                self.close()
+                break
+
+        assert _debug_net("Exiting _recv thread")
+
+    def on_receive(self, connection, message):
+        """Event for received messages."""
+
+    def on_disconnect(self, connection):
+        """Event for disconnection. """
+
+    def __repr__(self):
+        return f"Client(address={self._address}, port={self._port})"
+
+
+Client.register_event_type('on_receive')
+Client.register_event_type('on_disconnect')
+
+
+class ClientConnection(_EventDispatcher):
+
+    def __init__(self, reader, writer):
+        self._reader = reader
+        self._writer = writer
+        self._closed = False
+        self._loop = _asyncio.get_event_loop()
+        _asyncio.run_coroutine_threadsafe(self._recv(), self._loop)
+
+    def close(self):
+        if not self._closed:
+            self._writer.transport.close()
+            self._closed = True
+            self.dispatch_event('on_disconnect', self)
+
+    async def _recv(self):
+        while not self._closed:
+            try:
+                header = await self._reader.readexactly(4)
+                size = _struct.unpack('I', header)[0]
+                message = await self._reader.readexactly(size)
+                self._loop.call_soon(self.dispatch_event, 'on_receive', self, message)
+
+            except _asyncio.IncompleteReadError:
+                self.close()
+                break
+
+    async def _send(self, message):
+        try:
+            packet = _struct.pack('I', len(message)) + message
+            self._writer.write(packet)
+            await self._writer.drain()
+        except ConnectionResetError:
+            self.close()
+
+    def send(self, message):
+        # Synchrounously send a message in an async coroutine.
+        if self._writer.transport is None or self._writer.transport.is_closing():
+            self.close()
+            return
+        _future = _asyncio.run_coroutine_threadsafe(self._send(message), self._loop)
+
+    def on_receive(self, connection, message):
+        """Event for received messages."""
+
+    def on_disconnect(self, connection):
+        """Event for disconnection. """
+
+    def __del__(self):
+        assert _debug_net(f"Connection garbage collected: {self}")
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({id(self)})"
+
+
+ClientConnection.register_event_type('on_receive')
+ClientConnection.register_event_type('on_disconnect')
+
+
+class Server(_EventDispatcher):
+
+    def __init__(self, address, port):
+        self._address = address
+        self._port = port
+
+        self._server = None
+
+        self._thread = _threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+        blurb = f"Server listening on {address}:{port}"
+        assert _debug_net(f"{'-' * len(blurb)}\n{blurb}\n{'-' * len(blurb)}")
+
+
+    async def handle_connection(self, reader, writer):
+        connection = ClientConnection(reader, writer)
+        self.dispatch_event('on_connection', connection)
+
+    async def _start_server(self):
+        self._server = await _asyncio.start_server(self.handle_connection, self._address, self._port)
+        async with self._server:
+            await self._server.serve_forever()
+
+    def _run(self):
+        try:
+            _asyncio.run(self._start_server())
+        except KeyboardInterrupt:
+            self._server.close()
+
+    def on_connection(self, connection):
+        """Event for new Client connections."""
+        assert _debug_net("Connected <---", connection)
+        connection.set_handler('on_disconnect', self.on_disconnect)
+
+    def on_disconnect(self, connection):
+        """Event for disconnected Clients."""
+        assert _debug_net("Disconnected --->", connection)
+
+
+Server.register_event_type('on_connection')
+Server.register_event_type('on_disconnect')

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/font/directwrite.py

@@ -266,30 +266,29 @@ class DWRITE_CLUSTER_METRICS(ctypes.Structure):
 class IDWriteFontFileStream(com.IUnknown):
     _methods_ = [
         ('ReadFileFragment',
-         com.STDMETHOD(c_void_p, POINTER(c_void_p), UINT64, UINT64, POINTER(c_void_p))),
+         com.STDMETHOD(POINTER(c_void_p), UINT64, UINT64, POINTER(c_void_p))),
         ('ReleaseFileFragment',
-         com.STDMETHOD(c_void_p, c_void_p)),
+         com.STDMETHOD(c_void_p)),
         ('GetFileSize',
-         com.STDMETHOD(c_void_p, POINTER(UINT64))),
+         com.STDMETHOD(POINTER(UINT64))),
         ('GetLastWriteTime',
-         com.STDMETHOD(c_void_p, POINTER(UINT64))),
+         com.STDMETHOD(POINTER(UINT64))),
     ]
 
 
 class IDWriteFontFileLoader_LI(com.IUnknown):  # Local implementation use only.
     _methods_ = [
         ('CreateStreamFromKey',
-         com.STDMETHOD(c_void_p, c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileStream))))
+         com.STDMETHOD(c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileStream))))
     ]
 
 
 class IDWriteFontFileLoader(com.pIUnknown):
     _methods_ = [
         ('CreateStreamFromKey',
-         com.STDMETHOD(c_void_p, c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileStream))))
+         com.STDMETHOD(c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileStream))))
     ]
 
-
 class IDWriteLocalFontFileLoader(IDWriteFontFileLoader, com.pIUnknown):
     _methods_ = [
         ('GetFilePathLengthFromKey',
@@ -452,13 +451,13 @@ DWRITE_READING_DIRECTION_LEFT_TO_RIGHT = 0
 class IDWriteTextAnalysisSource(com.IUnknown):
     _methods_ = [
         ('GetTextAtPosition',
-         com.METHOD(HRESULT, c_void_p, UINT32, POINTER(c_wchar_p), POINTER(UINT32))),
+         com.STDMETHOD(UINT32, POINTER(c_wchar_p), POINTER(UINT32))),
         ('GetTextBeforePosition',
-         com.STDMETHOD(UINT32, c_wchar_p, POINTER(UINT32))),
+         com.STDMETHOD(UINT32, POINTER(c_wchar_p), POINTER(UINT32))),
         ('GetParagraphReadingDirection',
          com.METHOD(DWRITE_READING_DIRECTION)),
         ('GetLocaleName',
-         com.STDMETHOD(c_void_p, UINT32, POINTER(UINT32), POINTER(c_wchar_p))),
+         com.STDMETHOD(UINT32, POINTER(UINT32), POINTER(c_wchar_p))),
         ('GetNumberSubstitution',
          com.STDMETHOD(UINT32, POINTER(UINT32), c_void_p)),
     ]
@@ -467,7 +466,7 @@ class IDWriteTextAnalysisSource(com.IUnknown):
 class IDWriteTextAnalysisSink(com.IUnknown):
     _methods_ = [
         ('SetScriptAnalysis',
-         com.STDMETHOD(c_void_p, UINT32, UINT32, POINTER(DWRITE_SCRIPT_ANALYSIS))),
+         com.STDMETHOD(UINT32, UINT32, POINTER(DWRITE_SCRIPT_ANALYSIS))),
         ('SetLineBreakpoints',
          com.STDMETHOD(UINT32, UINT32, c_void_p)),
         ('SetBidiLevel',
@@ -524,7 +523,7 @@ class TextAnalysis(com.COMObject):
 
         analyzer.AnalyzeScript(self, 0, text_length, self)
 
-    def SetScriptAnalysis(self, this, textPosition, textLength, scriptAnalysis):
+    def SetScriptAnalysis(self, textPosition, textLength, scriptAnalysis):
         # textPosition - The index of the first character in the string that the result applies to
         # textLength - How many characters of the string from the index that the result applies to
         # scriptAnalysis - The analysis information for all glyphs starting at position for length.
@@ -542,10 +541,10 @@ class TextAnalysis(com.COMObject):
         return 0
         # return 0x80004001
 
-    def GetTextBeforePosition(self, this, textPosition, textString, textLength):
+    def GetTextBeforePosition(self, textPosition, textString, textLength):
         raise Exception("Currently not implemented.")
 
-    def GetTextAtPosition(self, this, textPosition, textString, textLength):
+    def GetTextAtPosition(self, textPosition, textString, textLength):
         # This method will retrieve a substring of the text in this layout
         #   to be used in an analysis step.
         # Arguments:
@@ -568,7 +567,7 @@ class TextAnalysis(com.COMObject):
     def GetParagraphReadingDirection(self):
         return 0
 
-    def GetLocaleName(self, this, textPosition, textLength, localeName):
+    def GetLocaleName(self, textPosition, textLength, localeName):
         self.__local_name = c_wchar_p("")  # TODO: Add more locales.
         localeName[0] = self.__local_name
         textLength[0] = self._textlength - textPosition
@@ -954,16 +953,16 @@ class IDWriteTextLayout1(IDWriteTextLayout, IDWriteTextFormat, com.pIUnknown):
 class IDWriteFontFileEnumerator(com.IUnknown):
     _methods_ = [
         ('MoveNext',
-         com.STDMETHOD(c_void_p, POINTER(BOOL))),
+         com.STDMETHOD(POINTER(BOOL))),
         ('GetCurrentFontFile',
-         com.STDMETHOD(c_void_p, c_void_p)),
+         com.STDMETHOD(c_void_p)),
     ]
 
 
 class IDWriteFontCollectionLoader(com.IUnknown):
     _methods_ = [
         ('CreateEnumeratorFromKey',
-         com.STDMETHOD(c_void_p, c_void_p, c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileEnumerator)))),
+         com.STDMETHOD(c_void_p, c_void_p, UINT32, POINTER(POINTER(IDWriteFontFileEnumerator)))),
     ]
 
 
@@ -971,20 +970,12 @@ class MyFontFileStream(com.COMObject):
     _interfaces_ = [IDWriteFontFileStream]
 
     def __init__(self, data):
+        super().__init__()
         self._data = data
         self._size = len(data)
         self._ptrs = []
 
-    def AddRef(self, this):
-        return 1
-
-    def Release(self, this):
-        return 1
-
-    def QueryInterface(self, this, refiid, tester):
-        return 0
-
-    def ReadFileFragment(self, this, fragmentStart, fileOffset, fragmentSize, fragmentContext):
+    def ReadFileFragment(self, fragmentStart, fileOffset, fragmentSize, fragmentContext):
         if fileOffset + fragmentSize > self._size:
             return 0x80004005  # E_FAIL
 
@@ -997,14 +988,14 @@ class MyFontFileStream(com.COMObject):
         fragmentContext[0] = None
         return 0
 
-    def ReleaseFileFragment(self, this, fragmentContext):
+    def ReleaseFileFragment(self, fragmentContext):
         return 0
 
-    def GetFileSize(self, this, fileSize):
+    def GetFileSize(self, fileSize):
         fileSize[0] = self._size
         return 0
 
-    def GetLastWriteTime(self, this, lastWriteTime):
+    def GetLastWriteTime(self, lastWriteTime):
         return 0x80004001  # E_NOTIMPL
 
 
@@ -1012,21 +1003,13 @@ class LegacyFontFileLoader(com.COMObject):
     _interfaces_ = [IDWriteFontFileLoader_LI]
 
     def __init__(self):
+        super().__init__()
         self._streams = {}
 
-    def QueryInterface(self, this, refiid, tester):
-        return 0
-
-    def AddRef(self, this):
-        return 1
-
-    def Release(self, this):
-        return 1
-
-    def CreateStreamFromKey(self, this, fontfileReferenceKey, fontFileReferenceKeySize, fontFileStream):
+    def CreateStreamFromKey(self, fontfileReferenceKey, fontFileReferenceKeySize, fontFileStream):
         convert_index = cast(fontfileReferenceKey, POINTER(c_uint32))
 
-        self._ptr = ctypes.cast(self._streams[convert_index.contents.value]._pointers[IDWriteFontFileStream],
+        self._ptr = ctypes.cast(self._streams[convert_index.contents.value].as_interface(IDWriteFontFileStream),
                                 POINTER(IDWriteFontFileStream))
         fontFileStream[0] = self._ptr
         return 0
@@ -1039,6 +1022,7 @@ class MyEnumerator(com.COMObject):
     _interfaces_ = [IDWriteFontFileEnumerator]
 
     def __init__(self, factory, loader):
+        super().__init__()
         self.factory = cast(factory, IDWriteFactory)
         self.key = "pyglet_dwrite"
         self.size = len(self.key)
@@ -1057,7 +1041,7 @@ class MyEnumerator(com.COMObject):
     def AddFontData(self, fonts):
         self._font_data = fonts
 
-    def MoveNext(self, this, hasCurrentFile):
+    def MoveNext(self, hasCurrentFile):
 
         self.current_index += 1
         if self.current_index != len(self._font_data):
@@ -1087,7 +1071,7 @@ class MyEnumerator(com.COMObject):
 
         pass
 
-    def GetCurrentFontFile(self, this, fontFile):
+    def GetCurrentFontFile(self, fontFile):
         fontFile = cast(fontFile, POINTER(IDWriteFontFile))
         fontFile[0] = self._font_files[self.current_index]
         return 0
@@ -1097,24 +1081,14 @@ class LegacyCollectionLoader(com.COMObject):
     _interfaces_ = [IDWriteFontCollectionLoader]
 
     def __init__(self, factory, loader):
+        super().__init__()
         self._enumerator = MyEnumerator(factory, loader)
 
     def AddFontData(self, fonts):
         self._enumerator.AddFontData(fonts)
 
-    def AddRef(self, this):
-        self._i = 1
-        return 1
-
-    def Release(self, this):
-        self._i = 0
-        return 1
-
-    def QueryInterface(self, this, refiid, tester):
-        return 0
-
-    def CreateEnumeratorFromKey(self, this, factory, key, key_size, enumerator):
-        self._ptr = ctypes.cast(self._enumerator._pointers[IDWriteFontFileEnumerator],
+    def CreateEnumeratorFromKey(self, factory, key, key_size, enumerator):
+        self._ptr = ctypes.cast(self._enumerator.as_interface(IDWriteFontFileEnumerator),
                                 POINTER(IDWriteFontFileEnumerator))
 
         enumerator[0] = self._ptr
@@ -2418,7 +2392,7 @@ class Win32DirectWriteFont(base.Font):
 
             # Note: RegisterFontLoader takes a pointer. However, for legacy we implement our own callback interface.
             # Therefore we need to pass to the actual pointer directly.
-            cls._write_factory.RegisterFontFileLoader(cls._font_loader.pointers[IDWriteFontFileLoader_LI])
+            cls._write_factory.RegisterFontFileLoader(cls._font_loader.as_interface(IDWriteFontFileLoader_LI))
 
             cls._font_collection_loader = LegacyCollectionLoader(cls._write_factory, cls._font_loader)
             cls._write_factory.RegisterFontCollectionLoader(cls._font_collection_loader)
@@ -2472,7 +2446,7 @@ class Win32DirectWriteFont(base.Font):
                 cls._font_collection_loader = LegacyCollectionLoader(cls._write_factory, cls._font_loader)
 
                 cls._write_factory.RegisterFontCollectionLoader(cls._font_collection_loader)
-                cls._write_factory.RegisterFontFileLoader(cls._font_loader.pointers[IDWriteFontFileLoader_LI])
+                cls._write_factory.RegisterFontFileLoader(cls._font_loader.as_interface(IDWriteFontFileLoader_LI))
 
             cls._font_collection_loader.AddFontData(cls._font_cache)
 

{pyglet-2.0.9 → pyglet-2.0.10}/pyglet/font/win32.py

@@ -336,7 +336,7 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
             pass
 
     def _create_bitmap(self, width, height):
-        self._data = (ctypes.c_byte * (4 * width * height))()
+        self._data = (BYTE * (4 * width * height))()
         self._bitmap = ctypes.c_void_p()
         self._format = PixelFormat32bppARGB
         gdiplus.GdipCreateBitmapFromScan0(width, height, width * 4,
@@ -532,6 +532,12 @@ class GDIPlusFont(Win32Font):
         self._name = name
 
         family = ctypes.c_void_p()
+
+        # GDI will add @ in front of a localized font for some Asian languages. However, GDI will also not find it
+        # based on that name (???). Here we remove it before checking font collections.
+        if name[0] == "@":
+            name = name[1:]
+
         name = ctypes.c_wchar_p(name)
 
         # Look in private collection first:
@@ -540,6 +546,9 @@ class GDIPlusFont(Win32Font):
 
         # Then in system collection:
         if not family:
+            if _debug_font:
+                print(f"Warning: Font '{name}' was not found. Defaulting to: {self._default_name}")
+
             gdiplus.GdipCreateFontFamilyFromName(name, None, ctypes.byref(family))
 
         # Nothing found, use default font.