Skip to content

Releases: ronaldoussoren/pyobjc

v10.3.1

11 Jun 07:38
Compare
Choose a tag to compare
  • #610: Ensure __init__ can be used when user implements __new__.

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

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

v10.3

28 May 06:03
Compare
Choose a tag to compare
  • 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

28 May 06:00
Compare
Choose a tag to compare
  • 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

09 Dec 08:56
Compare
Choose a tag to compare
  • 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

09 Dec 08:55
Compare
Choose a tag to compare
  • 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

07 Jun 07:24
Compare
Choose a tag to compare
  • #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

24 Sep 10:38
Compare
Choose a tag to compare

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

v8.5

19 Apr 13:06
Compare
Choose a tag to compare

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

15 Mar 11:59
Compare
Choose a tag to compare

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

07 Mar 21:42
Compare
Choose a tag to compare
  • 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.