pyglet 2.1.dev7__tar.gz → 2.1rc2__tar.gz

{pyglet-2.1.dev7 → pyglet-2.1rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglet
-Version: 2.1.dev7
+Version: 2.1rc2
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8

{pyglet-2.1.dev7 → pyglet-2.1rc2}/RELEASE_NOTES

@@ -1,3 +1,23 @@
+pyglet 2.0.20
+
+Changes and Improvements
+------------------------
+- media: add support for FFmpeg 7.x
+
+
+pyglet 2.0.19
+
+Changes and Improvements
+------------------------
+docs: update vertexbuffer.py module docstrings
+
+Bugfixes
+--------
+- macos: stop F5 from autocompleting (#1229)
+- input.base: Don't skip Axis Controls without names
+- window.xlib: don't send on_mouse_release events for scrolling (#1235)
+
+
 pyglet 2.0.18
 
 Changes and Improvements

{pyglet-2.1.dev7 → pyglet-2.1rc2}/doc/index.rst

@@ -50,10 +50,11 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/keyboard
    programming_guide/mouse
    programming_guide/input
-   programming_guide/shapes
    programming_guide/image
-   programming_guide/media
    programming_guide/text
+   programming_guide/media
+   programming_guide/shapes
+   programming_guide/models
    programming_guide/resources
    programming_guide/rendering
    programming_guide/events

pyglet-2.1rc2/doc/modules/models.rst

@@ -0,0 +1,6 @@
+pyglet.model
+============
+
+.. automodule:: pyglet.model
+  :members:
+  :undoc-members:

{pyglet-2.1.dev7 → pyglet-2.1rc2}/doc/programming_guide/media.rst

@@ -13,7 +13,7 @@ following are available:
 #. The built-in pyglet WAV file decoder (always available)
 #. Platform-specific APIs and libraries
 #. PyOgg
-#. :ref:`guide-supportedmedia-ffmpeg` version 4, 5, or 6
+#. :ref:`guide-supportedmedia-ffmpeg` version 4, 5, 6, or 7.
 
 Video is played into OpenGL textures, allowing real-time manipulation
 by applications. Examples include use in 3D environments or shader-based
@@ -304,7 +304,7 @@ FFmpeg
 ^^^^^^
 .. _FFmpeg's license overview: https://www.ffmpeg.org/legal.html
 
-.. note:: The most recent pyglet release can use FFmpeg 4.X, 5.X, or 6.X
+.. note:: The most recent pyglet release can use FFmpeg versions 4.X, 5.X, 6.X, and 7.X
 
           See :ref:`guide-media-ffmpeginstall` to learn more.
 
@@ -389,6 +389,7 @@ See the following to learn more:
   * `The FFmpeg 4.4 license breakdown <https://ffmpeg.org/doxygen/4.4/md_LICENSE.html>`_
   * `The FFmpeg 5.1 license breakdown <https://ffmpeg.org/doxygen/5.1/md_LICENSE.html>`_
   * `The FFmpeg 6.0 license breakdown <https://ffmpeg.org/doxygen/6.0/md_LICENSE.html>`_
+  * `The FFmpeg 7.0 license breakdown <https://ffmpeg.org/doxygen/7.0/md_LICENSE.html>`_
 
 .. _guide-media-ffmpeginstall:
 
@@ -400,8 +401,11 @@ in the `FFmpeg download <https://www.ffmpeg.org/download.html>`_ page. You must
 choose the shared build for the targeted OS with the architecture similar to
 the Python interpreter.
 
-All recent pyglet versions support FFmpeg 4.x and 5.x. To use FFmpeg 6.X,
-you must use pyglet 2.0.8 or later.
+All recent pyglet versions support FFmpeg 4.x.
+
+* Support for version 5.X requires at least: 1.5.28.
+* Support for version 6.X requires at least: 2.0.8.
+* Support for version 7.X requires at least: 2.0.20.
 
 Choose the correct architecture depending on the targeted
 **Python interpreter**. If you're shipping your project with a 32 bits
@@ -450,6 +454,8 @@ For Linux and Mac OS::
          * Exiting gracefully after the the user clicks OK on a dialog
          * Limiting the formats your project will attempt to load
 
+If you still have issues with the FFmpeg not being recognized, try enabling the debug flags to see if any relevant
+information is output: ``pyglet.options.debug_lib`` and/or ``pyglet.options.debug_media``.
 
 .. _guide-media-loading:
 

{pyglet-2.1.dev7 → pyglet-2.1rc2}/doc/programming_guide/migration.rst

@@ -12,7 +12,10 @@ are having an issue that is not covered here, please open up an issue ticket on
 
 Window "HiDPI" support
 ----------------------
-TBD
+The v2.1 release now provides a lot more control over how modern 'HiDPI' displays
+are treated. This includes "retina" displays, or any display that has a non-0% zoom
+or scale (such as 4K displays). This is exposed as new pyglet options. See
+``pyglet.options.dpi_scaling`` for more information.
 
 Labels & Text Layouts
 ---------------------
@@ -84,7 +87,7 @@ as booleans for a quick workaround when migrating, you can do something like thi
 
 
 Vectors can also be useful for analog sticks, because it gives an easy way to
-calculate dead-zones using `.length()`. For example::
+calculate dead-zones using ``.length()``. For example::
 
     @controller.event
     def on_stick_motion(controller, name, vector):
@@ -102,8 +105,8 @@ that the maximum value stays within range. For example::
 
             vector = min(vector, vector.normalize())
 
-You can also of course directly access the individual `Vec2.x` & `Vec2.y`
-attributes. See :py:class:`~pyglet.math.Vec2` for more details on vector types.
+You can also of course directly access the individual ``Vec2.x`` & ``Vec2.y`` attributes,
+if you want to . See :py:class:`~pyglet.math.Vec2` for more details on vector types.
 
 Gui
 ---
@@ -116,8 +119,8 @@ The :py:class:`~pyglet.gui.widget.ToggleButton` and :py:class:`~pyglet.gui.widge
 widgets have a small change. Instead of the image arguments being named "pressed"
 and "depressed", they has been renamed to the correct "pressed" and "unpressed".
 
-Math module
------------
+Math
+----
 In the :py:mod:`~pyglet.math` module, vector types (:py:class:`~pyglet.math.Vec2`,
 :py:class:`~pyglet.math.Vec3`, :py:class:`~pyglet.math.Vec4`) are now
 immutable; all operations will return a new object. In addition, all vector objects
@@ -139,12 +142,23 @@ way as vectors). For example:
 Matrix objects are generally created via their helper methods, so this change should
 hopefully not require any code updates for most users.
 
+Models
+------
+The :py:mod:`~pyglet.model` module has seen some changes. This is an undocumented
+WIP module for pyglet 2.0, and it remains so pyglet 2.1. That said, it's in a more
+usable state now. The first change is that :py:meth:`~pyglet.model.load` now returns
+a ``Scene`` object instead of a ``Model`` object. The Scene is a new, "pure data"
+intermediate representation of a 3D scene, that closely mimics the layout of the glTF
+format. The :py:meth:`~pyglet.model.Scene.create_models` method can be used to create
+``Model`` instances from the Scene, but the Scene data can also be manually iterated
+over for more advanced use cases.
+
 Canvas module
 -------------
-The `pyglet.canvas` module has been renamed to `pyglet.display`. The "canvas"
+The ``pyglet.canvas`` module has been renamed to ``pyglet.display``. The "canvas"
 concept was a work-in-progress in legacy pyglet, and was never fully fleshed out.
 It appears to have been meant to allow arbitrary renderable areas, but this type
-of functionality can now be easily accomplished with Framebuffers. The name `display`
+of functionality can now be easily accomplished with Framebuffers. The name ``display``
 is a more accurate representation of what the code in the module actually relates to.
 The usage is the same, with just the name change::
 

pyglet-2.1rc2/doc/programming_guide/models.rst

@@ -0,0 +1,10 @@
+.. _guide_models:
+
+3D Models and Scenes
+====================
+
+The :py:mod:`~pyglet.model` module is still a work in progress, and is
+not yet documented.
+
+TBD
+---

{pyglet-2.1.dev7 → pyglet-2.1rc2}/examples/dpi_scaled_window.py

@@ -71,10 +71,25 @@ def on_resize(width, height):
     hello_label.position = (window.width // 2, window.height // 2, 0)
 
 
+screens = pyglet.display.get_display().get_screens()
+selected_screen = screens[0]
+
 @window.event
 def on_key_press(symbol, modifiers):
+    global selected_screen
+    if len(screens) > 1:
+        if symbol == pyglet.window.key._1:
+            selected_screen = screens[1]
+        elif symbol == pyglet.window.key._0:
+            selected_screen = screens[0]
+    
     if symbol == pyglet.window.key.SPACE:
         window.set_size(500, 300)
+    elif symbol == pyglet.window.key.F:
+        window.set_fullscreen(False, screen=selected_screen)
+    elif symbol == pyglet.window.key.G:
+        window.set_fullscreen(True, screen=selected_screen)
+        
 
 
 @window.event

{pyglet-2.1.dev7 → pyglet-2.1rc2}/examples/model/fpscamera.py

@@ -10,17 +10,16 @@ to your needs for first person games.
 """
 
 from __future__ import annotations
+
 import weakref
-from pathlib import Path
+
 from math import radians, degrees
 
 import pyglet
-from pyglet.window import key as _key
 
 from pyglet.gl import glEnable, GL_DEPTH_TEST, GL_CULL_FACE
 from pyglet.math import Vec2, Vec3, Mat4, clamp
-
-MODULE_PATH = Path(__file__).parent
+from pyglet.window import key as _key
 
 
 class FPSCamera:
@@ -346,8 +345,8 @@ if __name__ == "__main__":
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_CULL_FACE)
 
-    model_logo = pyglet.model.load(MODULE_PATH / "logo3d.obj", batch=batch)
-    model_box = pyglet.model.load(MODULE_PATH / "box.obj", batch=batch)
+    model_logo = pyglet.resource.model("logo3d.obj", batch=batch)
+    model_box = pyglet.resource.model("box.obj", batch=batch)
 
     # Camera controls the global projection & view matrixes:
     camera = FPSCamera(window, position=Vec3(0.0, 0.0, 5.0))

{pyglet-2.1.dev7 → pyglet-2.1rc2}/examples/model/model.py

@@ -44,8 +44,10 @@ if __name__ == "__main__":
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_CULL_FACE)
 
-    model_logo = pyglet.resource.model("logo3d.obj", batch=batch)
-    model_box = pyglet.resource.model("box.obj", batch=batch)
+    logo_scene = pyglet.resource.scene('logo3d.obj')
+    box_scene = pyglet.resource.scene('box.obj')
+    model_logo = logo_scene.create_models(batch=batch)[0]   # only one model in this scene
+    model_box = box_scene.create_models(batch=batch)[0]     # only one model in this scene
 
     # Set the application wide view matrix (camera):
     window.view = Mat4.look_at(position=Vec3(0, 0, 5), target=Vec3(0, 0, 0), up=Vec3(0, 1, 0))

{pyglet-2.1.dev7 → pyglet-2.1rc2}/pyglet/__init__.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.dev7'
+version = '2.1.rc2'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -247,7 +247,7 @@ class Options:
 
     .. versionadded:: 2.0.5"""
 
-    dpi_scaling: Literal["real", "scaled", "stretch"] = "real"
+    dpi_scaling: Literal["real", "scaled", "stretch", "platform"] = "real"
     """For 'HiDPI' displays, Window behavior can differ between operating systems. Defaults to `'real'`.
 
     The current options are an attempt to create consistent behavior across all of the operating systems.
@@ -270,6 +270,13 @@ class Options:
     rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the extent
     of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
     `window.get_framebuffer_size()`.
+    
+    `'platform'`: A DPI aware window is created, however window sizing and framebuffer sizing is not interfered with
+    by Pyglet. Final sizes are dictated by the platform the window was created on. It is up to the user to make any
+    platform adjustments themselves such as sizing on a platform, mouse coordinate adjustments, or framebuffer size
+    handling. On Windows and X11, the framebuffer and the requested window size will always match in pixels 1:1. On
+    MacOS, depending on a Hi-DPI display, you may get a different sized framebuffer than the window size. This option
+    does allow `window.dpi` and `window.scale` to return their respective values.
     """
 
     shader_bind_management: bool = True

{pyglet-2.1.dev7 → pyglet-2.1rc2}/pyglet/__init__.pyi

@@ -63,7 +63,6 @@ class Options:
     com_mta: bool
     osx_alt_loop: bool
     dpi_scaling: Literal["real", "scaled", "stretch"]
-    scale_with_dpi: bool
     shader_bind_management: bool
 
     def get(self, item: str, default: Any = None) -> Any:

{pyglet-2.1.dev7 → pyglet-2.1rc2}/pyglet/experimental/jobs.py

@@ -25,16 +25,17 @@ if TYPE_CHECKING:
 
 class _Worker(Thread):
     """A worker thread to pop and run jobs."""
-    def __init__(self, workqueue: Queue, exitevent: Event, name: str) -> None:
-        super().__init__(name=name, daemon=True)
-        self.queue = workqueue
-        self.exit = exitevent
+    def __init__(self, workqueue: Queue, exitevent: Event, index: int) -> None:
+        super().__init__(daemon=True)
+        self._queue = workqueue
+        self._exit = exitevent
+        self._index = index
         self.start()
 
     def run(self) -> None:
         """Parallel thread of execution."""
-        _exit = self.exit
-        _queue = self.queue
+        _exit = self._exit
+        _queue = self._queue
         while not _exit.is_set():
             func, args = _queue.get()
             func(*args)
@@ -51,8 +52,9 @@ class JobExecutor:
     `concurrent.futures` module, but does not share any code with those classes.
     Instead, it is a more light-weight implementation intended for execution of
     highly parallizable functions (jobs). A key difference is that JobExecutor
-    does not return `Futures`, and instead depends on the submitted jobs to
-    self-contained.
+    does not return `Futures`. Submitted jobs must be self-contained, or handle
+    returning values by other mechanisms. The :py:meth:`~sync` method can be
+    used to wait for all currently submitted jobs to complete.
     """
 
     def __init__(self, max_workers: int | None = None) -> None:
@@ -65,7 +67,7 @@ class JobExecutor:
         self._max_workers = max_workers or os.cpu_count() // 2
         self._exitevent = Event()
         self._queue = Queue()
-        self._threads = [_Worker(self._queue, self._exitevent, f"Thread{i+1}") for i in range(self._max_workers)]
+        self._threads = [_Worker(self._queue, self._exitevent, i) for i in range(self._max_workers)]
 
     def submit(self, func: Callable, *args: Any) -> None:
         """Submit a job to be executed on .

{pyglet-2.1.dev7 → pyglet-2.1rc2}/pyglet/font/__init__.py

@@ -82,7 +82,7 @@ def add_user_font(font: UserDefinedFontBase) -> None:
     font_hold = shared_object_space.pyglet_font_font_hold
 
     # Look for font name in font cache
-    descriptor = (font.name, font.size, font.bold, font.italic, font.stretch, font.dpi)
+    descriptor = (font.name, font.size, font.weight, font.italic, font.stretch, font.dpi)
     if descriptor in font_cache:
         msg = f"A font with parameters {descriptor} has already been created."
         raise Exception(msg)
@@ -105,7 +105,7 @@ def have_font(name: str) -> bool:
     return name in _user_fonts or _system_font_class.have_font(name)
 
 
-def load(name: str | Iterable[str] | None = None, size: float | None = None, bold: bool | str = False,
+def load(name: str | Iterable[str] | None = None, size: float | None = None, weight: str = "normal",
          italic: bool | str = False, stretch: bool | str = False, dpi: int | None = None) -> Font:
     """Load a font for rendering.
 
@@ -118,10 +118,9 @@ def load(name: str | Iterable[str] | None = None, size: float | None = None, bol
         size:
             Size of the font, in points.  The returned font may be an exact
             match or the closest available.
-        bold:
-            If True, a bold variant is returned, if one exists for the given
-            family and size. For some Font renderers, bold is the weight of the font, and a string
-            can be provided specifying the weight. For example, "semibold" or "light".
+        weight:
+            If set, a specific weight variant is returned if one exists for the given font
+            family and size. The weight is provided as a string. For example: "bold" or "light".
         italic:
             If True, an italic variant is returned, if one exists for the given family and size. For some Font
             renderers, italics may have an "oblique" variation which can be specified as a string.
@@ -166,16 +165,17 @@ def load(name: str | Iterable[str] | None = None, size: float | None = None, bol
             name = found_name
 
     # Look for font name in font cache
-    descriptor = (name, size, bold, italic, stretch, dpi)
+    descriptor = (name, size, weight, italic, stretch, dpi)
     if descriptor in font_cache:
         return font_cache[descriptor]
 
     # Not in cache, create from scratch
-    font = _system_font_class(name, size, bold=bold, italic=italic, stretch=stretch, dpi=dpi)
+    font = _system_font_class(name, size, weight=weight, italic=italic, stretch=stretch, dpi=dpi)
+
     # Save parameters for new-style layout classes to recover
     # TODO: add properties to the base Font so completion is proper:
     font.size = size
-    font.bold = bold
+    font.weight = weight
     font.italic = italic
     font.stretch = stretch
     font.dpi = dpi

{pyglet-2.1.dev7 → pyglet-2.1rc2}/pyglet/font/directwrite.py

@@ -95,6 +95,9 @@ DWRITE_FONT_WEIGHT_HEAVY = 900
 DWRITE_FONT_WEIGHT_EXTRA_BLACK = 950
 
 name_to_weight = {
+    True: DWRITE_FONT_WEIGHT_BOLD,      # Temporary alias for attributed text
+    False: DWRITE_FONT_WEIGHT_NORMAL,   # Temporary alias for attributed text
+    None: DWRITE_FONT_WEIGHT_NORMAL,    # Temporary alias for attributed text
     "thin": DWRITE_FONT_WEIGHT_THIN,
     "extralight": DWRITE_FONT_WEIGHT_EXTRA_LIGHT,
     "ultralight": DWRITE_FONT_WEIGHT_ULTRA_LIGHT,
@@ -1944,7 +1947,7 @@ class DirectWriteGlyphRenderer(base.GlyphRenderer):
         return glyph
 
     def render_using_layout(self, text: str) -> Glyph | None:
-        """This will render text given the built in DirectWrite layout.
+        """This will render text given the built-in DirectWrite layout.
 
         This process allows us to take advantage of color glyphs and fallback handling that is built into DirectWrite.
         This can also handle shaping and many other features if you want to render directly to a texture.
@@ -2045,7 +2048,7 @@ class Win32DirectWriteFont(base.Font):
     glyph_renderer_class = DirectWriteGlyphRenderer
     texture_internalformat = pyglet.gl.GL_RGBA
 
-    def __init__(self, name: str, size: float, bold: bool | str = False, italic: bool | str = False,
+    def __init__(self, name: str, size: float, weight: str = "normal", italic: bool | str = False,
                  stretch: bool | str = False, dpi: int | None = None, locale: str | None = None) -> None:
         self._filename: str | None = None
         self._advance_cache = {}  # Stores glyph's by the indice and advance.
@@ -2056,7 +2059,7 @@ class Win32DirectWriteFont(base.Font):
             name = self._default_name
 
         self._name = name
-        self.bold = bold
+        self.weight = weight
         self.size = size
         self.italic = italic
         self.stretch = stretch
@@ -2074,13 +2077,7 @@ class Win32DirectWriteFont(base.Font):
         # From DPI to DIP (Device Independent Pixels) which is what the fonts rely on.
         self._real_size = (self.size * self.dpi) // 72
 
-        if self.bold:
-            if isinstance(self.bold, str):
-                self._weight = name_to_weight[self.bold]
-            else:
-                self._weight = DWRITE_FONT_WEIGHT_BOLD
-        else:
-            self._weight = DWRITE_FONT_WEIGHT_NORMAL
+        self._weight = name_to_weight[self.weight]
 
         if self.italic:
             if isinstance(self.italic, str):
@@ -2549,26 +2546,26 @@ class Win32DirectWriteFont(base.Font):
         return None, None
 
     @classmethod
-    def find_font_face(cls, font_name: str, bold: bool | str, italic: bool | str, stretch: bool | str) -> tuple[
+    def find_font_face(cls, font_name: str, weight: str, italic: bool | str, stretch: bool | str) -> tuple[
         IDWriteFont | None, IDWriteFontCollection | None]:
-        """This will search font collections for legacy RBIZ names. However, matching to bold, italic, stretch is
+        """This will search font collections for legacy RBIZ names. However, matching to weight, italic, stretch is
         problematic in that there are many values. We parse the font name looking for matches to the name database,
         and attempt to pick the closest match.
         This will search all fonts on the system and custom loaded, and all of their font faces. Returns a collection
         and IDWriteFont if successful.
         """
-        p_bold, p_italic, p_stretch = cls.parse_name(font_name, bold, italic, stretch)
+        p_weight, p_italic, p_stretch = cls.parse_name(font_name, weight, italic, stretch)
 
         _debug_print(f"directwrite: '{font_name}' not found. Attempting legacy name lookup in all collections.")
         if cls._custom_collection:
-            collection_idx = cls.find_legacy_font(cls._custom_collection, font_name, p_bold, p_italic, p_stretch)
+            collection_idx = cls.find_legacy_font(cls._custom_collection, font_name, p_weight, p_italic, p_stretch)
             if collection_idx is not None:
                 return collection_idx, cls._custom_collection
 
         sys_collection = IDWriteFontCollection()
         cls._write_factory.GetSystemFontCollection(byref(sys_collection), 1)
 
-        collection_idx = cls.find_legacy_font(sys_collection, font_name, p_bold, p_italic, p_stretch)
+        collection_idx = cls.find_legacy_font(sys_collection, font_name, p_weight, p_italic, p_stretch)
         if collection_idx is not None:
             return collection_idx, sys_collection
 
@@ -2582,7 +2579,7 @@ class Win32DirectWriteFont(base.Font):
         return False
 
     @staticmethod
-    def parse_name(font_name: str, weight: int, style: int, stretch: int) -> tuple[int, int, int]:
+    def parse_name(font_name: str, weight: str, style: int, stretch: int) -> tuple[str, int, int]:
         """Attempt at parsing any special names in a font for legacy checks. Takes the first found."""
         font_name = font_name.lower()
         split_name = font_name.split(" ")
@@ -2611,7 +2608,7 @@ class Win32DirectWriteFont(base.Font):
         return found_weight, found_style, found_stretch
 
     @staticmethod
-    def find_legacy_font(collection: IDWriteFontCollection, font_name: str, bold: bool | str, italic: bool | str, stretch: bool | str, full_debug: bool=False) -> IDWriteFont | None:
+    def find_legacy_font(collection: IDWriteFontCollection, font_name: str, weight: str, italic: bool | str, stretch: bool | str, full_debug: bool=False) -> IDWriteFont | None:
         coll_count = collection.GetFontFamilyCount()
 
         assert _debug_print(f"directwrite: Found {coll_count} fonts in collection.")
@@ -2681,7 +2678,7 @@ class Win32DirectWriteFont(base.Font):
 
             # If we have matches, we've already parsed through the proper family. Now try to match.
             if matches:
-                write_font = Win32DirectWriteFont.match_closest_font(matches, bold, italic, stretch)
+                write_font = Win32DirectWriteFont.match_closest_font(matches, weight, italic, stretch)
 
                 # Cleanup other matches not used.
                 for match in matches:
@@ -2693,7 +2690,7 @@ class Win32DirectWriteFont(base.Font):
         return None
 
     @staticmethod
-    def match_closest_font(font_list: list[tuple[int, int, int, IDWriteFont]], bold: int, italic: int, stretch: int) -> IDWriteFont | None:
+    def match_closest_font(font_list: list[tuple[int, int, int, IDWriteFont]], weight: str, italic: int, stretch: int) -> IDWriteFont | None:
         """Match the closest font to the parameters specified.
 
         If a full match is not found, a secondary match will be found based on similar features. This can probably
@@ -2704,18 +2701,18 @@ class Win32DirectWriteFont(base.Font):
             (f_weight, f_style, f_stretch, writefont) = match
 
             # Found perfect match, no need for the rest.
-            if f_weight == bold and f_style == italic and f_stretch == stretch:
+            if f_weight == weight and f_style == italic and f_stretch == stretch:
                 _debug_print(
-                    f"directwrite: full match found. (bold: {f_weight}, italic: {f_style}, stretch: {f_stretch})")
+                    f"directwrite: full match found. (weight: {f_weight}, italic: {f_style}, stretch: {f_stretch})")
                 return writefont
 
             prop_match = 0
             similar_match = 0
             # Look for a full match, otherwise look for close enough.
             # For example, Arial Black only has Oblique, not Italic, but good enough if you want slanted text.
-            if f_weight == bold:
+            if f_weight == weight:
                 prop_match += 1
-            elif bold != DWRITE_FONT_WEIGHT_NORMAL and f_weight != DWRITE_FONT_WEIGHT_NORMAL:
+            elif weight != DWRITE_FONT_WEIGHT_NORMAL and f_weight != DWRITE_FONT_WEIGHT_NORMAL:
                 similar_match += 1
 
             if f_style == italic:
@@ -2737,7 +2734,7 @@ class Win32DirectWriteFont(base.Font):
             # Take the first match after sorting.
             closest_match = closest[0]
             _debug_print(f"directwrite: falling back to partial match. "
-                         f"(bold: {closest_match[2]}, italic: {closest_match[3]}, stretch: {closest_match[4]})")
+                         f"(weight: {closest_match[2]}, italic: {closest_match[3]}, stretch: {closest_match[4]})")
             return closest_match[5]
 
         return None