CVS commit: pkgsrc/databases/py-multidict

["Thomas Klausner" <wiz%netbsd.org@localhost>]

Module Name:    pkgsrc
Committed By:   wiz
Date:           Sat Sep 26 10:18:39 UTC 2026

Modified Files:
        pkgsrc/databases/py-multidict: Makefile distinfo
        pkgsrc/databases/py-multidict/patches: patch-setup.py

Log Message:
py-multidict: update to 6.9.1.

6.9.1
=====

*(2026-09-21)*

Bug fixes
---------

- Fixed the C extension reading freed memory on free-threaded builds when a
  list handed to :py:meth:`~multidict.MultiDict.update`,
  :py:meth:`~multidict.MultiDict.extend`, :py:meth:`~multidict.MultiDict.merge`
  or the :py:class:`~multidict.MultiDict` and :py:class:`~multidict.CIMultiDict`
  constructors, a ``[key, value]`` item inside any iterable handed to them, or a
  list tested with ``in`` against :py:meth:`~multidict.MultiDict.items`, is
  changed by another thread; a call that catches the list shrinking under it
  now raises :py:exc:`RuntimeError` -- by :user:`rodrigobnogueira`.

  *Related issues and pull requests on GitHub:*
  :issue:`1437`.

- Fixed a data race on the free-threaded build where a retired hash table's
  reader count used relaxed atomics, letting a lock-free ``get()``/``getone()``/
  ``__getitem__()`` read race a concurrent free of that table. The reader-exit
  decrement and the drain's free check now use release/acquire ordering
  instead -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1481`.

- Fixed a free-threaded build bug where two threads calling ``update()``,
  ``merge()``, or ``__setitem__()`` on the same key at the same time could lose
  the key entirely instead of just racing on which value wins. A decref of the
  replaced value could transiently suspend the writer's critical section,
  letting a second writer for the same key observe the first writer's
  in-progress entry as absent and, once both settled, mistake it for a stale
  duplicate and delete it. Every such decref is now deferred until the writer
  has released its critical section, so the window can no longer open.
  ``setdefault()`` had an unrelated instance of the same blind spot (it could
  insert a duplicate rather than recognizing an in-flight key), fixed alongside
  it -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1483`.

- Fixed a free-threaded build bug where ``getall()`` and the ``items()``/
  ``keys()``/``values()`` equality path could raise ``KeyError`` or report a
  present, never-deleted key as missing. A concurrent ``update()``/``extend()``/
  ``__setitem__()`` call can have its critical section transiently suspended
  (a decref triggering a blocking allocator call) while an entry is marked as
  part of its own bookkeeping; a reader landing in that window used to treat
  the mark as "not found" instead of "still there, in flight" -- by
  :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1484`.

- Fixed a reference leak in the C extension where ``operand | md.items()``
  and ``md.items() - operand`` leaked one key and one value reference per
  element of ``operand``, letting a large operand grow memory without bound
  (:gh:`GHSA-54p9-h82j-f925 <aio-libs/multidict/security/advisories/GHSA-54p9-h82j-f925>`)
  -- by :user:`asvetlov`.

  The issue was reported by :user:`waydeshi`.

  *Related commits on GitHub:*
  :commit:`350b4a0`.

- Fixed a segmentation fault on the standard (non-free-threaded) C extension
  build when a value type's ``__del__`` released the GIL (for example by
  calling ``time.sleep()``) while ``update()``, ``merge()``, ``__setitem__()``,
  ``__delitem__()``, ``pop()``, ``popone()``, or ``popall()`` was dropping a
  replaced or removed value. ``Py_BEGIN_CRITICAL_SECTION`` compiles to a no-op
  on this build, so nothing else was stopping a second thread from mutating the
  very same ``MultiDict`` concurrently once the GIL was released mid-mutation.
  Every such decref is now deferred until the mutation has fully finished, the
  same technique already used to close the analogous free-threaded-build race
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1489`.

- Fixed the C extension reading freed memory while iterating a
  :py:class:`~multidict.CIMultiDict` whose keys are plain :py:class:`str`.
  Converting such a key to :py:class:`~multidict.istr` could run Python code
  (a :py:class:`str` subclass's ``__str__`` or ``__del__``) or, on free-threaded
  builds, suspend the iterator's critical section, after which the iterator read
  the entry again even though a concurrent mutation could already have freed it.
  As part of the fix, :py:meth:`~multidict.MultiDict.copy` and re-initializing
  from another multidict now assign a new version in the C extension instead of
  reusing the source's, matching the pure Python implementation
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1496`.

- Fixed a use-after-free on the free-threaded build where a lock-free
  ``get()``, ``[]`` or ``in`` could read a hash table that a concurrent
  resize had just retired and another reader was freeing
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1497`.

Contributor-facing changes
--------------------------

- Removed a redundant ``include`` and a duplicated ``exclude`` line from
  ``MANIFEST.in``; sdist contents are unchanged -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1478`.

- Added ``.claudeignore`` file -- by :user:`asvetlov`

  *Related issues and pull requests on GitHub:*
  :issue:`1479`.

- Scaled up the pure-Python ``pop()``, ``popitem()``, ``__delitem__()``,
  ``add()`` and item-insertion benchmarks to do more work per measurement.
  Repeated CodSpeed runs on the same commit showed these particular
  benchmarks flagged as dominated by syscalls, understating their real
  cost and adding noise to the reported values; a larger working set
  amortizes that overhead -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1485`.

- Replaced deprecated *instrumentation* codspeed mode with *simulation* -- by :user:`asvetlov`

  *Related issues and pull requests on GitHub:*
  :issue:`1493`.

- Reorganized the mutating benchmarks (item insertion, ``update()``,
  ``add()`` of the same key, ``pop()``, ``popitem()``, ``clear()``,
  ``__delitem__()`` and ``__setitem__()``) to copy a fresh multidict and
  apply the operation in a loop, like the ``add()`` and ``extend()``
  benchmarks already do. The insertion, ``update()`` and ``clear()``
  benchmarks previously mutated a single multidict shared across
  rounds, so only the first round measured the intended operation; the
  rest did a single copy per round, letting per-round overhead dominate
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1494`.

- The ``repr()`` and view inequality benchmarks were updated to repeat their
  operation in a loop, like the other benchmarks, and the CodSpeed benchmark
  job was moved to Python 3.14 -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1498`.

- Dropped ``-I`` from the AddressSanitizer test command in ``AGENTS.md``
  and in the CI job. It implies ``-E``, which made Python ignore
  ``PYTHONMALLOC=malloc``, so small hash tables were still served from
  ``pymalloc`` arenas where use-after-free went undetected
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1499`.

- The CI/CD workflow was updated to stop superseded runs of the same pull request
  when a new commit is pushed; runs on ``master``, release branches, tags,
  the merge queue, and the daily schedule are never interrupted
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1500`.

- The release job was changed to upload distributions and their signatures
  to the GitHub Release one file at a time, skipping assets that were
  already attached and retrying after a pause, so that a parallel upload
  burst no longer tripped the GitHub secondary rate limit
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1503`.

Miscellaneous internal changes
------------------------------

- Corrected several comments in the free-threaded C extension that
  attributed critical-section suspension to a blocking ``PyMem_Malloc()``
  call; allocation alone never suspends an acquired critical section, and
  the real risk at those sites is a decref running
  a finalizer or weakref callback. Also dropped a retry loop in
  ``md_clone_from_ht()`` that guarded against the same, non-existent
  allocation-triggered suspension -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1486`.

- Changed the free-threaded build's deferred decref buffer, used by
  ``update()`` and ``__setitem__()``, to a chain of fixed-size blocks
  with a large inline first block instead of a small inline array that
  was reallocated on growth -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1501`.

----

6.9.0
==========

*(2026-09-18)*

Bug fixes
---------

- Protected ``repr()`` of ``MultiDict``, ``MultiDictProxy``, and their views
  in the C extension with a critical section, avoiding data races on the
  free-threaded build of CPython -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1431`.

- Guarded ``repr()`` of ``MultiDictProxy`` in the C extension and of
  ``KeysView`` in both the C extension and the pure-Python
  implementation against infinite recursion on self-referential
  containers, matching the existing guard on ``MultiDict``,
  ``ItemsView``, and ``ValuesView`` -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1431`.

- Protected ``MultiDict.update()``, ``.extend()``, ``.merge()``, ``.clear()``,
  ``.copy()``, and the ``MultiDict``/``CIMultiDict`` constructors in the C
  extension with a critical section, using the two-object form when a
  second multidict, multidict proxy, or plain ``dict`` instance is
  involved, avoiding data races and a segmentation fault on the
  free-threaded build of CPython. ``.clear()`` now also publishes the
  empty table before releasing any entry's references, so a concurrent
  caller can never observe a partially-cleared multidict even if releasing
  a value runs arbitrary Python code that suspends the held critical
  section -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1433`.

- Protected ``MultiDict.add()``, ``__setitem__``/``__delitem__``,
  ``get()``/``getone()``/``__getitem__``, ``__contains__``, ``getall()``,
  ``setdefault()``, ``pop()``/``popone()``/``popall()``/``popitem()``,
  ``__eq__``, iteration, and the ``&``/``|``/``-``/``^``/``in``/
  ``isdisjoint()`` operations on ``.keys()`` and ``.items()`` views in the
  C extension with a critical section, avoiding data races and
  use-after-free crashes on the free-threaded build of CPython
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1438`.

- Fixed a data race on the free-threaded build where ``MultiDictObject.used``
  was written non-atomically while ``len()`` read it with a relaxed atomic
  load -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1441`.

- Fixed several pre-existing use-after-free races on the free-threaded build: ``_md_resize()``
  and ``md_clone_from_ht()`` could allocate a new hash table, have their
  critical section transiently suspended during that allocation, and then use
  a keys-table pointer or size a concurrent operation had already invalidated;
  ``_md_del_at()`` (plain ``del``/``pop()``) could likewise leave ``self`` in
  an inconsistent state across a suspending decref -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1441`.

- Fixed a data race on the free-threaded build where ``md->keys`` was
  published with a plain store while lock-free readers loaded it
  atomically, and a false-negative race in ``get()``/``__contains__``
  where a hash temporarily marked by a concurrent replace could make a
  present key look absent -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1441`.

- Fixed several more pre-existing use-after-free and data-corruption races on
  the free-threaded build, this time in the ``__setitem__()``/``update()``/
  ``extend()``/``merge()`` replace path: a decref suspending the critical
  section mid-replace could leave a stale table pointer in use, misplace a
  temporarily-marked entry during a concurrent resize, or let one thread's
  duplicate-tracking mark get overwritten by an unrelated key's entry sharing
  the same hash bucket -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1441`.

- Fixed an unbounded memory leak on the free-threaded build where a retired
  hash table could sit on ``md->retired`` for the rest of the object's
  lifetime under sustained concurrent read traffic instead of being freed
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1443`.

- Fixed a data race on the free-threaded build of the C extension where
  ``state->global_version``, the version counter shared by every
  multidict instance and used to derive ``getversion()``, was bumped with
  a plain increment instead of an atomic op. Two threads mutating
  different instances at the same time could step on each other's update
  and hand out a duplicate (or non-monotonic) version number
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1444`.

- Fixed a data race on the free-threaded build of the C extension where
  ``getall()``/``popall()`` and ``update()``/``extend()``/``merge()``
  temporarily marked and unmarked a matching entry's hash with a plain,
  non-atomic store, while a lock-free ``__contains__``/``get()`` on another
  thread could load that same field with an atomic operation and no lock at
  all -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1448`.

- Fixed a data race in the pure-Python ``MultiDict``/``CIMultiDict``
  fallback where concurrent mutating calls (``add()``, ``__setitem__``,
  ``__delitem__``, ``setdefault()``, ``pop()``/``popone()``,
  ``popall()``, ``popitem()``, ``update()``, ``extend()``, ``merge()``,
  ``clear()``, and re-``__init__``) could corrupt the shared hash table,
  or silently drop a concurrent write, on a regular, GIL-enabled
  interpreter. Pure-Python bytecode is not atomic under the GIL, so two
  threads could interleave mid hash-table insert or deletion, leaving
  the index table pointing at stale or out-of-range entries and causing
  an infinite probe loop, an ``AttributeError``, or a lost mutation.
  Each ``MultiDict``/``CIMultiDict`` instance now holds its own lock for
  the duration of these operations, with two-object operations locking
  both instances in a fixed order to avoid deadlock. The C extension
  already serializes these operations with a critical section and was
  not affected
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1449`.

- Fixed a data race on the free-threaded build of the C extension where
  ``to_dict()`` cleared every entry's temporary "seen" mark with a plain,
  non-atomic store, while a lock-free ``__contains__``/``get()`` on another
  thread could load that same field with an atomic operation and no lock at
  all -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1450`.

- Fixed a data race on the free-threaded build of the C extension where
  ``update()``/``extend()``/``merge()`` read ``self``'s module state without
  holding ``self``'s lock, while a concurrent ``__init__()`` on the same,
  already-published multidict could rewrite that same field under lock.
  Rather than routing every read through a lock-free lookup, the field is
  now written only once, at object construction, and never touched again by
  ``__init__()``, so it is safe to read unlocked anywhere -- by
  :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1452`.

- Fixed ``items()`` set algebra (``&``, ``|``, ``-``, ``in``, ``isdisjoint()``) so it no
  longer corrupts or hangs when a compared value's ``__eq__()`` re-enters the
  same :class:`~multidict.MultiDict`, for example by calling ``getall()`` on
  it. The comparison now runs only after the internal hash-chain walk has
  been fully materialized and restored, so the callback can no longer
  observe entries the walk still has marked -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1453`.

- Fixed a data race on the free-threaded build of the C extension where
  ``popall()``/``popone()``/``__delitem__``/``add()`` rewrote a hash table
  index slot with a plain, non-atomic store, while a lock-free
  ``get()``/``getone()``/``__getitem__``/``__contains__`` on another thread
  walked that same index array with a plain, non-atomic load and no lock at
  all -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1454`.

- Stopped folding the case of :class:`~multidict.istr` keys in the
  case-sensitive :class:`~multidict.MultiDict`, so both the C and the pure
  Python implementations now keep such a key exactly as given
  -- by :user:`youdie006`.

  *Related issues and pull requests on GitHub:*
  :issue:`1457`.

- Fixed the C extension's ``update()`` (and ``merge()``, which shares the same
  code path) silently failing to invalidate an in-progress ``keys()``/
  ``items()``/``values()`` iterator when the call only overwrote an
  already-present key's value in place. Adding a new key already invalidated
  iterators correctly; only the in-place overwrite branch was missing the
  version bump -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1458`.

- Fixed the pure-Python ``MultiDict``/``CIMultiDict`` iterator guard so that
  mutating the mapping before the first ``next()`` call on an ``items()``,
  ``keys()``, or ``values()`` iterator (or on ``iter(md)``) now reliably raises
  ``RuntimeError``, matching the C extension. Previously a mutation that
  happened before the iterator was ever advanced, such as ``clear()`` or a
  ``del``/``popone()`` that removed the only remaining entry, could make the
  iterator silently raise ``StopIteration`` instead -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1459`.

- Fixed a use-after-free race on the free-threaded build of the C extension
  where a retired hash table could be freed while a lock-free
  ``get()``/``getone()``/``__getitem__``/``__contains__`` reader on another
  thread was still walking it: the coarse "no reader in flight" gate
  reaching zero did not reliably mean every such reader had also reached
  its own per-table exit, so a table whose own reader count is still
  nonzero is now deferred for a later retry instead of freed
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1461`.

Features
--------

- Added a :meth:`~multidict.MultiDict.to_dict` method returning a plain
  :class:`dict` that maps every key to the list of all its values. Unlike
  ``dict(md)``, which keeps only the first value per key, and unlike a
  ``{k: md.getall(k) for k in md}`` comprehension, which emits one entry per
  spelling of a case-insensitive key, it groups by key identity
  -- by :user:`rodrigobnogueira`.

  *Related issues and pull requests on GitHub:*
  :issue:`783`.

- ``MultiDict``, ``CIMultiDict``, ``MultiDictProxy`` and ``CIMultiDictProxy`` in the
  C extension implemented the vectorcall calling convention for construction.
  This sped up ``MultiDict(...)``-style calls by avoiding an intermediate
  positional-arguments tuple and keyword-arguments dictionary in the common case; the gained burst is ~10.
  -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1436`.

- Made ``MultiDict.__contains__()``, ``.get()``, ``.getone()`` and
  ``__getitem__()`` lock-free on CPython 3.14+'s free-threaded build, instead
  of taking a critical section like the rest of the C extension's API (on
  3.13, which lacks the public API these need to safely read an entry
  concurrently, they still take the critical section, exactly as before). A
  resize/shrink/clear no longer frees the outgoing hash table immediately; it
  is deferred until no lock-free reader could still be walking it -- by
  :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1441`.

- Made the pure-Python ``MultiDict``/``CIMultiDict`` implementation safe to
  use from multiple threads under a free-threaded (no-GIL) build. Every
  method that touches an instance's hash table now takes that instance's own
  lock, two-object operations (``update()``, ``extend()``, ``merge()``,
  ``__eq__()``, copying) lock both objects in a fixed, deadlock-safe order,
  and the version counter shared by every instance is guarded separately. On
  a regular (GIL-enabled) interpreter this adds no overhead: the locked
  methods are the exact same function objects as before -- by
  :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1447`.

- Sped up adding many values for the same key to a
  :class:`~multidict.MultiDict` or :class:`~multidict.CIMultiDict`, each
  added value no longer gets slower than the one before it
  -- by :user:`bdraco`.

  *Related issues and pull requests on GitHub:*
  :issue:`1466`.

Improved documentation
----------------------

- Added the plural form "fallbacks" to the docs spell checker's allowed
  word list so :file:`CHANGES.rst` builds cleanly -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1439`.

Contributor-facing changes
--------------------------

- Added race tests that iterate and extend a :class:`~multidict.MultiDict`
  from several threads on a free-threaded build, so a regression in the C
  extension's locking fails a free-threaded CI leg instead of going unnoticed
  -- by :user:`rodrigobnogueira`.

  *Related issues and pull requests on GitHub:*
  :issue:`1317`.

- Added ``AddressSanitizer``/``UndefinedBehaviorSanitizer`` and
  ``ThreadSanitizer`` CI jobs. The former runs the suite under a
  regular CPython with ``MULTIDICT_ASAN_BUILD=1``; the latter builds a
  free-threaded CPython instrumented with ``--with-thread-sanitizer``
  and runs the suite against it via ``MULTIDICT_TSAN_BUILD=1`` -- by
  :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1455`.

- Added Hypothesis-based property and stateful fuzz tests covering
  :class:`~multidict.MultiDict`/:class:`~multidict.CIMultiDict` semantics,
  views, iterators, and threaded stress scenarios, run against both the
  C-extension and pure-Python backends -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1460`.

- Added core dump collection to the AddressSanitizer and ThreadSanitizer
  CI jobs: a crash now uploads the core file alongside the crashing
  interpreter binary and the compiled extension as a downloadable
  artifact, for offline debugging with a matching symbol-carrying binary
  instead of raw hex offsets -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1462`.

- Added benchmarks for adding many values for the same key and for
  creating a multidict with many items -- by :user:`bdraco`.

  *Related issues and pull requests on GitHub:*
  :issue:`1465`.

- Skipped abstractmethods from coverage leaks report, they are empty placeholders that are never executed -- by :user:`asvetlov`

  *Related issues and pull requests on GitHub:*
  :issue:`1470`.

- Add benchmarks for ``__setitem__`` -- by :user:`asvetlov`

  *Related issues and pull requests on GitHub:*
  :issue:`1471`.

- The AddressSanitizer and ThreadSanitizer CI jobs were changed to run pytest
  with ``--capture=no``. Previously a sanitizer abort could exit the process
  before pytest flushed its per-test output buffer, silently dropping the
  sanitizer report from the job log -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1472`.

- Moved the ``hypothesis`` pin out of ``requirements/pytest.txt`` into its own
  ``requirements/pytest-hypothesis.txt``, installed only by the dedicated
  Hypothesis CI jobs. ``hypothesis`` now ships a Rust extension with no
  prebuilt wheel for some emulated architectures (e.g. musllinux i686),
  which broke wheel-testing jobs that never run the Hypothesis-marked tests
  in the first place -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1475`.

Miscellaneous internal changes
------------------------------

- Replaced ``PyIter_Next()`` calls with the newer ``PyIter_NextItem()`` API in
  the C extension, so the iterator-exhausted and error cases are told apart by
  the return code instead of an ambiguous ``NULL`` result -- by :user:`asvetlov`.

  *Related issues and pull requests on GitHub:*
  :issue:`1440`.


To generate a diff of this commit:
cvs rdiff -u -r1.44 -r1.45 pkgsrc/databases/py-multidict/Makefile
cvs rdiff -u -r1.40 -r1.41 pkgsrc/databases/py-multidict/distinfo
cvs rdiff -u -r1.1 -r1.2 pkgsrc/databases/py-multidict/patches/patch-setup.py

Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

Modified files:

Index: pkgsrc/databases/py-multidict/Makefile
diff -u pkgsrc/databases/py-multidict/Makefile:1.44 pkgsrc/databases/py-multidict/Makefile:1.45
--- pkgsrc/databases/py-multidict/Makefile:1.44 Thu Sep 10 11:21:25 2026
+++ pkgsrc/databases/py-multidict/Makefile      Sat Sep 26 10:18:39 2026
@@ -1,6 +1,6 @@
-# $NetBSD: Makefile,v 1.44 2026/09/10 11:21:25 adam Exp $
+# $NetBSD: Makefile,v 1.45 2026/09/26 10:18:39 wiz Exp $
 
-DISTNAME=      multidict-6.8.0
+DISTNAME=      multidict-6.9.1
 PKGNAME=       ${PYPKGPREFIX}-${DISTNAME}
 CATEGORIES=    databases python
 MASTER_SITES=  ${MASTER_SITE_PYPI:=m/multidict/}

Index: pkgsrc/databases/py-multidict/distinfo
diff -u pkgsrc/databases/py-multidict/distinfo:1.40 pkgsrc/databases/py-multidict/distinfo:1.41
--- pkgsrc/databases/py-multidict/distinfo:1.40 Thu Sep 10 11:21:25 2026
+++ pkgsrc/databases/py-multidict/distinfo      Sat Sep 26 10:18:39 2026
@@ -1,6 +1,6 @@
-$NetBSD: distinfo,v 1.40 2026/09/10 11:21:25 adam Exp $
+$NetBSD: distinfo,v 1.41 2026/09/26 10:18:39 wiz Exp $
 
-BLAKE2s (multidict-6.8.0.tar.gz) = 36eb3ef2ada5106790c624ec4774a10ace7c693e6b6f05f3b2da7f0dbca07a45
-SHA512 (multidict-6.8.0.tar.gz) = 434a5dcbee201ca705947943c8645f784d1c211836b6511c5b096b9b9cf181335e1d7015bfd91b8d4c11481e7d81d64f2363214c41f3d051fb7e202be128e383
-Size (multidict-6.8.0.tar.gz) = 122412 bytes
-SHA1 (patch-setup.py) = d170d71c292bb5ae48e3f38e08ef70880f8499a4
+BLAKE2s (multidict-6.9.1.tar.gz) = 02c8084eed1372ed93a3c2908afb2ea84d3b73d1e765896103599d067ae8a775
+SHA512 (multidict-6.9.1.tar.gz) = d72f59c152abb0cae09400ece185908295d6ad7dd682eaf7710b7cc918ceb41b94b001aa6e35cf35bd24c9a4418c0d99f79f29ef1e7b9754317f3eb56e08b14b
+Size (multidict-6.9.1.tar.gz) = 182404 bytes
+SHA1 (patch-setup.py) = e34afa517e8de912c2f0ce37243a7c8b46e1dd2a

Index: pkgsrc/databases/py-multidict/patches/patch-setup.py
diff -u pkgsrc/databases/py-multidict/patches/patch-setup.py:1.1 pkgsrc/databases/py-multidict/patches/patch-setup.py:1.2
--- pkgsrc/databases/py-multidict/patches/patch-setup.py:1.1    Thu Sep 10 11:32:24 2026
+++ pkgsrc/databases/py-multidict/patches/patch-setup.py        Sat Sep 26 10:18:39 2026
@@ -1,15 +1,15 @@
-$NetBSD: patch-setup.py,v 1.1 2026/09/10 11:32:24 adam Exp $
+$NetBSD: patch-setup.py,v 1.2 2026/09/26 10:18:39 wiz Exp $
 
 Use CFLAGS from pkgsrc.
 
---- setup.py.orig      2026-09-09 12:34:28.056868300 +0000
+--- setup.py.orig      2026-09-21 16:18:55.298134000 +0000
 +++ setup.py
-@@ -10,7 +10,7 @@ DEBUG_BUILD = bool(os.environ.get("MULTI
+@@ -12,7 +12,7 @@ if sys.implementation.name != "cpython":
  if sys.implementation.name != "cpython":
      NO_EXTENSIONS = True
  
 -CFLAGS = ["-O0", "-g3", "-UNDEBUG"] if DEBUG_BUILD else ["-O3", "-DNDEBUG"]
 +CFLAGS = ["-O0", "-g3", "-UNDEBUG"] if DEBUG_BUILD else ["-DNDEBUG"]
+ LDFLAGS = []
  
  if platform.system() != "Windows":
-     CFLAGS.extend(