pyglet 2.1.12__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/libs/darwin/cocoapy/runtime.py

@@ -38,7 +38,7 @@ from contextlib import contextmanager
 
 from ctypes import *
 from ctypes import util
-from typing import Type, TypeVar, Sequence, Any
+from typing import Type, TypeVar, Sequence, Any, Callable
 
 from .cocoatypes import *
 
@@ -66,33 +66,14 @@ libc = cdll.LoadLibrary(util.find_library('c'))
 libc.free.restype = None
 libc.free.argtypes = [c_void_p]
 
-libc.sysctlbyname.argtypes = [c_char_p, c_void_p, POINTER(c_size_t), c_void_p, c_size_t]
-libc.sysctlbyname.restype = c_int
+_NSConcreteGlobalBlock = c_void_p.in_dll(libc, "_NSConcreteGlobalBlock")
 
-def _sysctl_get(name: str) -> str:
-    name_bytes = name.encode("utf-8")
-
-    size = c_size_t()
-    # Gets buffer size.
-    libc.sysctlbyname(name_bytes, None, byref(size), None, 0)
-
-    buf = create_string_buffer(size.value)
-    libc.sysctlbyname(name_bytes, buf, byref(size), None, 0)
-    return buf.value.decode("utf-8")
-
-def get_chip_model() -> str:
-    """Return Apple chip model name.
-
-    For example: "Apple M2"
-    """
-    try:
-        # Newer field.
-        return _sysctl_get("machdep.cpu.brand_string")
-    except Exception:
-        try:
-            return _sysctl_get("hw.model")
-        except Exception:
-            return "Unknown"
+BLOCK_IS_NOESCAPE      =  (1 << 23)
+BLOCK_HAS_COPY_DISPOSE =  (1 << 25)
+BLOCK_HAS_CTOR =          (1 << 26)
+BLOCK_IS_GLOBAL =         (1 << 28)
+BLOCK_HAS_STRET =         (1 << 29)
+BLOCK_HAS_SIGNATURE =     (1 << 30)
 
 ######################################################################
 
@@ -462,6 +443,9 @@ OBJC_ASSOCIATION_ASSIGN = 0  # Weak reference to the associated object.
 OBJC_ASSOCIATION_RETAIN = 0x0301  # Strong reference to the associated object. The association is made atomically.
 OBJC_ASSOCIATION_COPY = 0x0303  # Specifies that the associated object is copied. The association is made atomically.
 
+class MissingEncodingType(Exception):
+    """If an encoding type is missing."""
+
 
 def ensure_bytes(x: bytes | str) -> bytes:
     """Attempt to encode an object as :py:class:`bytes`.
@@ -820,7 +804,7 @@ def send_super(receiver, selName, *args, superclass_name=None, **kwargs):
 cfunctype_table = {}
 
 
-def parse_type_encoding(encoding):
+def parse_type_encoding(encoding: bytes):
     """Takes a type encoding string and outputs a list of the separated type codes.
     Currently does not handle unions or bitfields and strips out any field width
     specifiers or type specifiers from the encoding.  For Python 3.2+, encoding is
@@ -875,6 +859,9 @@ def parse_type_encoding(encoding):
             if typecode and typecode[-1:] == b'^':
                 # Previous char was pointer specifier, so keep going.
                 typecode += c
+            elif typecode and c == b'?' and typecode[-1:] == b'@':
+                # Block type, combine them.
+                typecode += c
             else:
                 # Add previous type code to the list.
                 if typecode:
@@ -911,8 +898,10 @@ def cfunctype_for_encoding(encoding):
             argtypes.append(typecodes[code])
         elif code[0:1] == b'^' and code[1:] in typecodes:
             argtypes.append(POINTER(typecodes[code[1:]]))
+        elif code[0:2] == b'@?':
+            argtypes.append(c_void_p)
         else:
-            raise Exception('unknown type encoding: ' + code)
+            raise Exception(f'unknown type encoding: {code}')
 
     cfunctype = CFUNCTYPE(*argtypes)
 
@@ -1011,11 +1000,10 @@ class ObjCMethod:
         # Get types for all the arguments.
         try:
             self.argtypes = [self.ctype_for_encoding(t) for t in self.argument_types]
-        except:
-            # print(f'no argtypes encoding for {self.name} ({self.argument_types})')
+        except MissingEncodingType as e:
+            #print(f'no argtypes encoding for {self.name}: {e}')
             self.argtypes = None
         # Get types for the return type.
-
         try:
             if self.return_type == b'@':
                 self.restype = ObjCInstance
@@ -1032,7 +1020,7 @@ class ObjCMethod:
         libc.free(return_type_ptr)
 
 
-    def ctype_for_encoding(self, encoding):
+    def ctype_for_encoding(self, encoding: bytes):
         """Return ctypes type for an encoded Objective-C type."""
         if encoding in self.typecodes:
             return self.typecodes[encoding]
@@ -1047,8 +1035,10 @@ class ObjCMethod:
         elif encoding[0:2] == b'r^' and encoding[2:] in self.typecodes:
             # const pointer, also don't care
             return POINTER(self.typecodes[encoding[2:]])
+        elif encoding[0:2] == b'@?':
+            return c_void_p
         else:
-            raise Exception('unknown encoding for %s: %s' % (self.name, encoding))
+            raise MissingEncodingType(encoding)
 
     def get_prototype(self):
         """Returns a ctypes CFUNCTYPE for the method."""
@@ -1099,7 +1089,8 @@ class ObjCMethod:
             # Add more useful info to argument error exceptions, then reraise.
             error.args += ('selector = ' + str(self.name),
                            'argtypes =' + str(self.argtypes),
-                           'encoding = ' + str(self.encoding))
+                           'encoding = ' + str(self.encoding),
+                           f'args passed = {args}')
             raise
 
 
@@ -1109,7 +1100,7 @@ class ObjCBoundMethod:
     """This represents an Objective-C method (an IMP) which has been bound
     to some id which will be passed as the first parameter to the method."""
 
-    def __init__(self, method, objc_id):
+    def __init__(self, method: ObjCMethod, objc_id):
         """Initialize with a method and ObjCInstance or ObjCClass object."""
         self.method = method
         self.objc_id = objc_id
@@ -1397,11 +1388,10 @@ def get_cached_instances():
     return [(obj.objc_class.name, obj._retained, obj.pool, obj) for obj in ObjCInstance._cached_objects.values()]
 
 
-def convert_method_arguments(encoding, args):
+def convert_method_arguments(arg_encodings, args):
     """Used by ObjCSubclass to convert Objective-C method arguments to
     Python values before passing them on to the Python-defined method."""
     new_args = []
-    arg_encodings = parse_type_encoding(encoding)[3:]
     for e, a in zip(arg_encodings, args):
         if e == b'@':
             new_args.append(ObjCInstance(a))
@@ -1516,18 +1506,20 @@ class ObjCSubclass:
 
         return decorator
 
-    def method(self, encoding):
+    def method(self, encoding: bytes | str):
         """Function decorator for instance methods."""
         # Add encodings for hidden self and cmd arguments.
-        encoding = ensure_bytes(encoding)
-        typecodes = parse_type_encoding(encoding)
+        encoding_bytes = ensure_bytes(encoding)
+        typecodes = parse_type_encoding(encoding_bytes)
         typecodes.insert(1, b'@:')
-        encoding = b''.join(typecodes)
+        encoding_bytes = b''.join(typecodes)
 
         def decorator(f):
+            arg_encoding = parse_type_encoding(encoding_bytes)[3:]
+
             def objc_method(objc_self, objc_cmd, *args):
                 py_self = ObjCInstance(objc_self)
-                args = convert_method_arguments(encoding, args)
+                args = convert_method_arguments(arg_encoding, args)
                 result = f(py_self, *args)
                 if isinstance(result, ObjCClass):
                     result = result.ptr.value
@@ -1536,7 +1528,7 @@ class ObjCSubclass:
                 return result
 
             name = f.__name__.replace('_', ':')
-            self.add_method(objc_method, name, encoding)
+            self.add_method(objc_method, name, encoding_bytes)
             return objc_method
 
         return decorator
@@ -1550,9 +1542,10 @@ class ObjCSubclass:
         encoding = b''.join(typecodes)
 
         def decorator(f):
+            arg_encoding = parse_type_encoding(encoding)[3:]
             def objc_class_method(objc_cls, objc_cmd, *args):
                 py_cls = ObjCClass(objc_cls)
-                args = convert_method_arguments(encoding, args)
+                args = convert_method_arguments(arg_encoding, args)
                 result = f(py_cls, *args)
                 if isinstance(result, ObjCClass):
                     result = result.ptr.value
@@ -1670,3 +1663,46 @@ def AutoReleasePool():
         yield
     finally:
         objc.objc_autoreleasePoolPop(pool)
+
+def get_callback_block(func: Callable, *, encoding: list[bytes | str]):
+    """Creates a block to handle callbacks from ObjC."""
+    bytes_list = [ensure_bytes(char) for char in encoding]
+    return ObjCBlock(func, encoding=bytes_list)
+
+class ObjCBlock:
+    """A basic implementation of a Global ObjC Block.
+
+    You must keep this object alive and referenced.
+    """
+    def __init__(self, func: Callable, *, encoding: list[bytes]):
+        if not callable(func):
+            raise TypeError("Blocks must be callable")
+
+        self.func = func
+
+        # Signature is return, block, args
+        desc_signature = encoding[0] + b"@?" + b"".join(encoding[1:])
+
+        cfunc_type = cfunctype_for_encoding(desc_signature)
+
+        self.cfunc_wrapper = cfunc_type(self._wrapper)
+
+        self._descriptor = Block_descriptor_1(
+            reserved=0,
+            Block_size=sizeof(Block_literal_1),
+            signature=desc_signature,
+        )
+
+        self.literal = Block_literal_1(
+            isa=addressof(_NSConcreteGlobalBlock),
+            flags=BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE,
+            reserved=0,
+            invoke=cast(self.cfunc_wrapper, c_void_p),
+            descriptor=self._descriptor,
+        )
+
+        self.block = cast(byref(self.literal), c_void_p)
+        self._as_parameter_ = self.block  # for ctypes to treat this as the block.
+
+    def _wrapper(self, _block, *args):
+        return self.func(*args)

pyglet/libs/darwin/coreaudio.py

@@ -12,6 +12,7 @@ This module includes:
 * Error checking helpers
 
 """
+from __future__ import annotations
 from ctypes import c_void_p, c_int, c_bool, Structure, c_uint32, util, cdll, c_uint, c_double, POINTER, c_int64, \
     CFUNCTYPE
 from typing import Final
@@ -30,7 +31,7 @@ class AudioStreamPacketDescription(Structure):
     _fields_ = [
         ('mStartOffset', c_int64),
         ('mVariableFramesInPacket', c_uint32),
-        ('mDataByteSize', c_uint32)
+        ('mDataByteSize', c_uint32),
     ]
 
 
@@ -44,10 +45,10 @@ class AudioStreamBasicDescription(Structure):
         ('mBytesPerFrame', c_uint32),
         ('mChannelsPerFrame', c_uint32),
         ('mBitsPerChannel', c_uint32),
-        ('mReserved', c_uint32)
+        ('mReserved', c_uint32),
     ]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"AudioStreamBasicDescription(sample_rate={self.mSampleRate}, channels={self.mChannelsPerFrame}, " \
                f"fmt={self.mFormatID}, bytes_per_packet={self.mBytesPerPacket}, bits={self.mBitsPerChannel}, " \
                f"frames_per_packet={self.mFramesPerPacket}, bytes_per_frame={self.mBytesPerFrame})"
@@ -224,7 +225,6 @@ class CoreAudioException(Exception):
     * kAudio_FileNotFoundError -> OSError (The typical Python file read error
     * kAudioFileInvalidChunkError -> ValueError (Invalid data)
     """
-    ...
 
 
 def err_check(err: int) -> None:

pyglet/{gl → libs/darwin}/lib_agl.py

@@ -3,17 +3,13 @@ from __future__ import annotations
 from typing import Any, Callable, Sequence
 
 import pyglet.lib
-from pyglet.gl.lib import decorate_function, missing_function
-
-from typing import Callable
-
-__all__ = ['link_GL', 'link_AGL']
+from pyglet.graphics.api.gl.lib import decorate_function, missing_function
 
 gl_lib = pyglet.lib.load_library(framework='OpenGL')
 agl_lib = pyglet.lib.load_library(framework='AGL')
 
 
-def link_GL(name: str, restype: Any, argtypes: Any, requires: str | None = None,  # noqa: N802, D103
+def link_GL(name: str, restype: Any, argtypes: Any, requires: str | None = None,  # noqa: N802
             suggestions: Sequence[str] | None = None) -> Callable[..., Any]:
     try:
         func = getattr(gl_lib, name)
@@ -25,8 +21,8 @@ def link_GL(name: str, restype: Any, argtypes: Any, requires: str | None = None,
         return missing_function(name, requires, suggestions)
 
 
-def link_AGL(name: str, restype: Any, argtypes: Any, requires: str | None = None,  # noqa: N802, D103
-            suggestions: Sequence[str] | None = None) -> Callable[..., Any]:
+def link_AGL(name: str, restype: Any, argtypes: Any, requires: str | None = None,  # noqa: N802
+             suggestions: Sequence[str] | None = None) -> Callable[..., Any]:
     try:
         func = getattr(agl_lib, name)
         func.restype = restype
@@ -35,3 +31,8 @@ def link_AGL(name: str, restype: Any, argtypes: Any, requires: str | None = None
         return func
     except AttributeError:
         return missing_function(name, requires, suggestions)
+
+
+link_GL_proxy = link_GL
+
+__all__ = ['link_GL', 'link_GL_proxy', 'link_AGL']

pyglet/libs/darwin/quartzkey.py

@@ -213,7 +213,6 @@ charmap = {
     '!': key.EXCLAMATION,
     '"': key.DOUBLEQUOTE,
     '#': key.HASH,
-    '#': key.POUND,
     '$': key.DOLLAR,
     '%': key.PERCENT,
     '&': key.AMPERSAND,
@@ -248,7 +247,6 @@ charmap = {
     ']': key.BRACKETRIGHT,
     '^': key.ASCIICIRCUM,
     '_': key.UNDERSCORE,
-    '`': key.GRAVE,
     '`': key.QUOTELEFT,
     'A': key.A,
     'B': key.B,
@@ -279,5 +277,5 @@ charmap = {
     '{': key.BRACELEFT,
     '|': key.BAR,
     '}': key.BRACERIGHT,
-    '~': key.ASCIITILDE
+    '~': key.ASCIITILDE,
 }

pyglet/libs/egl/__init__.py

@@ -0,0 +1,2 @@
+from pyglet.libs.egl.egl_lib import *
+from pyglet.libs.egl.eglext import *