v8.4

• The bindings for the Message and ServerNotification frameworks,
  which were removed in macOS 10.9, will be removed in PyObjC 9.

• Added bindings for ScreenCaptureKit (new in macOS 12.3)

• Updated framework bindings for the macOS 12.3 SDK.

  Based on Xcode 13.3 beta 3

• Reverted a change in 8.3: It is once again not possible to
  use the "is" operator to check if two proxies for an NSString
  refer to the same Cocoa object.

  The change in 8.3 changed long standng behaviour for mutable
  strings and may have caused unintended problems.

• #418: Added :class:typing.NewType definitions to the
  various framework bindings for all enum types in Cocoa
  (such as NSComparisonResult).

  Using this it is now possible to annotate methods returning
  such types, although it is not yet possible to type check
  this.

  For example:

  .. sourcecode:: python

  class MyObject(NSObject):
  def compare_(self, other: NSObject) -> NSComparisonResult:
  return NSOrderSame

  The actual representation of enum types is provisional
  and might change in the future.

• #440: Added :class:typing.NewType definitions to the
  various framework bindings for all NS_STRING_ENUM,
  NS_TYPED_ENUM and NS_TYPED_EXTENSIBLE_ENUM types in Cocoa.

• #432: Fix compatibility check when a class implements protocol NSObject.

  The following code used to fail the protocol implementation check:

  .. sourcecode:: python

  class AppDelegate( Cocoa.NSObject, protocols=[objc.protocolNamed("NSApplicationDelegate")]):
  pass

  The reason for this is that the type encodings for (at least) -[NSObject respondsToSelector:]
  in the Objective-C runtime doesn't match the type encoding in @protocol(NSObject) (the
  former returns char, the latter bool). The compatibility check now handles trivial
  differences like this.

• #428: Class NSData now implements the API from :class:bytes. The methods that
  return bytes in :class:bytes also return bytes in NSData. This may change in a
  future version.

  Class NSMutableData now implements the API from :class:bytearray as far as this
  doesn't conflict with the native API. In particular, NSMutableData.copy() returns
  an immutable copy (instance of NSData), use NSMutableData.mutableCopy() to
  create a mutable copy.

  .. note::

  The implementation is mostly suitable for fairly small amounts of data as
  the Cocoa value is first copied into a Python value.

• NSData([1,2,3]) and NSMutableData([1,2,3]) now work the same
  as bytes([1,2,3]) and bytearray([1,2,3]).

• #334: Workaround for catetory on NSMutableArray that introduces a conflicting pop method

  Some class in Cocoa can at times introduce an (undocumented) selector -pop
  on subclasses of NSArray, which conflicts with a convenience method that
  emulates :meth:list.pop. The version introduces a workaround for this by
  adding the convenience method to all (statically known) subclasses of NSArray.

  This is far from perfect, but fixes the problem for now.

• Fix memory manager API misuse

  PyObjC's :class:str subclass used the python allocator API incorrectly,
  causing an assertion failure when running tests with "python3 -Xdev",
  as well as a hard crash due to using the API without holding the GIL.

• #445: Workaround for Python 3.11 support

  Workaround for BPO-46891 <https://bugs.python.org/issue46891 >_, which causes
  a hard crash in the PyObjC testsuite. With this workaround the tests for
  pyobjc-core pass with python 3.11a5, but this does result into adding some
  implementation internals to the __dict__ of framework wrappers when using
  Python 3.11

• Fix build error on macOS 10.9

• Fix :class:str implementation invariant in the :class:objc.pyobjc_unicode
  subclass. With this fix the string consistency checks in debug builds of
  CPython pass.

• Fix exception handling when passing a bytes object to a C function
  with a byte buffer "inout" argument.

v8.3

This release contains a lot of small fixes dueo to the continued improvement
of test coverage for the C code in pyobjc-core.

• Backward incompatible change:

  -[OC_PythonDictionary setObject:value forKey:[NSNull null]] now sets
  key :data:None in the Python dictionary instead of NSNull.null().

  This is for consistency with -[OC_PythonDictionary objectForKey:] and
  other collection classes. Getting and setting key [NSNull null] now
  actually works.

• Backward incompatible change:

  -[OC_PythonDictionary removeObjectForKey:] now raises NSInvalidArgumentException
  instead of Python's KeyError for missing keys. This matches the documented
  behaviour of NSDictionary.

• Backward incompatible change:

  -[Protocol descriptionForClassMethod:] now only accepts selector names
  (such as b"description") as its argument, not instances of
  :class:objc.selector. This matches the behaviour of other methods
  with an argument of the C type SEL.

• :func"objc.namedSelector and :func:objc.typedSelector now also work when
  the decorated function is a :func:classmethod.

• Fix build problem on macOS 10.14 or earlier

• The Objective-C proxy for a python :class:int is now always OC_PythonNumber,
  in previous versions instances were proxied as NSNumber when the
  value was in the range of an unsigned long long that's outside of the
  range of a (signed) long long (that is, a value between
  2**63 and 2**64).

• Two NSString* values in Objective-C are now proxied to the
  same :class:objc.pyobjc_unicode instance when the two pointers are
  equal in Objective-C.

  That is, given NSString* value1 and NSString* value2
value1 == value2 in Objective-C can be replaced by
  value1 is value2 in Python. In older versions of PyObjC
  this invariant was not maintained, requiring more involved code to
  check if two strings represent the same object.

  This invariant was already maintained for other instances of other
  Objective-C classes.

• The proxy for python's :class:bytearray (and other writable buffers) now
  supports the mutableBytes method in Objective-C.

  As a side effect of this OC_PythonData is now a sublcass of
  NSMutableData instead of NSData.

• Fixed retrieving an :class:bytearray value from a Cocoa archive

  In previous versions this resulted in garbage data.

• Instances of :class:bytearray can now be included in "secure" Cocoa archives

• Remove -[OC_PythonArray getObjects:inRange:], it is not part of the
  regular NSArray interface and was never used.

• The proxy for python datetime objects was rewritten to be a lot simpler.

  User visible changes:

  • The new implementation is more correct, the old implementation truncated
    timestamps at whole seconds.

  • Calculating in Objective-C (such as calling -[NSDate dateByAddingTimeInterval:]
    will now always result in an NSDate value, not a Python value.

  • The proxy code now calls the "timestamp" method instead of "strftime" during
    conversion from Python to Objective-C.

• Adding :class:datetime.datetime and :class:datetime.date instances to an
  archive now works, both for keyed and classic archives.

  For the exact types :class:datetime.datetime and :class:datetime.date the encoding
  is compatible with that of NSDate and supports NSSecureCoding as long as the
  values are not timezone aware.

  When communicating with pure Objective-C code any timezone information will be lost.

  Note that both :class:datetime.datetime and :class:datetime.date are
  represented as an NSDate in Objective-C land, even though this Objective-C has
  semantics of the latter class don't fully match that of the Cocoa class.

• Fix python internal error when the "module_globals" argument to
  :func:objc.loadBundleFunctions is not a :class:dict.

• Fix the result of :func:inspect.signature for :class:objc.IMP.

  In previous versions this included the implicit "selector" argument that isn't used
  by Python callers.

• Avoid crash when trying to load a "magic" cookie CoreFoundation value for a
  type unknown to the PyObjC bridge.

• Removed -[OC_PythonObject pyObject].

  The method is no longer used by PyObjC itself, and these proxy objects are considered
  a private API that may change at any time.

• Removed +[OC_PythonObject classForUnarchiver]

  This method was present for compatibility with the NSObject interface, but isn't
  actually part of Cocoa.

• -[OC_PythonObject methodSignatureForSelector:] and
  +[OC_PythonObject methodSignatureForSelector:] now return nil instead of
  raising an exception when the queried selector does not exist. This matches
  the behaviour of NSObject.

• Fix the metadata in the bindings for DiscRecording, Intents, SceneKit, and libdispatch
  to ensure that the __all__ variable actually works.

• Eliminated usage of sscanf in pyobjc-core

  A possible user visible change is that the use of sscanf
  to parse an IPv4 address has been replaced by a call
  to inet_pton(), which may affect different representations
  of an IPv4 address.

• OC_PythonSet now epxlictly calls set related methods instead
  of using C-API functions like :func:PySet_Clear. This simplifies
  the pyobjc-core code, and gives fewer problems with set subclasses.

• Fix the buffer size used to for "struct sockaddr" arguments

• Added objc._C_CFRange and objc._C_NSRange with the type
  encodings of the C types CFRange and NSRange.

• Functions and methods where the length of a C array argument is passed
  in another argument (such as int function(int* buffer, size_t bufsize))
  now also work when the argument with the size is a pointer to
  a CFRange or a pointer to a char.

• A :class:memoryview of an NSMutableData instance is now writable.

• Fix crash when trying to create an :class:objc.informal_protocol with
  a sequence of selectors that contains a value that isn't an instance
  of :class:objc.selector.

• #435: Fix build problem with Xcode 13.3

  Xcode 13.3 introduces a new warning in -Wall: -Wunused-but-set-variable,
  and this found some code quality issues with PyObjC.

v8.2

This release contains a lot of little fixes due to improving
test coverage of the C code in pyobjc-core. These are mostly fixes
for edge cases that don't happen in normal programs.

• Reintroduce binary wheels for Python 3.6

  PyObjC 8.x still supports Python 3.6, but I didn't ship binary wheels
  until now.

  I plan to explicitly remove support for Python 3.6 in PyObjC 9, which
  will include updating package metadata to ensure that users of Python 3.6
  will keep using PyObjC 8.x.

• #414: [Python 3.10] The representation for C structures, like
  Foundation.NSPoint now have a __match_args__ attribute, which means
  it is now possible to use positional arguments to these types in match expressions.

  For example:

  .. sourcecode:: python

  from Foundation import NSPoint

  value = ...

  match value:
  case NSPoint(0, _):
  print("On the Y axis")

• The internal extension API between framework bindings and pyobjc-core has
  been cleaned up a little. Because of this extensions need to be
  recompiled for this version.

• :func:objc.allocateBuffer is deprecated, use :class:bytearray instead

  This function has always returned a bytearray object in Python 3 and it
  no longer necessary.

  As a side effect of this change the function is now implemented in Python
  instead of C.

• The private function objc._dyld_shared_cache_contains_path is now
  always available, and unconditionally returns :data:False on systems without
  a shared library cache.

• The private function objc._setClassExtender is now implemented in Python
  and will be removed in PyObjC 9.

• Removed private function objc._typestr2typestr.

  This function was untested and is no longer used by PyObjC.

• Removed the selector supportsWeakPointers from a number of classes.

  This method may have been needed during Apple's transition to ARC, but is
  no longer document and I've never seen it called during testing on recent
  versions of the OS.

  Furthermore the custom implementation of retain and release in PyObjC
  is a thin wrapper around the default one with additional locking to avoid
  race conditions during deallocation.

• :func:objc.recylceAutoReleasePool will now restore the global release pool
  when called after calling :func:objc.removeAutoreleasePool.

• Removed objc.FSSpec

  This is a wrapper for a C type that's only usable in 32-bit code, PyObjC
  no longer supports 32-bit.

• The default implementation of -copy for subclasses of Objective-C
  classes that implemented -copy (needed to adjust Python attributes)
  didn't consider that the superclass implementation of -copy may
  return an instance of a different class. This caused a hard crash.

  The easiest way to trigger this bug: Create a subclass of NSMutableData
  in Python, create an instance of that class and call the copy method.

• The module PyObjCTools.TestSupport was modernized a little

  This most visible part of this is that a number of functions and assertion
  method have been removed because they have a better alternative in the
  :mod:unittest library.

• #404: Instances of the Python represention of C structs can now be pickled.

  That is, instances of AppKit.NSPoint, Foundation.NSRange, etc. can
  be pickled. The exception are a number of types in the CoreAudio bindings
  that have manual wrapper types instead of the generic support in pyobjc-core.

• Switch to :c:func:PyCapsule_Import to load the PyObjC API object in
  extension modules.

• Fix crash when calling objc.FSRef.from_pathname() with a path
  that cannot be encoded in the filesystem encoding (UTF-8).

• Fix name of opaque pointer type wrappers (such as Foundation.NSZonePtr)

  The "name" and "qualname" attributes were correct, but the
  corresponding slot in the C struct of the type could point to
  no longer valid memory.

• Function :func:objc.registerABCForClass now actually works

• Fix bug in lazyloader where fetching the module's __all__ could
  raise :exc:AttributeError for some particular constants.

• #317: Cleanup code dealing with libffi closures APIs on various versions
  of macOS.

• If fetching the __pyobjc_object__ attribute during conversion from
  Python to Objective-C raisea an exception other than :exc:AttributeError
  the conversion will fail.

  In previous versions the attribute was ignored when this happens.

• Fix error in __str__ and __repr__ of an Objective-C instance
  when the class' description selector returns nil.

• Fixed crash in conversion of an Objective-C exception to a Python
  exception when the exception name is NULL.

• Type encoding that ends with an incomplete pointer definition will
  now raise an error earlier, in particular before the first time the
  callable is used.

• Using a value for the metadata dict of functions and selectors that
  is not a :class:dict now raises an exception instead of being silently
  ignored.

• The "suggestion" function metadata was ignored for :class:objc.function
  instances using the fast FFI variant.

• Deprecating the function returned by an API exposed through :class:objc.function
  would cause a crash.

• Fix value of the "deprecated" key in the result of __metadata__() for
  callables that are deprecated in a macOS version.

• Loading metadata for a function with more than 63 arguments would
  crash the interpreter.

  Note that calling such function is not supported even with this bugfix.

• #406: The "docstring" field in the function list argument for
  :func:objc.loadBundleFunctions was effectively ignored. It is now
  part of the document string (__doc__) of the :class:objc.function
  object.

• Actually implemented cyclic GC support in :class:objc.python_method.

• Fix crash when calling -[NSObject dealloc], -[NSObject retain]
  or -[NSObject release] though an :class:objc.IMP, for example:

  .. sourcecode:: python

  anObject = NSObject.alloc().init()
  retain = anObject.methodForSelector_("retain")
  retain(anObject)

• Tests in pyobjc-core better check the message of raised exceptions

  This resulted in some minor changes in messages, this should not affect
  code using PyObjC.

• Fix the __name__ and __repr__ result for the exact class
  :class:objc.objc_object.

• Fix use of uninitialized variable in the code that converts a C struct
  from Objective-C to a Python tuple.

• Added :func:PyObjCTools.TestSupport.no_autorelease_pool to disable
  autorelease pool management by the test runnner for a specific test.

• NSMutableArray.insert(idx, value) would fail when idx is beyond
  the length of the array. It now behaves the same as :meth:list.insert,
  the item will be appended to the array.

• Change the way type specific class methods are added to :class:objc.ivar.

  This changes the way class methods are added to :class:objc.ivar to
  be more correct in the CPython interpreter.

• #425: Fix CoreMIDI bindings

  The CoreMIDI is a wheel with a limited ABI tag, but one of the two
  extensions was build without using the limited ABI, resulting in a wheel
  that worked only for one python version.

v8.0

Backward incompatible changes

• In PyObjC 7 and earlier it was possible to leave out "output" arguments when
  calling a method with a Python implementation:

  .. sourcecode:: python

  class MyClass(NSObject):
  
      @objc.typedSelector(b"@@:o^@")
      def methodWithOutput_(self, a):
          return 1, 2
  
  
  o = MyClass.alloc().init()
  print(o.methodWithOutput_())
  

  This no longer works, it is always necessary to pass in all arguments, which
  was already true for methods implemented in Objective-C. That is:

  .. sourcecode:: python

  print(o.methodWithOutput_(None))

  This change both simplifies the PyObjC code base and was required to cleanly
  implement vectorcall support (see the section on performance below).

• Removed bindings for InterfaceBuilderKit. This was a way to integrate
  with InterfaceBuilder in old versions of Xcode, but support for that was
  dropped before the release of Mac OS X 10.8.

• Bindings for the Objective-C runtime API related to "associated objects" is
  now enabled unconditionally. This will cause problems when running or building
  on macOS 10.6 or earlier.

• It is no longer possible to deploy to macOS 10.7 or earlier when you attempt to
  create a formal protocol. Protocol creation already failed on those platform
  due to lack of the required runtime API, and that will now result in a crash
  because PyObjC no longer checks for availability of that runtime API.

• #371: Remove manual bindings for a number of old CoreGraphics APIs

  The following functions are no longer available:

  • CGDataProviderCreate

  • CGDataProviderCreateDirectAccess

  These functions were removed as a public API in macOS 10.8, but were still
  available through PyObjC through old backward compatibility code. That code has
  now been removed.

• For compatibility with Python's socket APIs functions that return a
  "struct sockaddr" (either by reference or as a function result) will now
  encode the IP address as a string and not a bytes object.

• The (undocumented) API in pyobjc-api.h (used in some framework bindings to
  integratie with pyobjc-core) has changed in an incompatible way, in particular
  the API for "caller" functions now mostly mirrors the vectorcall convention.

• Adding a method with a double underscore name will now raise an exception at
  class definition time instead of silently not creating the Objective-C method.

  .. sourcecode::

    class AClass (NSObject):
        ...
  
    def __foo_bar__(self, a, b, c):
        pass
  
    MethodNamesClass.__foo_bar__ = __foo_bar__
  

  Before PyObjC 8 this would add a __foo_bar__ selector to the Python
  representation of the class without adding a selector to the Objective-C class.

  Use :func:objc.python_method to mark this as a python-only function.

Upcoming incompatible changes

• The module :mod:PyObjCTools.Signals is deprecated and will be removed
  in PyObjC 9.

• :func:objc.initFrameworkWrapper and :func:objc.parseBridgeSupport
  are deprecated and will be removed in PyObjC 9.

  These functions implement support for ".bridgesupport" XML files,
  something that PyObjC hasn't used itself in a number of releases (in
  part because system versions of those files are at best incomplete).

Performance

Most performance changes use features introduced in Python 3.9, performance
in older Python versions is unchanged except for the effects of general cleanup.

• Implement the "vectorcall" protocol for :class:objc.function, :class:objc.WeakRef,
  :class:objc.selector, :class:objc.IMP, :class:objc.python_method.

  This reduces the interpreter overhead for calling instances of these objects.

• Implement Py_TPFLAGS_METHOD_DESCRIPTOR for :class:objc.selector,
  :class:objc.python_method.

• Use vectorcall in the method stub that forwards Objective-C calls to Python.

• Convert internal calls into Python to the vectorcall protocol (pyobjc-core)

• Add more optimized vectorcall implementation to :class:objc.function,
  :class:objc.IMP and :class:objc.selector for simpler callables.

  In the current version "simpole enough" callables have a 8 or fewer
  arguments, and none of those arguments are pass by reference. This will
  change over time.

Generic Implementation Quality

• #391: Fix some spelling errors found by the
  codespell <https://pypi.org/project/codespell/>_ tool.

  The codespell tool is also run as part of pre-commit hooks.

• #296: use clang-format for Objective-C code

  The Objective-C code for the various extensions has been reformatted
  using clang-format, and this enforced by a pre-commit hook.

• #374: Use pyupgrade to modernize the code base

  This is enforced by a pre-commit hook.

• #388: Added "nullability" attributes to Objectice-C sources for pyobjc-core.

  This gives the compiler and clang static analyzer more information
  that can be used to pinpoint possible bugs in the implementation. As a
  side effect of this a number of internal checks were strengthened, although
  most of them were for error conditions that should never happen.

  That said, this change also found a number of places where Python reference
  counts weren't updated properly, which may have led to refcount overflows
  in long running programs.

• Add more error checking to pyobjc-core to catch (very) unlikely error conditions.

  This is a side effect of the previous item.

New features

• Updated framework bindings for macOS 12

• New framework bindings for the following frameworks:

  • AudioVideoBridging (introduced in macOS 10.8)

  • DataDetection (introduced in macOS 12.0)

  • IntentsUI (introduced in macOS 12.0)

  • LocalAuthenticationEmbeddedUI (introduced in macOS 12.0)

  • MailKit (introduced in macOS 12.0)

  • MetricKit (introduced in macOS 12.0)

  • ShazamKit (introduced in macOS 12.0)

• #318: Implement support for __class_getitem__ for Objective-C classes

  The result of this is that effectively all Objective-C classes can be used
  as generic classes, without runtime type checking. This is meant to be used
  with optional type checking (for example MyPy)

  Usage:

  .. sourcecode:: python

    def create_integers(count: int) -> NSArray[int]:
        return NSArray[int].arrayWithArray_([i for i in range(count)])
  

  .. note::

  This requires typing stubs for framework bindings to be really useful,
  and those do not yet exist.

• #354: Add an option to install all framework bindings, including those not
  relevant for the current platform. To use this:

  .. sourcecode:: sh

  $ pip install 'pyobjc[allbindings]'

Other changes and bugfixes

• #390: pyobjc-core is no longer linked with the Carbon framework.

  Due to implicit dependencies this also required a change to the Metal
  bindings: those now import AppKit instead of Foundation.

• PyObjC only ships "Universal 2" wheels for Python 3.8 and later. Those work
  with single-architecture builds of Python as well.

• PyObjC 8 only ships with source archives and "univeral2" binary
  wheels (Python 3.? and later). There are no longer "x86_64" binary wheels.

• The AVFoundation bindings (in pyobjc-framework-AVFoundation) now have
  an install dependency on the CoreAudio bindings (pyobjc-framework-CoreAudio).

  This is needed for a new API introduced in macOS 12.

• #371: Link extensions in the Quartz bindings to the Quartz frameworks

  A number of C extensions in the Quartz bindings package were not
  linked to a framework. Those now link to the Quartz framework.

• #378: Fix raising ImportError when doing from ApplicationServices import *

  The root cause for this were private classes in system frameworks that contain
  a dot in their name (for example Swift.DispatchQueueShim. Those names are
  both private and invalid attribute names.

• Creating protocols that contain methods that have a method signature containing
  PyObjC custom type encodings now works (those encodings are translated to
  the corresponding Objective-C encoding.

• Fix bindings for SKIndexCopyDocumentRefsForDocumentIDs, that binding
  didn't work due to a typo in the metadata.

• #365: The PyObjCTools namespace package no longer has an __init__.py
  file in the source tree (that is, the tree switches to implicit namespace
  packages instead of the older setuptools style for namespace packages).

  This primarily affects testing with recent versions of pip/setuptools (which
  seem to no longer install the __init__.py file for namespace packages).

• development-support/run-testsuite now uses venv instead of
  virtualenv. This removes a development dependency.

• PR# 367: Tweak the code that calculates PyObjC_BUILD_RELEASE in
  the various setup.py files to deal with versions with more than two
  labels (can happen when building using Xcode 13 beta)

  PR by Eric Lin (Tzu Hsiang Lin), github user eric100lin.

• PyObjCTest.TestSupport now never uses "10.16" as the
  OS release but always uses the actual platform version, even
  when Python was compiled using an old SDK.

• Adjusted PyObjC testcases to check for 11.0 instead of 10.16
  now that testsupport uses the real platform version.

• #385: Fix race condition the lazy importer

  When two threads simultaneously try to get an attribute from a framework
  binding one of them might fail with an attribute error because information
  for resolving the name was removed before actually resolving the name.

• Fix various issues with invalid indices in :class:objc.varlist

• Fix support for AF_UNIX in the support code for struct sockaddr.

• The implementation for opaque poin...

PyObjC 7.3 (bug fix release)

With WWDC and beta of a new major release of macOS approaching fast it is high time to push out a new release for PyObjC. PyObjC 7.3 is primarily a bugfix release, with one minor feature.

I expect this to be the last release for PyObjC 7.x and will start working on PyObjC 8 soon.

• issue 356: Explicitly error out when building for unsupported architectures

  "python setup.py build" will now fail with a clear error when
  trying to build PyObjC for a CPU architecture that is no longer
  supported (such as 32-bit Intel)

• issue 319: Use memset instead of bzero in C code to clear memory

  Based on a PR by GitHub user stbdang.

• issue 348: Fix platform version guard for using protocols in MetalPerformanceShaders bindings

• issue 344: Fix test for CFMessagePortCreateLocal

  The tests didn't actually test calling the callback function
  for CFMessagePortCreateLocal.

• issue 349: Change calls to htonl in pyobjc-core to avoid compiler warning

  The original code had a 32-bit assumption (using 'long' to represent
  a 32-bit value), and that causes problems for some users build from
  source.

• issue 315: Fix binding for SecAddSharedWebCredential (Security framework)

  Trying to use this function will no longer crash Python.

• issue 357: Calling Metal.MTLCopyAllDevices() no longer crashes

  The reference count of the result of this function was handled incorrect,
  causing access to an already deallocated value when the Python reference
  was garbage collected.

• issue 260: Add manual bindings for AXValueCreate and AXValueGetValue in ApplicationServices

  Calling these crashed in previous versions.

• issue 320, 324: Fix the type encoding for a number of CoreFoundation types in the Security bindings

• issue 336: Add core support for "final" classes

  It is now possible to mark Objective-C classes as final,
  that is to disable subclassing for such classes.

  This is primarily meant to be used in framework bindings for
  matching Objective-C semantics.

The "final" feature adds two new APIs:

1. A keyword argument "final" when defining a new class

       class MyClass (NSObject, final=True):
           pass
   

2. An read-write attribute __objc_final__ on all subclasses of NSObject.

Note that this is a separate concept from typing.final.

v6.2.2

• #311: Build for the Metal bindings failed on macOS 10.14

• #309: Fix incompatibility with macOS 11 in framework loader

• Another attempt at giving a nice error message when trying to install on
  platforms other than macOS.

• The classifiers now correctly identify supported Python versions

v6.2.1

• Issue #299: Ensure package 'pyobjc' won't try to build the PubSub bindings on macOS 10.15

  Reported by Thomas Buchberger

• Minor tweaks to build and pass tests on macOS 10.14 with the latest Xcode
  that can be installed on that version of macOS.

• Issue #300: Fix SystemError in block edge case

  PyObjC raised a SystemError when converting a callable into
  an ObjC block when the callable is a bound method without
  positional arguments.

• Issue #275: Fix crash on catalina caused by writing to read-only memory.

  Patch by Dan Villiom Podlaski Christiansen

• PR #302: Make sure the SDK detection works when the version is not in the SDK name

  Patch by Joshua Root

• There were no SDK updates in Xcode 11.5 and Xcode 11.6 (beta)

v6.2

• The project has moved from Bitbucket to Github

• Remove most remnants of Python 2 support

• Clean up code quality issues found using flake8

• Add pre-commit hook to run black on all Python code.

• #290: Fix protocol conformance testing when explicitly implementing a protocol

  Before this bugfix a class explicitly conforming to a protocol could not
  implement any method that wasn't declared in the protocol, the bridge would
  erroneously raise an exception when checking the additional method.

  Issue reported by Georg Seifert.

• #289: Fix Python 3 issues in PyObjCTools.Conversion

  Reported by vinolin asokan.

• PyObjCTools.Conversio.propertyListFromPythonCollection didn't
  recursively convert members of lists and tuples.

• PyObjCTools.Conversio.propertyListFromPythonCollection and
  PyObjCTools.Conversio.pythonCollectionFromPropertyList now
  support sets.

• Update metadata for Xcode 11.4 (beta 2)

• Added bindings for framework AutomaticAssessmentConfiguration.framework
  introduced in macOS 10.15.4

• #298: In some cases the compiler uses the type encoding "^{NSObject=#}"
  instead of "@".

  Reported by Georg Seifert.

• #264: Added bindings for the Metal framework (new in macOS 10.11)

• Most framework bindings now use the limited ABI for the included C extensions,
  reducing the number of wheels that are needed. The exception are
  the bindings for Cocoa, Quartz and libdispatch, those use functionality not
  available in the limited ABI.

  The bridge itself (pyobjc-core) still uses the full CPython API.

  The CoreAudio bindings also don't use the limited ABI for now, those
  need more work to work with that ABI.

v6.1

• Updated for the macOS 10.15.1 SDK (Xcode 11.2)

• Fix reference counting in -[OC_PythonData length], which resulted
  in use-after-free.

• #281: Fix problems found in pyobjc-core by the clang static analyser

v6.0.1

• #277: Remove debug print accidently left in production

• #278: Surpress "-Wunguarded-availability" warnings in the extension
  AppKit._inlines