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).

v10.2

• Fix a number of warnings found by adding -Wpendantic to the CFLAGS for
  pyobjc-core

• Fix undefined behaviour warnings:

  • Suppress the undefined behaviour warning about out of range values in
    double to (unsigned) long long in the OC_PythonNumber implementation
    as these are unavoidable when matching NSNumber behaviour.

  • Switch to using memcpy instead of direct assignment in converting
    plain C values to/from Python because "packed" structs might result
    in accessing values through unaligned pointers.

• Updated bindings for the macOS 14.4 SDK (Xcode 15.3)

• Added bindings for the "BrowserEngineKit" framework on macOS 14.4 or later.

• Add :func:obj.registerPathType to register a Python type as a path like
  type with PyObjC. By default only :class:pathlib.Path is registered as such.

  A minor backward compatibility issue is that instances of the registered types
  will be written to NSArchive and NSKeyArchive archives as instances
  of NSURL and won't roundtrip back to the original Python type. This might
  change in future versions of PyObjC, at least for :class:pathlib.Path.

• #589: Instances of :class:pathlib.Path (and other types registered with
  objc.registerPathType) are bridged into Objective-C as instances of NSURL.

  This means that these types can be used as values passed to APIs expecting
  a filesystem URL, e.g.:

  path = pathlib.Path("/Applications/Numbers.app")
  bundle = NSBundle.bundleWithURL_(path)

• Fix some warnings in pyobjc-core when testing with Python 3.13a4.

• Add support for NSBezierPathElementQuadraticCurveTo in NSBezierPath.elementAtIndex_associatedPoints_.

• #595: Fix compilation error in pyobjc-framework-Cocoa with a recent
  deployment target.

v10.1

• Upgrade framework bindings for the macOS 14.2 SDK

• #579: Make sure the install.py and develop.py scripts in the
  repository work when run out of tree.

• #577: os.fspath(someURL) will not work with Cocoa URLs (NSURL, CFURLRef) that
  refer to local filesystem paths. TypeError will be raised for other URLs.

  This enables using regular Python filesystem APIs with URLs that refer to
  local filesystem paths.

• #572: Fix compilation issue when building on macOS 13 or earlier

• Fix build error on ancient macOS versions where clang doesn't support
  -flto=thin.

• Add a workaround for a crash in pyobjc-core when running the testsuite
  on macOS 10.14.

• Fix some issues found while running the testsuite on macOS 10.9 to
  macOS 13, instead of only testing on the latest macOS version. Most
  issues found where problems in the testsuite itself, but not all.

  Some of the changes skip tests on older macOS versions (10.12, 10.13
  and 10.14) due to running into what appears to be crashing
  platform bugs.

• #581: Fix dependencies between framework binding packages

• Fix build error with the current Python 3.13 alpha release (3.13a2).

v10.0

• Update bindings for macOS 14

  Symbols newly introduced in macOS 14 were added to the existing bindings,
  and the following new bindings were introduced:

  • Cinematic

  • MediaExtension

  • SensitiveContentAnalysis

  • Symbols

• The "IMServicePlugIn" bindings are no longer available

  The entire framework was deprecated in macOS 10.13 and removed in macOS 14.
  The bindings can not be build using the latest SDK, and had (at best) limited
  use.

• #542: PyObjC 10 requires Python 3.8 and no longer supports Python 3.7

• #547: Removed all MAC_OS_X_VERSION* constants from objc.

  These constants are needed in practice (switch to :func:objc.available to
  check for platform availability), and caused unnecessary code churn.

• The value for objc.options.deprecation_warnings is now a string
  instead of an integer.

• #555: Fix unintended incompatibility with pytest in PyObjCTools.TestSupport

• #295: The lazy loading machinery by default no longer uses
  objc.ObjCLazyModule, but uses module level __dir__ and
  __getattr__ instead. The class :class:objc.ObjCLazyModule is still
  available, but is deprecated

  As a side effect of this objc is no longer an attribute of framework
  binding packages (e.g Foundation.objc is no longer a valid attribute).

  Another side effect of this is that all attributes added by the import system
  are now correctly present in the packages for framework bindings.

  And a final side effect is that private symbols (prefixed with underscore) are
  no longer imported from dependencies of framework bindings (more closely matching
  the from dependency import * behaviour that the lazy importer emulates.

• Add attribute __framework_identifier__ to all framework bindings with the
  identifier of the corresponding system framework.

• #295: Introduce :func:objc.createFrameworkDirAndGetattr to
  create module level __dir__ and __getattr__ for use by
  framework bindings.

• #561: Tests now validate the bundle identifier value used in framework bindings.

  This resulted in a number of changes to framework bindings with incorrect
  bundle identifier values. This shouldn't affect user code because the
  bundle loader falls back on the framework path when the identifier cannot be found.

• #559: Avoid test failures in pyobjc-core when pyobjc-framework-Quartz is
  not installed.

• A number of classes can no longer be subclasses in Python because they are marked as non-subclassable
  in the macOS 14 SDK (either directly or as "subclassing is deprecated":
  CKAllowedSharingOptions,
  CKAsset,
  CKContainer,
  CKDatabase,
  CKDatabaseNotification,
  CKDatabaseSubscription,
  CKFetchRecordZoneChangesConfiguration,
  CKNotification,
  CKNotificationID,
  CKNotificationInfo,
  CKOperationConfiguration,
  CKOperationGroup,
  CKQuery,
  CKQueryCursor,
  CKQueryNotification,
  CKQuerySubscription,
  CKRecord,
  CKRecordID,
  CKRecordZone,
  CKRecordZoneID,
  CKRecordZoneNotification,
  CKRecordZoneSubscription,
  CKReference,
  CKServerChangeToken,
  CKShare,
  CKShareMetadata,
  CKShareParticipant,
  CKSubscription,
  CKSyncEngine,
  CKSyncEngineAccountChangeEvent,
  CKSyncEngineConfiguration,
  CKSyncEngineDidFetchChangesEvent,
  CKSyncEngineDidFetchRecordZoneChangesEvent,
  CKSyncEngineDidSendChangesEvent,
  CKSyncEngineEvent,
  CKSyncEngineFailedRecordSave,
  CKSyncEngineFailedZoneSave,
  CKSyncEngineFetchChangesOptions,
  CKSyncEngineFetchedDatabaseChangesEvent,
  CKSyncEngineFetchedRecordDeletion,
  CKSyncEngineFetchedRecordZoneChangesEvent,
  CKSyncEngineFetchedZoneDeletion,
  CKSyncEnginePendingDatabaseChange,
  CKSyncEnginePendingRecordZoneChange,
  CKSyncEnginePendingZoneDelete,
  CKSyncEnginePendingZoneSave,
  CKSyncEngineRecordZoneChangeBatch,
  CKSyncEngineSendChangesContext,
  CKSyncEngineSendChangesOptions,
  CKSyncEngineSentDatabaseChangesEvent,
  CKSyncEngineSentRecordZoneChangesEvent,
  CKSyncEngineState,
  CKSyncEngineStateSerialization,
  CKSyncEngineStateUpdateEvent,
  CKSyncEngineWillFetchChangesEvent,
  CKSyncEngineWillFetchRecordZoneChangesEvent,
  CKSyncEngineWillSendChangesEvent,
  CKSystemSharingUIObserver,
  CKUserIdentity,
  CKUserIdentityLookupInfo.

• The encoding of a number of basic types changes, in particular those
  of CoreFoundation struct types and SIMD struct types. None of this
  should affect user code.

• objc.getClassList now has an optional positional argument to
  ignore classes with a name that aren't identifiers.

• Some of the functionality in CoreFoundation was rewritten in Swift
  in macOS 14, with Swift subclasses of NSArray and NSDictionary.
  Those classes break an invariant of PyObjC: the superclass of the root
  of the Swift class hierarchy changes when the class is instantiated
  for the first time (from NSObject to the correct superclass).

  PyObjC 10 contains a workaround for this by ignoring these classes
  unless they are needed to create a proxy for an instance (FB12286520).

• Fix crash when the method signature retrieved from the Objective-C runtime
  contains the class name for a method returning id.

• Remove old 32-bit support in metadata override files.

• Restructure objc.simd: The matrix types are now named simd_float3x3
  instead of matrix_float3x3, with the older name as an alias (to match
  older system headers).

• Fix crash when loading the libdispatch bindings on recent macOS versions
  (at least macOS 13, possibly earlier)

• dispatch.dispatch_source_t is renamed to dispatch.dispatch_source_type_t
  to match the type name in C code.

• #569: Xcode 15 has a bug when using weak symbols and targeting older macOS
  versions. Switch to the old linker when detecting Xcode 15.