v12.2.2

• The project can now be build using Xcode 27.

v12.2.1

• #670: A number of test files were in a directory name
  with lower-case letters where upper-case letters should have been
  used. This only affects users checking out the repository on
  systems with a case-sensitive filesystem.

• #671: Fix build error in the Quartz bindings when the SDK
  is for macOS 15 or later and the build target is also macOS 15 or later.

• #659: Implement basic support for handling Swift classes that
  have an Objective-C representation but are not subclasses of NSObject,
  as used in the Network framework.

note

The Network framework builds upon grand central dispatch
(the pyobjc-framework-libdispatch package), and because of that
exceptions in callback handlers will cause a hard crash.

v12.2

• Update framework bindings for macOS 26.5 SDK

• The following code failed at the last line in previous versions:

   class MyObject(NSObject):
       pass
  
   obj = MyObject()
   obj.alloc = MyObject.alloc
   print(obj.alloc) # Raised AttributeError

• Backward incompatible changes: CFBagCreate and CFBagCreateMutable now match the API in Objective-C, that is, a value for the callbacks argument must be passed (must be kCFTypeBagCallBacks).

• #663: Fix retain count management for the callbacks registered with DARegisterDiskEjectApprovalCallback, DARegisterDiskMountApprovalCallback, and DARegisterDiskUnmountApprovalCallback in DiskArbitration bindings.

• “Hidden” instance methods were not hidden when looking them up as an attribute on the class, but found an unbound method as if the method was not hidden.

• “Hidden” instance methods were visible in dir(SomeClass).

• #664: Fix anObject.methodForSelector_(some_selector) resolving to a class method IMP when a bound selector object for some_selector is a class attribute.

• Fixed some memory leaks on unlikely error paths.

• #637: numbers.Number values are proxies as an NSNumber value.

• #665: the new of Objective-C classes now also support keyword arguments derived from class selectors of the form valueWithKey1:key2: (with an arbitrary prefix instead of value).

  The following calls are now possible (as examples):

  • Foundation.NSHost(address="www.python.org"), returns Foundation.NSHost.hostWithAddress_("www.python.org").

  • AppKit.NSImage(systemSymbolName="multiply.circle.fill", accessibilityDescription="multiply icon"), returns AppKit.NSColor.colorWithSystemSymbolName_accessibilityDescription_("multiply.circle.fill", "multiply icon").

• Add NSMutableData.take_bytes on Python 3.15 to mirror the new bytearray method of the same name.

• Rewrite the construction of objects representing method and function metadata, this should result in (slightly) less memory usage.

• This release gets the testsuite for pyobjc-core to a point where there is comprehensive test coverage for the entire bridge. All extension modules now have 100% test coverage according to lcov, although with use for exclusion comments to ignore code blocks that cannot be reached for various reasons (e.g. PyDict_New can fail, but that only happens when running out of memory and it not preproducable during testing).

• This enables refactoring the code in pyobjc-core with more confidence that this won’t result in unexpected changes in behaviour.

• Fix error message for invalid argument to a callable with a variable length output buffer argument.

• Fix error handlign for incomplete struct encodings.

• Raise better error when specifying a negative array size for (Objective-)C arguments where the size of a buffer is passed as one of the arguments to a method or function.

• A side effect of this is that a number of manual bindings no longer support passing -1 as the size of a buffer to derive the size from the Python sequence.

• A Python implementation for a method that returns void and has a single output parameter used to leak a reference to the return value.

• Fix crash when a Python implementation with a pass-by-reference output argument or return value returns an Objective-C instance that is no longer referenced in Python when the function returns, e.g.:

  @objc.objc_method(signature=b"@@:o^@")
  def myOutput_(self, a):
      return (1, NSObject.alloc().init())

• The bridge could pass a null pointer for a function pointer argument in some (unlikely) edge cases instead of raising an error.

• Fix various crashes related to edge cases in pass-by-reference argument handling (none of which happen are used in bindings for Cocoa frameworks)

• Metadata with a tuple as the value for c_array_length_in_arg for an output argument is now honored for methods implemented in Python.

• Fix crash when c_array_length_in_arg metadata refers to an non-existing argument.

• Fix handling of transient proxy value, such as when Objective-C calls a Python method when the object is kept alive from Objective-C (no active reference in Python).

  Edge case found while debugging an unexpected crash in the free-threaded build which uncovered a bug that also affected the regular build (but was not triggered there in the test suite).

• aValue.methodForSelector_ now works when the selector is implemented in Python, the result will be the Python callable (not wrapped in an objc.IMP value).

• #644: A number of constants in the CoreAudio bindings evaluated to byte strings, while the framework expects regular strings.

• Foundation.NSDecimalNumber can no longer be subclassed in Python.

  Subclasses was possible in older versions, but this is something that isn’t supported in Objective-C and has unexpected behaviour.

• The cobject and c_void_p arguments for opaque pointer types and objc.objc_object are now keyword only.

  This should not affect user code because passing these values by value isn’t useful (esp. because the c_void_p argument is the only one that’s useful for interop with 3th-party code).

• #668: “frozendict” is supported with Python 3.15a7 and later.

  • Instances roundtrip to Objective-C objects similarly as the dict type, including for keyed archiving. For non-keyed archiving a frozendict value is read back as a plain dict.

  • The metadata method on objc.function, objc.selector, and objc.IMP now returns a frozendict instead of a regular dict to indicate that changing the value has no effect.

• #674: Drop GIL when sending KVO notifications

  PR by github user Tim Clem.

• #669: Drop dependency on dis.dis

  PR by github user Max Bélanger.Update framework bindings for macOS 26.5 SDK

v12.1

• #661: 12.0 incorrectly has support for Python 3.9 in
  packaging metadata.

• Update framework bindings for the macOS 26.1 SDK

• Instances of :type:bytearray can be used as the argument for
  a function or selector that expects a null-terminated C char array.

• Automatically disable KVO usage for subclasses of NSProxy defined
  in Python.

• Fix SystemError when calling objc.propertiesForClass(objc.objc_object).

• objc.classAddMethods no longer supports callable's whose __name__
  attribute is a byte string.

• Clearer error messages when an entry in the methods added with
  objc.classAddMethod is invalid.

• Using objc.classAddMethods to add a method for which a custom
  IMP helper has been registered now works correctly (previously
  the default libffi IMP implementation was used in these cases),
  and likewise for using :funcsetattr to assign methods.

• It is no longer possible to use :func:objc.classAddMethods to
  override an existing method with an incompatible Objective-C signature,
  and likewise for using :func:setattr to do the same.

  It was already not possible to override a method from a super class
  with an incompatible Objective-C signature.

• It is now possible to use an :class:objc.objc_method instance
  in the method list argument for :func:objc.classAddMethod.

• -[OC_PythonObject copy] now actually copies the value if the
  value is not known to be immutable (such as subclasses of the
  builtin number types).

v12.0

• Drop support for Python 3.9, which will go out of support
  before PyObjC 3.12 is released.

• Added AVFAudio as a separate toplevel package, instead of keeping
  it merged in into AVFoundation.

  The package is included in the pyobjc-framework-AVFoundation distribution.

• Updated metadata for the macOS 26 SDK.

  As part of this introduce bindings for the following new framework bindings:

  • ARKit
  • CompositorServices
  • GameSave

  There are no bindings for the MetalPerformancePrimitives at this time, it is
  a low-level C++ library that would require a lot of work to create bindings.

• In macOS 26 a number of type encodings for block arguments include a signature
  for the block interface. Update PyObjC runtime introspection to ignore that
  information.

• Dropped old metadata scans. That is, all framework bindings are now created
  from the most recent macOS SDK headers with some manual additions and annotations.

  This change required adding manual entries for, in particular, constants that were
  renamed in by now old versions of macOS and have been removed from Apple's headers
  by now. These will be removed from PyObjC in a future update as well (but after
  a transition period where using them will raise a warning).

  This has the following user visible side effects (as far as they are
  visible, most of the the changes below affect versions of macOS that are long gone):

  • Accounts: The following constants are no longer available (on the old versions
    of macOS where these were available): ACFacebookAppVersionKey,
    ACFacebookPermissionGroupKey, ACFacebookPermissionGroupRead,
    ACFacebookPermissionGroupReadWrite, and ACFacebookPermissionGroupWrite.

  • AppKit: The NSFileWrapper class no longer supports with keyword arguments path,
    and serializedRepresentation, and the keyword set (URL, options, error).

  • AuthenticationServices: The classes
    ASAccountAuthenticationModificationReplacePasswordWithSignInWithAppleRequest
    and ASAccountAuthenticationModificationUpgradePasswordToStrongPasswordRequest
    no longer have a keyword argument set named (user, serviceIdentifier).

  • Automator: class AMBundleAction no longer accepts the keyword set (definition, fromArchive).

  • CFNetwork: The following functions were deprecated before macOS 10.6 and were removed
    in the macOS 10.15 SDK: CFHTTPReadStreamSetRedirectsAutomatically, and
    CFNetServiceSetProtocolSpecificInformation.

  • CloudKit: CKDiscoverUserInfosOperation no longer recognizes the keyword
    set (emailAddresses, userRecordIDs). CKFetchDatabaseChangesOperation
    no longer recognizes the keyword argument previousServerChangeToken.
    CKShare no longer recognizes the keyword arguments recordZoneID,
    rootRecord, and the keyword set (rootRecord, shareID).
    CKSubscription no longer recognizes the keyword argument coder,
    and the keyword sets (recordType, predicate, options),
    (recordType, predicate, subscriptionID, options),
    (zoneID, options) and zoneID, subscriptionID, options).

  • CoreAudio: The following functions are no longer available (all were deprecated between
    macOS 10.5 and 10.8, and removed from the macOS 10.15 SDK):
    AudioHardwareClaimAudioDeviceID, AudioHardwareDevicesDied,
    AudioHardwareDevicePropertyChanged, AudioHardwareDevicesCreated, AudioObjectCreate,
    AudioHardwareStreamPropertyChanged, AudioHardwareClaimAudioStreamID, AudioObjectPropertiesChanged,
    AudioHardwareStreamsCreated, AudioObjectsPublishedAndDied,
    AudioHardwareStreamsDied.

    The following constants are no longer available because they are not useful
    in python code: CA_PREFER_FIXED_POINT and COREAUDIOTYPES_VERSION.

  • CoreData: The constant NSFetchRequestExpressionType is no longer available.

  • CoreLocation: CLBeaconIdentityConstraint no longer supports the
    keyword UUID and the keyword sets (UUID, major) and (UUID, major, minor).

  • CoreServices: The following functions are no longer available (all were removed
    in the macOS 10.7 SDK): LSInit and LSTerm.

  • CoreText: The constant kCTVersionNumber10_6_7 is no longer available.

  • CryptoTokenKit: The following constants are no longer available. Use the modern
    names instead: TKSmartCardNoSlot, TKSmartCardSlotEmpty,
    TKSmartCardSlotProbing, TKSmartCardSlotMuteCard, and TKSmartCardSlotValidCard.

  • DiscRecording: The following constants are no longer available:
    DRCDTextEncodingASCII, kDRCDTextEncodingASCII,
    DRCDTextEncodingISOLatin1Modified, and kDRCDTextEncodingISOLatin1Modified.

  • DiskArbitration: The following constants are no longer available:
    kDADiskOptionEjectUponLogout, kDADiskOptionMountAutomatic,
    kDADiskOptionMountAutomaticNoDefer, and kDADiskOptionPrivate.

  • GameController: The struct type registration GCExtendedGamepadValueChangedHandler
    is gone (the existence of this type was a bug).

  • ImageCaptureCore: Constant ICCameraDeviceSupportsFastPTP is no longer
    available (only affects macOS 10.11).

  • Intents: Removed constant INMessageReactionTypeEmojiReaction, use
    INMessageReactionTypeEmoji instead.

  • Intents: INAggregatedMessageReaction no longer accepts the keyword set
    reactionType, emoji, reactionCount). INMessage no longer accepts
    the keyword sets (identifier, conversationIdentifier, content, dateSent, sender, recipients, groupName, serviceName, messageType, referencedMessage, reaction, aggregatedReactions)
    and
    (identifier, conversationIdentifier, content, dateSent, sender, recipients, groupName, serviceName, messageType, referencedMessage, sticker, reaction, aggregatedReactions). It
    does accept these keyword sets without the aggregatedReactions keyword though.

  • Intents: The INColor class no longer accepts the keyword set (read, green, blue).

  • Intents: The INHeadUnit class no longer accepts the keyword set (bluetoothIdentifier, iap2Identifier).

  • Intents: The INMediaSearch class no longer accepts the keyword set
    (mediaType, sortOrder, mediaName, artistName, albumName, genreNames, moodNames, activityNames, releaseDate, reference, mediaIdentifier).

  • Intents: The INStartCallIntent class no longer accepts the keyword set
    (audioRoute, destinationType, contacts, callCapability).

  • JavaScriptCore: Constants WEBKIT_VERSION_* are no longer available.

  • LocalAuthentication: The following constants are no longer available:
    kLAOptionAuthenticationReason and kLAOptionUserFallback.

  • Metal: The constant MTLStitchedLibraryOptionStoreLibraryInMetalScript
    is no longer available (was only present in a beta SDK)

  • MLCompute: Class MLCOptimizer no longer has a keyword argument named descriptor.

  • PassKit: The following constants are no longer available:
    PKDisbursementRequestScheduleFuture and PKDisbursementRequestScheduleOneTime.

    Because of this the type PKDisbursementRequestSchedule has been removed as well.

    The metadata for PKDisbursementAuthorizationController has been removed.

    Class PKShareablePassMetadataPreview no longer accepts the
    keyword set (passThumbnail, localizedDescription).

  • PubSub: Class PSFeed no longer accepts the keyword URL and
    the keyword set (data, URL).

    Note that the entire framework was removed in macOS 10.15, and the Python
    bindings will be removed in PyObjC 13 at the latest.

  • Quartz: The following constants are no longer available: CGFLOAT_EPSILON,
    CA_TEST, CA_TESTABLE_CLASS, CA_TESTABLE, kCGErrorLast.

  • Quartz: The following structs are no longer available (all of them contain
    callback pointers which aren't used in PyObjC's bindings for the APIs that use
    those structs): CGFunctionCallbacks, CGDataProviderCallbacks,
    CGPatternCallbacks, CGDataConsumerCallbacks, CGDataProviderDirectAccessCallbacks,
    CGDataProviderSequentialCallbacks, and CGPSConverterCallbacks.

  • Quartz: The CIColor class no longer accepts the keyword argument CGColor.

  • Quartz: The CIFilterGenerator class no longer accepts the keyword argument contentsOfURL.

  • Quartz: The CIFilterShape class no longer accepts the keyword argument rect.

  • Quartz: The CImage class no longer accepts the keyword sets (bitmapData, bytesPerRow, size, format, colorSpace),
    (CGImage, options), (CGLayer, options), (CVImageBuffer, options), (CVPixelBuffer, options),
    (contentsOfURL, options), (data, options), (IOSurface, options), (IOSurface, plance, format, options),
    (imageProvider, size, format, colorSpace, options), (texture, size, flipped, colorSpace),
    (texture, size, flipped, options),
    and keywords CGImage, CGLayer, CVImageBuffer, CVPixelBuffer, color, contentsOfURL,
    data and IOSurface.

  • Quartz: The CIImageAcculator class no longer accepts the keyword set (extent, format, colorSpace).

  • Quartz: The CISampler class no longer accepts the keyword sets
    (image, keysAndValues), (image, options), (values, count), (x, y),
    (x, y, z), (x, y, z, w),
    and keywords image, CGAfineTransform, CGPoint, CGRect, string,
    and x.

  • ScreenSaver: Class ScreenSaverView no longer accepts frame as its
    sole keyword argument (always use it in combination with ``isP...

v11.1

The major change in this release is aligning behaviour of the core bridge
with clang's documentation for automatic reference counting <https://clang.llvm.org/docs/AutomaticReferenceCounting.html>_
for initializer methods. In particular, PyObjC now correctly models
that methods in the "init" family steal a reference to self and return
a new reference.

In previous version of PyObjC the proxy for [NSObject alloc] would be
marked as 'partially initialized' and would be cleared when the -init method
returns something else then self.

This has two problems:

1. Behaviour is incorrect when +alloc returns a singleton whose
   -init method(s) are factory methods (such as NSArray in
   recent versions of macOS)

2. The proxy for Objective-C objects needs to contain mutable state.
   This in turn requires locking in the implementation to work
   correctly with free-threading.

This version drops the concept of "uninitialized" values and correctly models
how reference counts are handled by -init methods.

• Update framework bindings for the macOS 15.5 SDK

• Added bindings for the SecurityUI framework

• Restructure the PyObjC website

  The theme of the PyObjC websites is now shibuya
  to give a more modern look and feel to the website.

  The actual content is mostly still the same, with some minor restructuring
  of pages. Restructuring will continue in future updates.

• :class:objc.FSRef now implements :class:os.PathLike.

• :issue:642: Fix concurrency issue when creating NSArray instances
  using NSArray.alloc().init....

  In previous versions the following would fail on recent versions of macOS:

  .. sourcecode:: python

  value1 = NSArray.alloc()
  value2 = NSArray.alloc()

  value1 = value1.init()
  value2 = value2.init()

  That's a unrealistic code pattern, but the same can be triggered using
  NSArray.alloc().init() when run concurrently in multiple threads,
  especially when using free-threading.

• Fixing the previous issue required rearchitecting the way partially
  initialized objects (e.g. the result of SomeClass.alloc() are handled,
  and has some other user visible behaviour changes (none of which should
  affect normal code):

  • :class:objc.UninitializedDeallocWarning is now soft deprecated because
    this warning will never be emitted.

  • Bit 0x1 will never be set in the __flags__ attribute of
    Objective-C objects.

  • The proxied value of an :class:objc.objc_object instance will never
    be nil, all exceptions about accessing attributes or methods
    of a NIL object are gone.

  • It is now possible to call methods on a partially initialized object,
    in previous versions that would often result in setting the proxied value
    to nil.

  • It is now possible to call an init method multiple times an an
    partially initialized value, e.g.:

    .. sourcecode:: python

    part = SomeClass.alloc()
    value1 = part.init()
    value2 = part.init()

    Whether or not this is safe depends on the implementation of the
    Objective-C class. In general it is advised to not use this pattern,
    but always call SomeClass.alloc().init...() or the more pythonic
    SomeClass(...) introduced in PyObjC 10.3.

  • The following code accidentally worked in previous versions of PyObjC
    and will now crash. Handling of partially initialized objects in previous
    versions hides the reference counting bug in this code.

    .. sourcecode:: python

    class NilObject(NSObject):
    def init(self):
    self.release()
    return None

  • The isAlloc attribute of :class:objc.selector is deprecated and
    will be removed in PyObjC 12.

  • The bridge no longer uses CFRetain and CFRelease to maintain
    the reference counts of Objective-C values. The original reason to do
    this is no longer needed, there are edge cases where mixing native ObjC
    retain count updates with these functions causes problems.

• Python 3.14: Use PyUnstable_Object_IsUniquelyReferenced to check if the
  dealloc helper is uniquely referenced when trying to release it instead of
  manually checking the reference count.

  This fixes an unlikely edge case in the free threading build where checking
  the reference count like this is not correct.

• Deprecated :attr:objc.objc_object.pyobjc_ISA.

• Implement __class_getitem__ for :class:objc.function,
  :class:objc.selector. :class:objc.varlist. and
  :class:objc.WeakRef

  This allows for treating these classes a generic in type annotations.

• Add some methods to :class:PyObjCTools.TestSupport.TestCase, in
  particular
  :meth:assertIsInitializer <PyObjCTools.TestSupport.TestCase.assertIsInitializer,
  :meth:assertIsNotInitializer <PyObjCTools.TestSupport.TestCase.assertIsNotInitializer,
  :meth:assertDoesFreeResult <PyObjCTools.TestSupport.TestCase.assertDoesFreeResult,
  :meth:assertDoesNotFreeResult <PyObjCTools.TestSupport.TestCase.assertDoesNotFreeResult.

• Add implementation for NSMutableData.resize to match :meth:bytearray.resize that
  was introduced in Python 3.14.

• Using a instance of a Python class with an __call__ method as
  an Objective-C block is now possible.

• Change PyObjC's internal assertions in C code from PyObjC_Assert to assert
  (and only enable them using debug builds of CPython). This is slightly more efficient
  and enables removing error return paths in a number of functions due to internal
  APIs that could only fail due to assertion errors.

• Removed some helper code that was used when subclassing a number of NSDecimalNumber
  methods. This should have no effect because overriding these methods is effectifly
  impossible anyway on recent versions of macOS.

• Fix some free-threaded race conditions

• Classes NSString and NSMutableString are marked as "final", which
  means these classes can no longer be subclassed.

  Reason for this is that Cocoa strings have special handling in PyObjC
  and trying to subclass these classes in Python will result in crashes.

• The objc._objc extension no longer performs imports from native code,
  all external dependencies are passed in as (private) options from Python
  code.

  This simplifies PyObjC's code, and avoids having imports that are hidden
  from analysis tools.

• Remove usage of pkg_resources in PyObjC's setup.py files.

  This is needed because this library is deprecated in setuptools and will
  be removed.

• :issue:651: Fix build issue on macOS 10.12 by changing the invocation
  of sw_vers(1).

PyObjC 11: Support for macOS 15

Version 11.0

The major change in this release is experimental support for free-threading
(PEP 703 <https://peps.python.org/pep-0703/>_) which was introduced
as an experimental feature in Python 3.13.

This required fairly significant changes in the core of PyObjC to change
C Python API use and PyObjC internal APIs (mostly related to the use of
borrowed references).

• Dropped support for Python 3.8. PyObjC 11 supports Python 3.9 and later.

• Updated metadata for the macOS 15.2 SDK, including bindings
  for the following frameworks:

  • MediaExtension
  • DeviceDiscoveryExtension

• :issue:249: Added minimal bindings to the Carbon framework.

  At this time only some functions and constants related to hotkeys
  are available. Please file an issue if you have a usecase for other APIs.

• :issue:249: Added minimal bindings to the Carbon framework.

  At this time only some functions and constants related to hotkeys
  are available. Please file an issue if you have a usecase for other APIs.

• :issue:615: Struct wrappers now support a number of functions from
  :mod:copy: :func:copy.replace (new in Python 3.13), :func:copy.copy
  and :func:copy.deepcopy.

• The __pyobjc_copy__ method has been removed from struct wrappers. This
  was never a public API. Use :func:copy.deepcopy instead.

• :meth:`objc.FSRef.from_pathnow supportsos.PathLike`` values as its
  arguments (as well as strings).

• :issue:608: Experimental support for the free-threading mode
  introduced in Python 3.13.

  The core bridge and framework bindings claim compatibility with free-threading
  as introduced as an experimental feature in Python 3.13.

  The support in PyObjC is also an experimental feature: I've reviewed
  code for free-threading issues and adjusted it where needed, but the
  code has seen only light testing w.r.t. concurrency.

  Some functionality that's explicitly not thread-safe:

  • Defining an Objective-C class with the same name in multiple threads concurrently.

  • Splitting calls to alloc and init and calling init multiple
    times concurrently. E.g.:

    .. sourcecode:: python

    import threading
    from Cocoa import NSObject
    
    v = NSObject.alloc()
    
    t_list = []
    for _ in range(2):
        t = threading.Thread(target=lambda: v.init())
        t_list.append(t)
        t.start()
    
    for t in t_list:
        t.join()
    

• The internal mapping from Python values to their active Objective-C
  proxy value now uses weak references. This should not affect user code,
  other than being a bit more efficient.

• The internal interfaces for updating this mapping, and the reverse mapping
  from Objective-C values to their active Python proxy was changed to remove
  a small race condition. This was required for free threading support, but
  could in theory also bit hit when using the GIL.

• The data structure for mapping Python values to their Objective-C proxy
  has been rewritten to support free threading. This also simplifies the
  code, and should be small performance improvement for the regular build
  of Python.

• The :exc:TypeError raised when passing a non-sequence value to
  some APIs implemented in C now has a __cause__ with more detailed
  information.

  This is a side effect of dropping the use of PySequence_Fast in the
  implementation of PyObjC.

• Removed objc.options._nscoding_version, a private option that is no
  longer used.

• Changing the __block_signature__ of a block value when the current
  value of the signature is not None is no longer possible.

  Please file an issue if you have a use case for changing the signature
  of a block.

• Fix compatibility with Python 3.14 (alpha 3)

• Removed private function objc._sizeOfType because its unused.

• Fix memory leak when using Python callables as blocks.

  The memory leak also resulted in leaking a reference to the callable
  (and hence anything kept alive by that reference).

• The generic __new__ implementation now works as intended when
  registering methods that other than init... methods.

• Dropped '%n' support in handling printf-format strings for variadic
  functions and methods.

  Two reasons for that: 1) supporting this properly should return the
  value writing to the %n location (requiring significant changes) and
  2) Apple's libraries require using static strings for '%n' to work (at
  least on some platforms and versions of the OS)

• :issue:633: Fix manual bindings for AVAudioPCMBuffer methods for
  getting channel data (floatChannelData, int16ChannelData and
  int32ChannelData)

• :issue:632: fix broken bindings for CGWindowListCreateImageFromArray.

• The private __is_magic attribute on :class:objc.objc_object has
  been renamed to __pyobjc_magic_coookie__.

• Various fixes to edge case behaviour that were found while improving
  test coverage.

v10.3.2

• Fix a number of test failures on macOS 15 These are all documentation and test updates.

• #593: PyObjCTools.AppHelper.runConsoleEventLoop no longer exits the process on macOS 14 or later when stopping the event loop.

• #613: Actually expose protocols KHTTPCookieStoreObserver, WKURLSchemeTask, and WKURLSchemeHandler in the WebKit bindings.

• Remove workaround for a linker problem in early versions of Xcode 15, which restores support for building with Xcode Command Line tools.

• The release contains wheels for the free-threaded build of Python 3.13.

  Note that PyObjC does not support running without the GIL at this time.

• Fix for running test suite with recent versions of setuptools

  Recent versions of setuptools broke the "test" command, the full command has been reimplemented as part of PyObjC.

• #627: Fix build issue when deployment target is 15.0 or later.

• #623: Don't lowercase the first character of the first keyword argument for __new__ when the segment only contains upper case characters.

  Before this change initWithURL: mapped to an uRL keyword argument, with this fix the keyword argument is named URL.

  Fix by user @rndblnch on github

• #625: Fix crash for calling NSIndexSet.alloc().initWithIndex_(0)

  This "fix" is a workaround for what appears to be a bug in Foundation.

• #569: Actually remove the workaround for Xcode 15.0

• #619: Fix race condition in creating proxy objects for Objective-C classes.

v10.3.1

• #610: Ensure __init__ can be used when user implements __new__.

  Version 10.3 dropped support for calling __init__, but that breaks
  a number of popular projects. Reintroduce the ability to use __init__
  when a class or one of its super classes contains a user implemenentation
  of __new__.

  Code relying on the __new__ provided by PyObjC still cannot use
  __init__ for the reason explained in the 10.3 release notes.

v10.3

• The release contains binary wheels for Python 3.13

  PyObjC does at this time not support the experimental free threading
  support in Python 3.13.

• #569: Removed the workaround for a bug in Xcode 15.0

  The workaround is no longer necessary, and caused problems when
  building with the Command Line Tools development tools from Apple.

• Updated SDK bindings for macOS 14.5

• A minor change in the (currently private) tooling I use for
  collecting the raw metadata resulted in minor fixes to the framework
  bindings, in particular for metadata for a number of block and function
  typed arguments and return values.

• #275: It is now possible to create instances of Objective-C
  classes by calling the class, e.g. NSObject() instead of
  NSObject.alloc().init().

  The implementation of __new__ forwards calls to the underlying
  SomeClass.alloc().init...() pattern. In particular, all public init
  methods are translated into sets of keyword arguments:

  • Remove init or initWith from the start of the selector name
  • Lowercase the first character of what's left over
  • The strings before colons are acceptable keywords, in that order

  For example, given a selector initWithX:y: the __new__ method
  will accept x, y as keyword arguments, in that order.

  Framework bindings have been updated with additional metadata to support
  this pattern, and the sets of keyword arguments are automatically calculated
  for subclasses in written in Python.

  The limitation on the order of keyword arguments may be lifted in a future
  version, it is currently present to keep the code closer to the Objective-C
  spelling which should make it easier to look up documentation on Apple's
  website.

• For some Objective-C classes some of the init and new methods are not
  available even if they are available in super classes. Those methods are
  marked with NS_UNAVAILABLE in Apple's headers.

  As of this version these methods are also not available in Python code,
  trying to call them will result in an exception.

  To make methods unavailable in Python classes set these methods to None,
  e.g.:

  class MyObject(NSObject):
     init = None # NS_UNAVAILABLE

• Added :func:objc.registerUnavailableMethod,
  :func:objc.registerNewKeywordsFromSelector and
  :func:objc.registerNewKeywords to support the generic __new__
  in framework bindings.

  A limitation for registerUnavailableMethod is that it is currently
  not supported to reintroduce the method in a subclass, primarily because
  that functionality is not needed for framework bindings.

• Instantiating an Objective-C class by calling the class (e.g. invoking
  __new__) will not call __init__ even if one is defined.

  The implementation of a subclass of NSObject should always follow
  the Objective-C convention for initializing using one or more
  methods with a name starting with init.

  This can affect code that manually defines a __new__ method for
  an Objective-C class, in previous versions that was the only way
  to create instances in a Pythontic way.

• NSArray, NSMutableArray, NSSet and NSMutableSet accepted
  a sequence keyword argument in previous versions. This is no longer supported.

  It is still supported to create instances using a positional argument
  for a sequence, e.g. NSArray([1, 2, 3]).

• NSData, NSMutableData, NSDecimal, NSString and NSMutableString
  accepted a value keyword argument in previous versions. This is no longer supported.

  It is still supported to create instances using a positional argument,
  e.g. NSData(b"hello").

• NSDictionary and NSMutableDictionary do not support the
  generic new interface because this conflicts with having a similar
  interface to dict for creating instances.

  That is, NSDictionary(a=4, b=5) is the same as NSDictionary({"a":4, "b":5}),
  and not like NSDictionary.alloc().initWithA_b_(4, 5).