Improve typing.

Author: Aermoss

sdl3/SDL_assert.py

@@ -10,8 +10,6 @@
 SDL_ASSERTION_RETRY, SDL_ASSERTION_BREAK, SDL_ASSERTION_ABORT, \
     SDL_ASSERTION_IGNORE, SDL_ASSERTION_ALWAYS_IGNORE = range(5)
 
-SDL_AssertData: typing.TypeAlias = SDL_TYPE["SDL_AssertData", ctypes.c_void_p]
-
 class SDL_AssertData(ctypes.Structure):
     _fields_ = [
         ("always_ignore", ctypes.c_bool),
@@ -20,7 +18,7 @@ class SDL_AssertData(ctypes.Structure):
         ("filename", ctypes.c_char_p),
         ("linenum", ctypes.c_int),
         ("function", ctypes.c_char_p),
-        ("next", SDL_POINTER[SDL_AssertData])
+        ("next", SDL_POINTER[ctypes.c_void_p])
     ]
 
 SDL_ReportAssertion: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_ReportAssertion", SDL_AssertState, [SDL_POINTER[SDL_AssertData], ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int], SDL_BINARY]

sdl3/SDL_atomic.py

@@ -21,9 +21,6 @@ class SDL_AtomicInt(ctypes.Structure):
 SDL_GetAtomicInt: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_GetAtomicInt", ctypes.c_int, [SDL_POINTER[SDL_AtomicInt]], SDL_BINARY]
 SDL_AddAtomicInt: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_AddAtomicInt", ctypes.c_int, [SDL_POINTER[SDL_AtomicInt], ctypes.c_int], SDL_BINARY]
 
-class LP_SDL_AtomicInt(ctypes._Pointer):
-    ...
-
 SDL_AtomicIncRef: abc.Callable[[SDL_POINTER[SDL_AtomicInt]], ctypes.c_int] = lambda a: SDL_AddAtomicInt(a, 1)
 SDL_AtomicDecRef: abc.Callable[[SDL_POINTER[SDL_AtomicInt]], bool] = lambda a: SDL_AddAtomicInt(a, -1) == 1
 

sdl3/SDL_audio.py

@@ -32,13 +32,13 @@
 else:
     SDL_AUDIO_S16, SDL_AUDIO_S32, SDL_AUDIO_F32 = SDL_AUDIO_S16BE, SDL_AUDIO_S32BE, SDL_AUDIO_F32BE
 
-SDL_AUDIO_BITSIZE: abc.Callable[[SDL_AudioFormat], int] = lambda x: x & SDL_AUDIO_MASK_BITSIZE
-SDL_AUDIO_BYTESIZE: abc.Callable[[SDL_AudioFormat], int] = lambda x: SDL_AUDIO_BITSIZE(x) / 8
+SDL_AUDIO_BITSIZE: abc.Callable[[SDL_AudioFormat], int] = lambda x: x.value & SDL_AUDIO_MASK_BITSIZE
+SDL_AUDIO_BYTESIZE: abc.Callable[[SDL_AudioFormat], int] = lambda x: int(SDL_AUDIO_BITSIZE(x) / 8)
 
-SDL_AUDIO_ISFLOAT: abc.Callable[[SDL_AudioFormat], int] = lambda x: x & SDL_AUDIO_MASK_FLOAT
-SDL_AUDIO_ISBIGENDIAN: abc.Callable[[SDL_AudioFormat], int] = lambda x: x & SDL_AUDIO_MASK_BIG_ENDIAN
+SDL_AUDIO_ISFLOAT: abc.Callable[[SDL_AudioFormat], int] = lambda x: x.value & SDL_AUDIO_MASK_FLOAT
+SDL_AUDIO_ISBIGENDIAN: abc.Callable[[SDL_AudioFormat], int] = lambda x: x.value & SDL_AUDIO_MASK_BIG_ENDIAN
 SDL_AUDIO_ISLITTLEENDIAN: abc.Callable[[SDL_AudioFormat], bool] = lambda x: not SDL_AUDIO_ISBIGENDIAN(x)
-SDL_AUDIO_ISSIGNED: abc.Callable[[SDL_AudioFormat], int] = lambda x: x & SDL_AUDIO_MASK_SIGNED
+SDL_AUDIO_ISSIGNED: abc.Callable[[SDL_AudioFormat], int] = lambda x: x.value & SDL_AUDIO_MASK_SIGNED
 SDL_AUDIO_ISINT: abc.Callable[[SDL_AudioFormat], bool] = lambda x: not SDL_AUDIO_ISFLOAT(x)
 SDL_AUDIO_ISUNSIGNED: abc.Callable[[SDL_AudioFormat], bool] = lambda x: not SDL_AUDIO_ISSIGNED(x)
 

sdl3/SDL_hidapi.py

@@ -10,8 +10,6 @@ class SDL_hid_device(ctypes.c_void_p):
 SDL_HID_API_BUS_UNKNOWN, SDL_HID_API_BUS_USB, SDL_HID_API_BUS_BLUETOOTH, \
     SDL_HID_API_BUS_I2C, SDL_HID_API_BUS_SPI = range(5)
 
-SDL_hid_device_info: typing.TypeAlias = SDL_TYPE["SDL_hid_device_info", ctypes.c_void_p]
-
 class SDL_hid_device_info(ctypes.Structure):
     _fields_ = [
         ("path", ctypes.c_char_p),
@@ -28,7 +26,7 @@ class SDL_hid_device_info(ctypes.Structure):
         ("interface_subclass", ctypes.c_int),
         ("interface_protocol", ctypes.c_int),
         ("bus_type", SDL_hid_bus_type),
-        ("next", SDL_POINTER[SDL_hid_device_info])
+        ("next", SDL_POINTER[ctypes.c_void_p])
     ]
 
 SDL_hid_init: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_hid_init", ctypes.c_int, [], SDL_BINARY]

sdl3/SDL_pixels.py

@@ -31,21 +31,22 @@
 SDL_PACKEDLAYOUT_NONE, SDL_PACKEDLAYOUT_332, SDL_PACKEDLAYOUT_4444, SDL_PACKEDLAYOUT_1555, SDL_PACKEDLAYOUT_5551, SDL_PACKEDLAYOUT_565, \
     SDL_PACKEDLAYOUT_8888, SDL_PACKEDLAYOUT_2101010, SDL_PACKEDLAYOUT_1010102 = range(9)
 
+SDL_DEFINE_PIXELFOURCC: abc.Callable[[str, str, str, str], int] = SDL_FOURCC
+
 def SDL_DEFINE_PIXELFORMAT(ptype: int, order: int, layout: int, bits: int, pbytes: int) -> int:
     return (1 << 28) | (ptype << 24) | (order << 20) | (layout << 16) | (bits << 8) | (pbytes << 0)
 
-SDL_DEFINE_PIXELFOURCC: abc.Callable[[int, int, int, int], int] = SDL_FOURCC
 SDL_ISPIXELFORMAT_FOURCC: abc.Callable[..., bool] = lambda format: format and SDL_PIXELFLAG(format) != 1
 
-SDL_PIXELFLAG: abc.Callable[..., int] = lambda x: (x >> 28) & 0x0F
-SDL_PIXELTYPE: abc.Callable[..., int] = lambda x: (x >> 24) & 0x0F
-SDL_PIXELORDER: abc.Callable[..., int] = lambda x: (x >> 20) & 0x0F
-SDL_PIXELLAYOUT: abc.Callable[..., int] = lambda x: (x >> 16) & 0x0F
-SDL_BITSPERPIXEL: abc.Callable[..., int] = lambda x: (x >> 8) & 0xFF
+SDL_PIXELFLAG: abc.Callable[..., int] = lambda format: (format >> 28) & 0x0F
+SDL_PIXELTYPE: abc.Callable[..., int] = lambda format: (format >> 24) & 0x0F
+SDL_PIXELORDER: abc.Callable[..., int] = lambda format: (format >> 20) & 0x0F
+SDL_PIXELLAYOUT: abc.Callable[..., int] = lambda format: (format >> 16) & 0x0F
+SDL_BITSPERPIXEL: abc.Callable[..., int] = lambda format: 0 if SDL_ISPIXELFORMAT_FOURCC(format) else (format >> 8) & 0xFF
 
-def SDL_BYTESPERPIXEL(x: int) -> int:
-    if not SDL_ISPIXELFORMAT_FOURCC(x): return (x >> 0) & 0xFF
-    else: return 2 if x in (SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YVYU, SDL_PIXELFORMAT_P010) else 1
+def SDL_BYTESPERPIXEL(format: int) -> int:
+    if not SDL_ISPIXELFORMAT_FOURCC(format): return (format >> 0) & 0xFF
+    else: return 2 if format in [SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YVYU, SDL_PIXELFORMAT_P010] else 1
 
 def SDL_ISPIXELFORMAT_INDEXED(format: int) -> bool:
     return not SDL_ISPIXELFORMAT_FOURCC(format) and (SDL_PIXELTYPE(format) in [SDL_PIXELTYPE_INDEX1, SDL_PIXELTYPE_INDEX2, SDL_PIXELTYPE_INDEX4, SDL_PIXELTYPE_INDEX8])

sdl3/SDL_rect.py

@@ -31,24 +31,19 @@ class SDL_FRect(ctypes.Structure):
         ("h", ctypes.c_float)
     ]
 
-LP_SDL_Point: typing.TypeAlias = SDL_POINTER[SDL_Point]
-LP_SDL_FPoint: typing.TypeAlias = SDL_POINTER[SDL_FPoint]
-LP_SDL_Rect: typing.TypeAlias = SDL_POINTER[SDL_Rect]
-LP_SDL_FRect: typing.TypeAlias = SDL_POINTER[SDL_FRect]
-
-def SDL_RectToFRect(rect: LP_SDL_Rect, frect: LP_SDL_FRect) -> None:
+def SDL_RectToFRect(rect: SDL_Rect, frect: SDL_FRect) -> None:
     rect, frect = SDL_DEREFERENCE(rect), SDL_DEREFERENCE(frect)
     frect.x, frect.y, frect.w, frect.h = float(rect.x), float(rect.y), float(rect.w), float(rect.h)
 
-def SDL_PointInRect(p: LP_SDL_Point, r: LP_SDL_Rect) -> bool:
+def SDL_PointInRect(p: SDL_Point, r: SDL_Rect) -> bool:
     p, r = SDL_DEREFERENCE(p), SDL_DEREFERENCE(r)
     return p.x >= r.x and p.x < r.x + r.w and p.y >= r.y and p.y < r.y + r.h
 
-def SDL_RectEmpty(r: LP_SDL_Rect) -> bool:
+def SDL_RectEmpty(r: SDL_Rect) -> bool:
     r = SDL_DEREFERENCE(r)
     return r.w <= 0 or r.h <= 0
 
-def SDL_RectEquals(a: LP_SDL_Rect, b: LP_SDL_Rect) -> bool:
+def SDL_RectEquals(a: SDL_Rect, b: SDL_Rect) -> bool:
     a, b = SDL_DEREFERENCE(a), SDL_DEREFERENCE(b)
     return a.x == b.x and a.y == b.y and a.w == b.w and a.h == b.h
 
@@ -58,20 +53,19 @@ def SDL_RectEquals(a: LP_SDL_Rect, b: LP_SDL_Rect) -> bool:
 SDL_GetRectEnclosingPoints: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_GetRectEnclosingPoints", ctypes.c_bool, [SDL_POINTER[SDL_Point], ctypes.c_int, SDL_POINTER[SDL_Rect], SDL_POINTER[SDL_Rect]], SDL_BINARY]
 SDL_GetRectAndLineIntersection: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_GetRectAndLineIntersection", ctypes.c_bool, [SDL_POINTER[SDL_Rect], SDL_POINTER[ctypes.c_int], SDL_POINTER[ctypes.c_int], SDL_POINTER[ctypes.c_int], SDL_POINTER[ctypes.c_int]], SDL_BINARY]
 
-def SDL_PointInRectFloat(p: LP_SDL_FPoint, r: LP_SDL_FRect) -> bool:
+def SDL_PointInRectFloat(p: SDL_FPoint, r: SDL_FRect) -> bool:
     p, r = SDL_DEREFERENCE(p), SDL_DEREFERENCE(r)
     return p.x >= r.x and p.x < r.x + r.w and p.y >= r.y and p.y < r.y + r.h
 
-def SDL_RectEmptyFloat(r: LP_SDL_FRect) -> bool:
+def SDL_RectEmptyFloat(r: SDL_FRect) -> bool:
     r = SDL_DEREFERENCE(r)
     return r.w <= 0 or r.h <= 0
 
-def SDL_RectsEqualEpsilon(a: LP_SDL_FRect, b: LP_SDL_FRect, epsilon: float) -> bool:
+def SDL_RectsEqualEpsilon(a: SDL_FRect, b: SDL_FRect, epsilon: float) -> bool:
     a, b = SDL_DEREFERENCE(a), SDL_DEREFERENCE(b)
     return abs(a.x - b.x) < epsilon and abs(a.y - b.y) < epsilon and abs(a.w - b.w) < epsilon and abs(a.h - b.h) < epsilon
 
-def SDL_RectsEqualFloat(a: LP_SDL_FRect, b: LP_SDL_FRect) -> bool:
-    a, b = SDL_DEREFERENCE(a), SDL_DEREFERENCE(b)
+def SDL_RectsEqualFloat(a: SDL_FRect, b: SDL_FRect) -> bool:
     return SDL_RectsEqualEpsilon(a, b, SDL_FLT_EPSILON)
 
 SDL_HasRectIntersectionFloat: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_HasRectIntersectionFloat", ctypes.c_bool, [SDL_POINTER[SDL_FRect], SDL_POINTER[SDL_FRect]], SDL_BINARY]

sdl3/SDL_stdinc.py

@@ -5,7 +5,7 @@
 SDL_arraysize: abc.Callable[[typing.Any], int] = lambda array: \
     ctypes.sizeof(array) // ctypes.sizeof(array[0])
 
-def SDL_FOURCC(a: int, b: int, c: int, d: int) -> int:
+def SDL_FOURCC(a: str, b: str, c: str, d: str) -> int:
     return (ord(a) << 0) | (ord(b) << 8) | (ord(c) << 16) | (ord(d) << 24)
 
 Sint8: typing.TypeAlias = SDL_TYPE["Sint8", ctypes.c_int8]
@@ -122,7 +122,7 @@ class SDL_Environment(ctypes.c_void_p):
 SDL_memset4: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_memset4", ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_uint32, ctypes.c_size_t], SDL_BINARY]
 
 SDL_zero: abc.Callable[[ctypes.c_void_p], ctypes.c_void_p] = lambda x: SDL_memset(ctypes.byref(x), 0, ctypes.sizeof(x))
-SDL_zerop: abc.Callable[[ctypes.c_void_p], ctypes.c_void_p] = lambda x: SDL_memset(x, 0, ctypes.sizeof(x.contents))
+SDL_zerop: abc.Callable[[ctypes.c_void_p], ctypes.c_void_p] = lambda x: SDL_memset(x, 0, ctypes.sizeof(SDL_DEREFERENCE(x)))
 SDL_zeroa: abc.Callable[[ctypes.c_void_p], ctypes.c_void_p] = lambda x: SDL_memset(x, 0, ctypes.sizeof(x))
 
 SDL_memcmp: abc.Callable[..., typing.Any] = SDL_FUNC["SDL_memcmp", ctypes.c_int, [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t], SDL_BINARY]

sdl3/__init__.py

@@ -223,12 +223,9 @@ def SDL_CHECK_BINARY_NAME(name: str) -> bool:
                     if (name.split(".")[0] if "." in name else name).endswith(_name):
                         binaryMap[module] = ctypes.CDLL(os.path.abspath(path))
 
-BaseType = typing.TypeVar("BaseType")
-TargetType = typing.TypeVar("TargetType")
-
-def SDL_ARRAY(*args: BaseType, **kwargs: TargetType) -> tuple[ctypes.Array[BaseType | TargetType], int]:
+def SDL_ARRAY(*values, type: typing.Any | None = None) -> tuple[typing.Any, int]:
     """Create a ctypes array from the given arguments."""
-    return ((kwargs.get("type", None) or args[0].__class__) * len(args))(*args), len(args)
+    return ((type or values[0].__class__) * len(values))(*values), len(values)
 
 def SDL_DEREFERENCE(value: typing.Any) -> typing.Any:
     """Dereference a ctypes pointer or object."""
@@ -270,7 +267,7 @@ def __class_getitem__(cls, key: tuple[str, type, list[type], str]) -> typing.Any
             assert isinstance(key[0], str), "Expected a string as the first argument."
             assert isinstance(key[1], type) or key[1] is None, "Expected a type as the second argument."
             assert isinstance(key[2], list), "Expected a list as the third argument."
-            assert ... not in key[2] or key[2].count(...) == 1, "Expected at most 1 '...' in the argument list."
+            assert ... not in key[2] or key[2].count(...) == 1, "Expected at most 1 '...' in the argument list." # type: ignore
             assert ... not in key[2] or key[2][-1] == ..., "Expected '...' at the end of the argument list."
             assert isinstance(key[3], str), "Expected a string as the fourth argument."
             assert key[3] in SDL_MODULES, "Unknown binary."
@@ -358,16 +355,16 @@ def __class_getitem__(cls, key: tuple[str, type, list[type]]) -> type:
             assert isinstance(key[1], type) or key[1] is None, "Expected a type as the second argument."
             assert isinstance(key[2], list), "Expected a list as the third argument."
 
-        _, ctypes._c_functype_cache = ctypes._c_functype_cache, {}
+        _, ctypes._c_functype_cache = ctypes._c_functype_cache, {} # type: ignore
         value = ctypes.CFUNCTYPE(key[1], *key[2])
-        value.__name__, ctypes._c_functype_cache = key[0], _
+        value.__name__, ctypes._c_functype_cache = key[0], _ # type: ignore
         return value
 
 SDL_ENUM: typing.TypeAlias = SDL_TYPE["SDL_ENUM", ctypes.c_int]
 SDL_VA_LIST: typing.TypeAlias = SDL_TYPE["SDL_VA_LIST", ctypes.c_char_p]
 
 def SDL_PARSE_ARGUMENTS(argc: ctypes.c_int, argv: SDL_POINTER[ctypes.c_char_p]) -> list[str]:
-    return [argv[i].decode("utf-8") for i in range(argc)]
+    return [argv[i].decode("utf-8") for i in range(argc.value)] # type: ignore
 
 def SDL_PROCESS_DESCRIPTION(description: str, url: str | None = None, rst: bool = False) -> str:
     """Process HTML description."""
@@ -410,7 +407,7 @@ async def SDL_GET_LATEST_RELEASES() -> dict[str, str]:
     await session.close()
     return releases
 
-async def SDL_GET_FUNC_DESCRIPTIONS(funcs: list[tuple[str, str]], rst: bool = False) -> tuple[list[str], list[list[str]]]:
+async def SDL_GET_FUNC_DESCRIPTIONS(funcs: list[tuple[str, str]], rst: bool = False) -> tuple[list[str], list[list[str]], list[str]]:
     """Get descriptions, arguments and return types of SDL3 functions from the official SDL3 wiki."""
     session, tasks = aiohttp.ClientSession(), []
 
@@ -458,7 +455,7 @@ async def SDL_GET_FUNC_DESCRIPTIONS(funcs: list[tuple[str, str]], rst: bool = Fa
     await session.close()
     return descriptions, arguments, returns
 
-async def SDL_GET_STRUCT_DESCRIPTIONS(structs: list[tuple[str, str]], rst: bool = False) -> tuple[list[str], list[list[str]]]:
+async def SDL_GET_STRUCT_DESCRIPTIONS(structs: list[tuple[str, str]], rst: bool = False) -> tuple[list[str], list[dict[str, typing.Any]]]:
     """Get descriptions and members of SDL3 structures from the official SDL3 wiki."""
     session, tasks = aiohttp.ClientSession(), []
 
@@ -518,7 +515,7 @@ async def SDL_GET_STRUCT_DESCRIPTIONS(structs: list[tuple[str, str]], rst: bool
     await session.close()
     return descriptions, members
 
-def SDL_GET_MODULE_BY_NAME(name: str) -> str:
+def SDL_GET_MODULE_BY_NAME(name: str) -> str | None:
     """Get the module of an SDL3 function/structure by its name."""
 
     for prefix, module in sorted({"SDL": "SDL3", "IMG": "SDL3_image", "Mix": "SDL3_mixer", "TTF": "SDL3_ttf", "RTF": "SDL3_rtf", "NET": "SDL3_net", "SDL_ShaderCross": "SDL3_shadercross"}.items(), key = lambda x: -len(x[0])):
@@ -565,11 +562,13 @@ def SDL_GENERATE_DOCS(modules: list[str] = SDL_MODULES, raw: types.ModuleType |
             if (_ := __module__.functions[module][func]).__name__ == "__inner__": _ = _.func
             _.__doc__ = (descriptions[__index := __index + 1], arguments[__index], returns[__index])
 
+    structs = False
     result = "" if rst else "\"\"\"\n# This file is auto-generated, do not modify it.\n__meta__ = "
     if not rst: result += f"{{\"target\": \"v{__version__}\", \"system\": \"{SDL_SYSTEM}\"}}\n\"\"\"\n\n"
-    result += f"from {'sdl3' if rst else ''}.SDL import * # type: ignore\n\n"
-    result += f"from {'sdl3' if rst else ''}. import {'' if rst else 'raw, '}ctypes, typing, {'SDL_POINTER' if rst else ''}"
-    result += "\n" if rst else f"\\\n{' ' * 4}SDL_POINTER, SDL_CLONE_METACLASS as SDL_CloneMeta\n\n"
+    result += f"from {'sdl3' if rst else ''}.SDL import * # type: ignore\n"
+    result += f"from {'sdl3' if rst else '.'} import {'' if rst else 'raw, '}SDL_POINTER"
+    result += "\n\n" if rst or not structs else f", \\\n{' ' * 4}SDL_CLONE_METACLASS as SDL_CloneMeta\n\n"
+    result += "import ctypes, typing\n\n"
     types, definitions = set(), ""
 
     def SDL_GET_FULL_NAME(type: type | None) -> str:
@@ -578,9 +577,9 @@ def SDL_GET_FULL_NAME(type: type | None) -> str:
         if type.__name__.startswith("c_"): return f"ctypes.{type.__name__}"
         else: return type.__name__
 
-    if not rst and raw is not None:
-        structs = [(SDL_GET_MODULE_BY_NAME(name), name) for name in dir(raw) if hasattr(getattr(raw, name), "_fields_") \
-            and not name.startswith("_") and "_" in name and name not in ["SDL_GamepadBinding", "SDL_TLSID"]]
+    if not rst and raw is not None and structs:
+        structs = [(module, name) for name in dir(raw) if hasattr(getattr(raw, name), "_fields_") and not name.startswith("_") \
+            and "_" in name and name not in ["SDL_GamepadBinding", "SDL_TLSID"] and (module := SDL_GET_MODULE_BY_NAME(name))]
 
         for (module, name), description, members in zip(structs, *asyncio.run(SDL_GET_STRUCT_DESCRIPTIONS(structs))):
             if not description or not members:
@@ -748,7 +747,8 @@ def SDL_TRY_WRITE_DOCS() -> bool | None:
     else:
         try:
             if not (__frozen__ or __release__):
-                if os.path.exists(__doc_file__): os.remove(__doc_file__)
+                if os.path.exists(__doc_file__):
+                    os.remove(__doc_file__)
 
         except PermissionError as exc:
             SDL_LOGGER.Log(SDL_LOGGER.Error, f"Failed to remove docs: {exc}.")