more typing fixes

Author: Cleptomania

arcade/application.py

@@ -230,12 +230,13 @@ def __init__(
                     alpha_size=8,
                 )
         try:
+            # This type ignore is here because somehow Pyright thinks this is an Emscripten window
             super().__init__(
                 width=width,
                 height=height,
                 caption=title,
                 resizable=resizable,
-                config=config,  # type: ignore Pylance seems to think this is an EmscriptenWindow at this point?
+                config=config,  # type: ignore
                 vsync=vsync,
                 visible=visible,
                 style=style,
@@ -356,8 +357,10 @@ def current_view(self) -> View | None:
         """
         return self._current_view
 
+    # TODO: This is overriding the ctx function from Pyglet's BaseWindow which returns the
+    # SurfaceContext class from pyglet. We should probably rename this.
     @property
-    def ctx(self) -> ArcadeContext:
+    def ctx(self) -> ArcadeContext:  # type: ignore
         """
         The OpenGL context for this window.
 

arcade/context.py

@@ -16,9 +16,11 @@
 from arcade.camera import Projector
 from arcade.camera.default import DefaultProjector
 from arcade.gl import BufferDescription, Context
+from arcade.gl.buffer import Buffer
 from arcade.gl.compute_shader import ComputeShader
 from arcade.gl.framebuffer import Framebuffer
 from arcade.gl.program import Program
+from arcade.gl.query import Query
 from arcade.gl.texture import Texture2D
 from arcade.gl.vertex_array import Geometry
 from arcade.texture_atlas import DefaultTextureAtlas, TextureAtlasBase
@@ -55,7 +57,9 @@ def __init__(
         gl_api: str = "gl",
     ) -> None:
         # Set up a default orthogonal projection for sprites and shapes
-        self._window_block = window._matrices.ubo
+        # Mypy can't figure out the dynamic creation of the matrices in Pyglet
+        # They are created based on the active backend.
+        self._window_block = window._matrices.ubo  # type: ignore
         self.bind_window_block()
 
         self.blend_func = self.BLEND_DEFAULT
@@ -191,23 +195,26 @@ def __init__(
         if gl_api != "webgl":
             # SpriteList collision resources
             # Buffer version of the collision detection program.
-            self.collision_detection_program = self.load_program(
+            self.collision_detection_program: Program | None = self.load_program(
                 vertex_shader=":system:shaders/collision/col_trans_vs.glsl",
                 geometry_shader=":system:shaders/collision/col_trans_gs.glsl",
             )
             # Texture version of the collision detection program.
-            self.collision_detection_program_simple = self.load_program(
+            self.collision_detection_program_simple: Program | None = self.load_program(
                 vertex_shader=":system:shaders/collision/col_tex_trans_vs.glsl",
                 geometry_shader=":system:shaders/collision/col_tex_trans_gs.glsl",
             )
             self.collision_detection_program_simple["pos_angle_data"] = 0
             self.collision_detection_program_simple["size_data"] = 1
             self.collision_detection_program_simple["index_data"] = 2
 
-            self.collision_buffer = self.buffer(reserve=1024 * 4)
-            self.collision_query = self.query(samples=False, time=False, primitives=True)
+            self.collision_buffer: Buffer | None = self.buffer(reserve=1024 * 4)
+            self.collision_query: Query | None = self.query(
+                samples=False, time=False, primitives=True
+            )
         else:
             self.collision_detection_program = None
+            self.collision_detection_program_simple = None
             self.collision_buffer = None
             self.collision_query = None
 

arcade/sprite_list/sprite_list.py

@@ -1685,25 +1685,30 @@ def get_nearby_sprite_indices(self, pos: Point, size: Point, length: int) -> lis
             A list of indices of nearby sprites.
         """
         ctx = self.ctx
+        if ctx._gl_api == "webgl":
+            raise RuntimeError("GPU Collision is not supported on WebGL Backends")
+
+        # All of these type ignores are because of GPU collision not being supported on WebGL
+        # Unfortuantely the type checkers don't have a sane way of understanding that, and it's
+        # not worth run-time checking all of these things, because they are guaranteed based on
+        # active GL api of the context. Pyright actually does seem to be able to figure it out
+        # but mypy does not
 
-        ctx.collision_detection_program["check_pos"] = pos
-        ctx.collision_detection_program["check_size"] = size
+        ctx.collision_detection_program["check_pos"] = pos  # type: ignore
+        ctx.collision_detection_program["check_size"] = size  # type: ignore
         buffer = ctx.collision_buffer
-        with ctx.collision_query:
-            # These calls are typed as | None because of the arcade.gl backends, but at this
-            # point if we have SpriteListBufferData these are guaranteed to be on a backend
-            # where they will not be None.
+        with ctx.collision_query:  # type: ignore
             self._geometry.transform(
                 ctx.collision_detection_program,  # type: ignore
                 buffer,  # type: ignore
                 vertices=length,
             )
 
         # Store the number of sprites emitted
-        emit_count = ctx.collision_query.primitives_generated
+        emit_count = ctx.collision_query.primitives_generated  # type: ignore
         if emit_count == 0:
             return []
-        return [i for i in struct.unpack(f"{emit_count}i", buffer.read(size=emit_count * 4))]
+        return [i for i in struct.unpack(f"{emit_count}i", buffer.read(size=emit_count * 4))]  # type: ignore
 
 
 class SpriteListTextureData(SpriteListData):
@@ -1892,25 +1897,30 @@ def get_nearby_sprite_indices(self, pos: Point, size: Point, length: int) -> lis
         ctx = self.ctx
         if ctx._gl_api == "webgl":
             raise RuntimeError("GPU Collision is not supported on WebGL Backends")
+
+        # All of these type ignores are because of GPU collision not being supported on WebGL
+        # Unfortuantely the type checkers don't have a sane way of understanding that, and it's
+        # not worth run-time checking all of these things, because they are guaranteed based on
+        # active GL api of the context. Pyright actually does seem to be able to figure it out
+        # but mypy does not
+
         buffer = ctx.collision_buffer
         program = ctx.collision_detection_program_simple
-        program["check_pos"] = pos
-        program["check_size"] = size
+        program["check_pos"] = pos  # type: ignore
+        program["check_size"] = size  # type: ignore
 
         self._storage_pos_angle.use(0)
         self._storage_size.use(1)
         self._storage_index.use(2)
 
-        with ctx.collision_query:
-            # This is ignored because it is guaranteed to not be none by the above context GL api
-            # check. This is only able to be None when we are on WebGL.
+        with ctx.collision_query:  # type: ignore
             ctx.geometry_empty.transform(
-                program,
+                program,  # type: ignore
                 buffer,  # type: ignore
                 vertices=length,
             )
-        emit_count = ctx.collision_query.primitives_generated
+        emit_count = ctx.collision_query.primitives_generated  # type: ignore
         # print(f"Collision query emitted {emit_count} sprites")
         if emit_count == 0:
             return []
-        return [i for i in struct.unpack(f"{emit_count}i", buffer.read(size=emit_count * 4))]
+        return [i for i in struct.unpack(f"{emit_count}i", buffer.read(size=emit_count * 4))]  # type: ignore