Pyobjc

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

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.

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.

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 pointer types (such as the proxy for
'NSZone*') has switched to :c:func:`PyType_FromSpec`.

* The :meth:`objc.FSRef.from_path` and :meth:`objc.FSRef.as_pathname`,
methods now use the filesystem encoding instead of the default encoding.
C string. This shouldn't affect any code, both encoding default to UTF-8 on macOS.

* Inheriting directly from :class:`objc.objc_object` now raises :class:`TypeError`
instead of :class:`objc.InternalError`. User code should always inherit from
a Cocoa class.

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

* 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