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.

PyObC 9.2 with some bugfixes

• #549: Added warning objc.ObjCSuperWarning that is used
  to warn about classes that use argument-less super without binding that
  name to objc.super.

  The correct code pattern is:

  from Foundation import NSObject
  from objc import super
  
  
  class MyObject(NSObject):
      def init(self):
          self = super().init()
          if self is None:
              return None
  
          ...
          return self

• #549: Document that objc.super must be used instead of
  builtin.super when calling superclass methods in a Cocoa subclass.

  See the documentation <(https://pyobjc.readthedocs.io/core/super.html>_
  for more details.

• #550: Add minimal pyproject.toml to all subprojects

  Recent versions of pip give a deprecation warning for projects without
  a pyproject.toml, and version 23.1 enabled the pyproject.toml
  backend by default. Add a minimal pyproject.toml to get a consistent
  build regardless of the version of pip

• #551: Fix crash in pyobjc-core when using Python 3.12a7.

• #449: Added explicit tests for dealing with Objective-C categories
  that are loaded while using classes from Python.

• #552: Fix the version of macOS where the SafariServices framework is
  present.

• #552: Fixed some issues found by testing on a macOS 10.11 system

• Trying to implement a method with SIMD types as arguments or return value
  will now give a more useful error when the bridge does not support the
  signature.

• #554: Fix incomplete metadata for CoreMediaIO.CMIOObjectSetPropertyData

• Fix incorrect metadata for
  xpc.xpc_uuid_create,
  xpc.xpc_dictionary_set_uuid ,
  xpc.xpc_array_set_uuid,
  JavaScriptCore.JSObjectMakeDeferredPromise,
  JavaScriptCore.JSValueIsEqual,
  JavaScriptCore.JSValueIsInstanceOfConstructor,
  JavaScriptCore.JSValueCreateJSONString,
  JavaScriptCore.JSValueToNumber,
  JavaScriptCore.JSValueToStringCopy,
  JavaScriptCore.JSValueToObject,
  Quartz.CGImageCreateWithJPEGDataProvider,
  Quartz.CGImageCreateWithPNGDataProvider,
  Quartz.CGImageMaskCreate,
  Quartz.CVBufferCopyAttachment,
  Quartz.CVMetalTextureCacheCreate,
  Quartz.CVMetalTextureCacheCreateFromImage,
  Quartz.CVOpenGLTextureCacheCreate,
  CoreMedia.CMAudioClockCreate,
  CoreMedia.CMAudioFormatDescriptionCreate,
  CoreMedia.CMBlockBufferGetDataPointer,
  CoreMedia.CMBlockBufferAccessDataBytes,
  CoreMedia.CMBlockBufferGetDataPointer,
  CoreMedia.CMAudioFormatDescriptionGetMostCompatibleFormat,
  CoreMedia.CMAudioFormatDescriptionGetRichestDecodableFormat,
  CoreMedia.CMSampleBufferCreateWithMakeDataReadyHandler,
  CoreMedia.CMSampleBufferCreateForImageBufferWithMakeDataReadyHandler,
  CFNetwork.CFNetServiceBrowserSearchForDomains,
  CFNetwork.CFNetServiceBrowserStopSearch,
  CFNetwork.CFNetServiceMonitorStop,
  CFNetwork.CFNetServiceRegister,
  CFNetwork.CFNetServiceResolve,
  CoreText.CTFontCreateCopyWithSymbolicTraits,
  CoreText.CTFontCreateCopyWithFamily,
  CoreText.CTFontCreateCopyWithAttributes,
  CoreMIDI.MIDISourceCreateWithProtocol,
  CoreMIDI.MIDISourceCreate,
  CoreMIDI.MIDISetupCreate,
  CoreMIDI.MIDIDestinationCreate,
  CoreMIDI.MIDIClientCreate,
  CoreMIDI.MIDIClientCreateWithBlock,
  CoreMIDI.MIDIOutputPortCreate,
  CoreMIDI.MIDIObjectGetStringProperty,
  CoreMIDI.MIDIObjectGetProperties,
  CoreMIDI.MIDIObjectGetIntegerProperty,
  CoreMIDI.MIDIObjectGetDictionaryProperty,
  CoreMIDI.MIDIObjectGetDataProperty,
  CoreMIDI.MIDIObjectFindByUniqueID,
  CoreMIDI.MIDIDestinationCreateWithProtocol,
  CoreMIDI.MIDIEndpointGetEntity,
  CoreMIDI.MIDIEntityGetDevice,
  CoreMIDI.MIDIEntityGetRefCons,
  CoreMIDI.MIDIEntitySetRefCons,
  DVDPlayback.DVDRegisterEventCallBack,
  DiskArbitration.DADiskMountWithArguments,
  GameController.NSDataFromGCExtendedGamepadSnapShotDataV100,
  HealthKit.HKAppleWalkingSteadinessClassificationForQuantity,
  IOSurface.IOSurfaceSetPurgeable,
  Network.nw_ethernet_channel_send,

• Removed Quartz.CGColorConversionInfoCreateFromListWithArguments. This function
  was already documented as unsupported, but was still present in the framework
  wrapper.

• Removed Quartz.CVPixelBufferCreateWithPlanarBytes. This function requires a
  manual binding, but was still present with a generic (and non-working) binding.

• Removed CoreMedia.CMBufferQueueCreate, CoreMedia.CMBufferQueueGetCallbacksForSampleBuffersSortedByOutputPTS,
  CoreMedia.CMBufferQueueGetCallbacksForUnsortedSampleBuffers, CoreMedia.CMVideoFormatDescriptionGetH264ParameterSetAtIndex,
  CoreMedia.CMVideoFormatDescriptionGetHVECParameterSetAtIndex,
  These functions require a manual binding, but were still present with a generic (and non-working) binding.

• Explicitly exclude definitions from CMIOHardwarePlugIn.h from the CoreMediaIO
  bindings.

• Added deref_result_pointer key to the metadata for a return value. Use this
  when a callable returns a pointer to a single value (for example CMAudioFormatDescriptionGetMostCompatibleFormat)

• Removed unsupported functions from the ApplicationServices bindings (not named individually
  due to the size of the list). Also fixed annotations for other ApplicationServices bindings.

• Add manual binding for CFNetwork.CFNetServiceBrowserCreate, CFNetwork.CFNetServiceSetClient,
  and CFNetwork.CFNetServiceMonitorCreate.

• Fix incompatibility with Python 3.12 beta 1.

  warning:

  Due to changes to the bytecode compiler the bridge will (incorrectly)
  deduce that a method does not return a value (void return in Objective-C)
  when a method only contains return None statements and no return
  statements that return some other value (expressions or constants).

  That is the following method is implied to return id for Python 3.11 or
  earlier, but is implied to return void in Python 3.12.

      def mymethod(self):
          return None

v8.5.1: Minor tweaks

This release contains a small number of bug fixes, most import of which is support for Python 3.11

v8.5

This release continues the work on test coverage in pyobjc-core,
resulting in a number of minor bug fixes.

• Added two options to the build_ext command in the setup.py
  of pyobjc-core:

  • --no-lto: Disable link time optimization

  • --no-warnings-as-errors: Disable -Werror

• For struct bindings in frameworks the "in" operator no longer
  swallows exceptions raised by the __eq__ method.

• Improved handing of invalid type encodings for struct types.

• Fix crash while handling a struct wrapper with an invalid
  type encoding.

• Fix handling of empty structs (such as struct foo { }; in
  :func:objc.repythonify.

• The type for NSObject.pyobjc_instanceMethod and
  NSObject.pyobjc_classMethods now supports the GC protocol
  to avoid garbage collection issues when the value for these
  properties is stored as an attribute (which introduces a
  reference cycle)

• PyObjC should work with Python 3.11 alpha release, starting
  at alpha 6. Earlier alpha's are not supported due to reverting
  a workaround for a bug that was fixed in alpha 6.

• NSObject.alloc = 42 now fails. It was already impossible
  to replace a selector by something else through instances
  (NSObject.new().description = 42 raises).

• Added :data:objc.ObjCPointer.typestr with the same
  value as :data:objc.ObjCPonter.type. The latter is now
  deprecated and will be removed in PyObjC 9.

• Better error messages when a class implementing a protocol
  inherits a method of the wrong kind ("class" vs. "instance").

• The value of __slots__ in a class definition is now
  kept in the created class (previous versions always set
  the attribute to an empty tuple).

  This is primarily useful when __slots__ is a :class:dict
  that is used to document attributes.

• Raise the correct exception when the name of a method is
  not an ASCII string.

• :func:objc.loadSpecialVar now better enforces that the
  module_globals argument is a Python dictionary.

• Fixed a crash in :func:objc.loadSpecialVar due to a
  missing pointer dereference.

• pip install pyobjc-framework-... for a framework
  that is not present on the current machine will now
  give a better error message when the "wheel" package
  is not installed.

• Setting an integer option in :data:objc.options to
  a value of an incompatible type (such as a string) will
  now raise an exception as intended, instead of breaking
  the interpreter.

• Trying to delete an attribute from :data:objc.options
  now raises :type:AttributeError instead of :type:TypeError.

• :class:objc.selector now copies the default signature
  from its argument when that argument is another :class:objc.selector.

  Until now this would raise an exception.

• Added some missing error checking in calls to :c:func:PyObject_New
  and :c:func:PyObject_GC_New.

• It is now possible to create an :class:objc.selector from
  a callable that is not a function or bound method. This may
  require specifying the method signature in the call
  to :class:objc.selector.

• For pyobjc-core the build_ext command in setup.py
  now includes the command-line option from the standaard
  command, which means python setup.py build_ext -j 4
  can now be used for parallel builds.

  On my M1 laptop using python setup.py build_ext -j 8
  halves the time needed to build the extension.

• The test command setup.py now supports
  the -v option to print test cases while they are run,
  in previoius versions this required using the --verbosity
  option.

• Improve error handling when dealing with "isHidden" selectors.

• Added pyobjc_hiddenSelectors(classmethods) to :class:objc.objc_class

  This method returns a copy of the dictionary with "hidden" selectors,
  that is Objective-C selectors that are hidden from view.

  The method is primarily a debugging aid for development of
  PyObjC itself.

• #456: ApplicationServices.AXIsProcessTrustedWithOptions and
  Quartrz.CGPDFArrayGetObject had incorrect metadata.

  The testsuites for the various framework bindings now have a test
  that does some basic checks on function and selector metadata. This
  test found the problem with CGPDFArrayGetObject.

• Added :data:objc._C_ATOMIC and :data:objc._C_COMPLEX, both
  extracted from the clang sources after finding some type encodings
  that PyObjC could not decode.

  :data:objc._C_ATOMIC is ignored by PyObjC (for now), and
  :data:objc._C_COMPLEX is not yet supported.

• #456: Fix internal error for _C_OUT argument markup on
  arguments that are CoreFoundation types.

  This can only happen with invalid metadata definitions in framework
  bindings, and earlier versions this resulted in an internal
  assertion error. With this change the "output" argument is always
  None in the result.

• #463: Fix metadata for a number of functions with a C string argument

  The metadata for the following functions was changed to have
  the correct type encoding for string argument, to fix issues with
  using non-ASCII (byte) strings.

  • ApplicationServices.PMWorkflowSubmitPDFWithOptions
  • CoreServices.LocaleRefGetPartString
  • Foundation.NSGetSizeAndAlignment
  • Network.nw_advertise_descriptor_create_bonjour_service
  • Network.nw_browse_descriptor_create_bonjour_service
  • Network.nw_browse_descriptor_get_bonjour_service_domain
  • Network.nw_browse_descriptor_get_bonjour_service_type
  • Network.nw_connection_copy_description
  • Network.nw_content_context_create
  • Network.nw_content_context_get_identifier
  • Network.nw_endpoint_copy_address_string
  • Network.nw_endpoint_copy_port_string
  • Network.nw_endpoint_create_bonjour_service
  • Network.nw_endpoint_create_host
  • Network.nw_endpoint_create_url
  • Network.nw_endpoint_get_bonjour_service_domain
  • Network.nw_endpoint_get_bonjour_service_name
  • Network.nw_endpoint_get_bonjour_service_type
  • Network.nw_endpoint_get_hostname
  • Network.nw_framer_create_definition
  • Network.nw_framer_message_access_value
  • Network.nw_framer_message_copy_object_value
  • Network.nw_framer_message_set_object_value
  • Network.nw_framer_message_set_value
  • Network.nw_framer_options_set_object_value
  • Network.nw_listener_create_with_port
  • Network.nw_privacy_context_create
  • Network.nw_quic_get_application_error_reason
  • Network.nw_quic_set_application_error
  • Network.nw_txt_record_access_key
  • Network.nw_ws_options_add_additional_header
  • Network.nw_ws_options_add_subprotocol
  • Quartz.CGContextSelectFont
  • Quartz.CGContextShowText
  • Quartz.CGContextShowTextAtPoint
  • Quartz.CGDataProviderCreateWithFilename
  • Quartz.CGPDFArrayGetName
  • Quartz.CGPDFContentStreamGetResource
  • Quartz.CGPDFDictionaryGetArray
  • Quartz.CGPDFDictionaryGetBoolean
  • Quartz.CGPDFDictionaryGetName
  • Quartz.CGPDFDocumentUnlockWithPassword
  • Quartz.CGPDFScannerPopName
  • Quartz.CGPDFTagTypeGetName

  While fixing this issue I found problems with the metadata for these functions:

  • CoreMIDI.MIDIExternalDeviceCreate
  • CoreMedia.CMBlockBufferAccessDataBytes
  • CoreMedia.CMBlockBufferGetDataPointer
  • CoreMedia.CMBufferQueueInstallTriggerHandler
  • CoreMedia.CMBufferQueueInstallTriggerHandlerWithIntegerThreshold
  • CoreMedia.CMTextFormatDescriptionGetJustification
  • CoreServices.TECGetTextEncodingFromInternetNameOrMIB
  • DVDPlayback.DVDGetScanRate
  • MediaAccessibility.MACaptionAppearanceAddSelectedLanguage

  There's also a new test that checks for this problem in all
  exposed functions.

• Fix incorrect reset of the "inline_list" attribute of the lazy importer,
  this could result in an incorrect TypeError when trying to access
  an non-existing attribute after looking at __all__.

• Fix uniqueness of symbols exposed in the OpenDirectory bindings.

• Unhide manual bindings for Security.SecKeychainFindGenericPassword and
  Security.SecKeychainFindInternetPassword.

Bugfix release

This is a bug fix release.

• #455: pip install pyobjc on a macOS 12.2 machine tried
  to install pyobjc-framework-ScreenCaptureKit, which is
  only can be installed on macOS 12.3 or later.

• #456: Fix bad metadata for HIServices.AXIsProcessTrustedWithOptions

• Wheels were build with Xcode 13.3 RC

  There are no changes in framework bindings relative to
  PyObjC 8.4 because there are no relevant API changes in
  Xcode 13.3 RC.

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.