pyobjc-core 10.0__tar.gz → 10.2__tar.gz

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/PyObjCTools/TestSupport.py

@@ -276,7 +276,7 @@ def min_os_level(release):
     """
     return _unittest.skipUnless(
         os_level_key(os_release()) >= os_level_key(release),
-        f"Requires OSX {release} or later",
+        f"Requires macOS {release} or later",
     )
 
 
@@ -292,7 +292,7 @@ def max_os_level(release):
     """
     return _unittest.skipUnless(
         os_level_key(os_release()) <= os_level_key(release),
-        f"Requires OSX up to {release}",
+        f"Requires macOS up to {release}",
     )
 
 
@@ -310,13 +310,13 @@ def os_level_between(min_release, max_release):
         os_level_key(min_release)
         <= os_level_key(os_release())
         <= os_level_key(max_release),
-        f"Requires OSX {min_release} up to {max_release}",
+        f"Requires macOS {min_release} up to {max_release}",
     )
 
 
 _poolclass = objc.lookUpClass("NSAutoreleasePool")
 
-# NOTE: On at least OSX 10.8 there are multiple proxy classes for CFTypeRef...
+# NOTE: On at least macOS 10.8 there are multiple proxy classes for CFTypeRef...
 _nscftype = tuple(cls for cls in objc.getClassList(1) if "NSCFType" in cls.__name__)
 
 _typealias = {}
@@ -1199,7 +1199,6 @@ class TestCase(_unittest.TestCase):
                                 "c_array_delimited_by_null",
                                 "c_array_of_variable_length",
                                 "c_array_length_in_arg",
-                                "c_array_delimited_by_null",
                                 "c_array_size_in_arg",
                             }
                         ):
@@ -1230,13 +1229,16 @@ class TestCase(_unittest.TestCase):
                 )
 
         if exclude_cocoa:
-            import Cocoa
+            try:
+                import Cocoa
 
-            exclude_names = set(dir(Cocoa))
+                exclude_names = set(dir(Cocoa))
 
-            # Don't exclude NSObject' because a number
-            # of frameworks define categories on this class.
-            exclude_names -= {"NSObject"}
+                # Don't exclude NSObject' because a number
+                # of frameworks define categories on this class.
+                exclude_names -= {"NSObject"}
+            except ImportError:
+                exclude_names = set()
         else:
             exclude_names = set()
 
@@ -1291,6 +1293,24 @@ class TestCase(_unittest.TestCase):
             )
         )
 
+        # Two (private) classes that end up being found in
+        # test runs on macOS 10.12 and 10.13
+        exclude_attrs.add("ABCDContact_ABCDContact_")
+        exclude_attrs.add("ABCDGroup_ABCDGroup_")
+
+        # Some bindings in CoreAudio with false positives
+        exclude_attrs.add("AudioHardwareClaimAudioDeviceID")
+        exclude_attrs.add("AudioHardwareClaimAudioStreamID")
+        exclude_attrs.add("AudioHardwareDevicePropertyChanged")
+        exclude_attrs.add("AudioHardwareDevicesCreated")
+        exclude_attrs.add("AudioHardwareDevicesDied")
+        exclude_attrs.add("AudioHardwareStreamPropertyChanged")
+        exclude_attrs.add("AudioHardwareStreamsCreated")
+        exclude_attrs.add("AudioHardwareStreamsDied")
+        exclude_attrs.add("AudioObjectCreate")
+        exclude_attrs.add("AudioObjectPropertiesChanged")
+        exclude_attrs.add("AudioObjectsPublishedAndDied")
+
         # Calculate all (interesting) names in the module. This pokes into
         # the implementation details of objc.ObjCLazyModule to avoid loading
         # all attributes (which is expensive for larger bindings).
@@ -1364,7 +1384,6 @@ class TestCase(_unittest.TestCase):
                             self._validateCallableMetadata(
                                 attr, nm, skip_simple_charptr_check=not exclude_cocoa
                             )
-
             elif isinstance(value, objc.function):
                 with self.subTest(function=nm):
                     self._validateCallableMetadata(value)
@@ -1387,6 +1406,13 @@ class TestCase(_unittest.TestCase):
         Run the test, same as unittest.TestCase.run, but every test is
         run with a fresh autorelease pool.
         """
+        try:
+            cls = objc.lookUpClass("NSApplication")
+        except objc.error:
+            pass
+        else:
+            cls.sharedApplication()
+
         if _usepool and not self._skip_usepool:
             p = _poolclass.alloc().init()
         else:

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/objc/_bridges.py

@@ -1,5 +1,6 @@
 import collections.abc
 import datetime
+import pathlib
 
 from objc import _objc
 
@@ -8,6 +9,7 @@ __all__ = [
     "registerMappingType",
     "registerSetType",
     "registerDateType",
+    "registerPathType",
 ]
 
 _objc.options._datetime_date_type = datetime.date
@@ -58,6 +60,17 @@ def registerDateType(type_object):
     _objc.options._date_types += (type_object,)
 
 
+def registerPathType(type_object):
+    """
+    Register 'type' as a date-like type that will be proxied
+    as an NSDate subclass.
+    """
+    if _objc.options._path_types is None:
+        _objc.options._path_types = ()
+
+    _objc.options._path_types += (type_object,)
+
+
 registerListType(collections.abc.Sequence)
 registerListType(range)
 registerMappingType(collections.abc.Mapping)
@@ -67,3 +80,4 @@ registerSetType(frozenset)
 registerSetType(collections.abc.Set)
 registerDateType(datetime.date)
 registerDateType(datetime.datetime)
+registerPathType(pathlib.Path)

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/objc/_properties.py

@@ -248,7 +248,7 @@ class object_property:
             )
             signature = _C_NSBOOL + b"@:N^@o^@"
             validate = selector(self._validate, selector=selName, signature=signature)
-            class_dict[validate.selector] = validate
+            class_dict[validate.selector.decode().replace(":", "_")] = validate
             instance_methods.add(validate)
 
         if self._depends_on:
@@ -266,7 +266,7 @@ class object_property:
                 signature=b"@@:",
                 isClassMethod=True,
             )
-            class_dict[affecting.selector] = affecting
+            class_dict[affecting.selector.decode().replace(":", "_")] = affecting
             class_methods.add(affecting)
 
     def __get__(self, an_object, owner):

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/objc/_protocols.py

@@ -25,7 +25,7 @@ def protocolNamed(name):
         PROTOCOL_CACHE.setdefault(pname, p)
         if pname == name:
             return p
-    for cls in _objc.getClassList(1):
+    for cls in _objc.getClassList(True):
         for p in _objc.protocolsForClass(cls):
             pname = p.__name__
             PROTOCOL_CACHE.setdefault(pname, p)

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/objc/_pycoder.py

@@ -493,10 +493,10 @@ def load_reduce(coder, setValue):
 
         for k in state:
             v = state[k]
-            if type(k) == objc.pyobjc_unicode:
+            if type(k) is objc.pyobjc_unicode:
                 inst_dict[intern(k)] = v
 
-            elif type(k) == str:
+            elif type(k) is str:
                 inst_dict[intern(k)] = v
 
             else:

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/objc/_transform.py

@@ -497,7 +497,7 @@ def transformAttribute(name, value, class_object, protocols):
     for cls in class_object.mro():  # pragma: no branch
         if not issubclass(cls, objc.objc_object):
             # Skip all non-objc class in the MRO to ignore
-            # mixin classees.
+            # mixin classes.
             continue
         if selname in cls.pyobjc_hiddenSelectors(isclass):
             ishidden = True

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/pyobjc_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyobjc-core
-Version: 10.0
+Version: 10.2
 Summary: Python<->ObjC Interoperability Module
 Home-page: https://github.com/ronaldoussoren/pyobjc
 Author: Ronald Oussoren, bbum, SteveM, LeleG, many others stretching back through the reaches of time...
@@ -25,6 +25,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Objective C
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

{pyobjc-core-10.0 → pyobjc-core-10.2}/Lib/pyobjc_core.egg-info/SOURCES.txt

@@ -110,6 +110,8 @@ Modules/objc/OC_PythonObject.h
 Modules/objc/OC_PythonObject.m
 Modules/objc/OC_PythonSet.h
 Modules/objc/OC_PythonSet.m
+Modules/objc/OC_PythonURL.h
+Modules/objc/OC_PythonURL.m
 Modules/objc/OC_PythonUnicode.h
 Modules/objc/OC_PythonUnicode.m
 Modules/objc/ObjCPointer.h
@@ -472,6 +474,7 @@ PyObjCTest/test_transform.py
 PyObjCTest/test_transform_integration.py
 PyObjCTest/test_typecheck.py
 PyObjCTest/test_unicode.py
+PyObjCTest/test_urlproxy.py
 PyObjCTest/test_usekvo.py
 PyObjCTest/test_varargs.py
 PyObjCTest/test_varlist.py

{pyobjc-core-10.0 → pyobjc-core-10.2}/License.txt

@@ -1,7 +1,7 @@
 (This is the MIT license, note that libffi-src is a separate product with its own license)
 
 Copyright 2002, 2003 - Bill Bumgarner, Ronald Oussoren, Steve Majewski, Lele Gaifax, et.al.
-Copyright 2003-2022 - Ronald Oussoren
+Copyright 2003-2024 - Ronald Oussoren
 
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/OC_PythonArray.m

@@ -622,6 +622,9 @@ NS_ASSUME_NONNULL_BEGIN
     }
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+
 - (id)copyWithZone:(NSZone* _Nullable)zone
 {
     if (PyObjC_CopyFunc && PyObjC_CopyFunc != Py_None) {
@@ -651,6 +654,7 @@ NS_ASSUME_NONNULL_BEGIN
     }
 }
 
+
 - (id)mutableCopyWithZone:(NSZone* _Nullable)zone
 {
     NSObject* result;
@@ -672,6 +676,7 @@ NS_ASSUME_NONNULL_BEGIN
     [result retain];
     return result;
 }
+#pragma clang diagnostic pop
 
 + (NSArray*)classFallbacksForKeyedArchiver
 {

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/OC_PythonDictionary.m

@@ -570,6 +570,8 @@ PyObjC_FINAL_CLASS @interface OC_PythonDictionaryEnumerator : NSEnumerator {
     }
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
 - (id)mutableCopyWithZone:(NSZone* _Nullable)zone
 {
     NSObject* result;
@@ -600,6 +602,7 @@ PyObjC_FINAL_CLASS @interface OC_PythonDictionaryEnumerator : NSEnumerator {
     [result retain];
     return result;
 }
+#pragma clang diagnostic pop
 
 @end /* interface OC_PythonDictionary */
 

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/OC_PythonNumber.m

@@ -123,7 +123,15 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (BOOL)boolValue
 {
-    return (BOOL)PyObject_IsTrue(value);
+    int         r;
+    PyObjC_BEGIN_WITH_GIL
+        r = PyObject_IsTrue(value);
+        if (r == -1) {
+            PyObjC_GIL_FORWARD_EXC();
+        }
+    PyObjC_END_WITH_GIL
+
+    return !!r;
 }
 
 - (char)charValue
@@ -209,12 +217,19 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (long long)longLongValue
+  /* Disable float-cast-overflow checking when running
+   * with undefined behaviour sanitizer. The float cast
+   * below can result in undefined behaviour but is
+   * necessary to match Cocoa semantics.
+   */
+  __attribute__((no_sanitize("float-cast-overflow")))
 {
     long long result;
 
     PyObjC_BEGIN_WITH_GIL
         if (PyFloat_Check(value)) {
-            result = (long long)PyFloat_AsDouble(value);
+            double float_result = PyFloat_AsDouble(value);
+            result = (long long)float_result;
             PyObjC_GIL_RETURN(result);
         } else if (PyLong_Check(value)) {
             result = PyLong_AsUnsignedLongLongMask(value);
@@ -231,6 +246,12 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (unsigned long long)unsignedLongLongValue
+  /* Disable float-cast-overflow checking when running
+   * with undefined behaviour sanitizer. The float cast
+   * below can result in undefined behaviour but is
+   * necessary to match Cocoa semantics.
+   */
+  __attribute__((no_sanitize("float-cast-overflow")))
 {
     unsigned long long result;
 

pyobjc-core-10.2/Modules/objc/OC_PythonURL.h

@@ -0,0 +1,14 @@
+NS_ASSUME_NONNULL_BEGIN
+
+PyObjC_FINAL_CLASS
+@interface OC_PythonURL : NSURL {
+    PyObject* value;
+}
+
++ (instancetype _Nullable)URLWithPythonObject:(PyObject*)value;
+- (id _Nullable)initWithPythonObject:(PyObject*)value;
+- (PyObject*)__pyobjc_PythonObject__;
+
+@end
+
+NS_ASSUME_NONNULL_END

pyobjc-core-10.2/Modules/objc/OC_PythonURL.m

@@ -0,0 +1,128 @@
+#include "pyobjc.h"
+NS_ASSUME_NONNULL_BEGIN
+
+@implementation OC_PythonURL
+
++ (instancetype _Nullable)URLWithPythonObject:(PyObject*)object
+{
+    return [[[self alloc] initWithPythonObject:object] autorelease];
+}
+
+- (id _Nullable)initWithPythonObject:(PyObject*)object
+{
+    PyObject* fspath = PyOS_FSPath(object);
+    if (fspath == NULL) {
+        return nil;
+    }
+    if (!PyUnicode_Check(fspath)) {
+        Py_DECREF(fspath);
+        PyErr_Format(PyExc_ValueError, "os.fspath(%R) did not return a string", object);
+        return nil;
+    }
+
+    const char* utf8;
+    Py_ssize_t utf8_size;
+
+    utf8 = PyUnicode_AsUTF8AndSize(fspath, &utf8_size);
+    if (utf8 == NULL) {
+        Py_DECREF(fspath);
+        return nil;
+    }
+    if (utf8_size != (Py_ssize_t)strlen(utf8)) {
+        Py_DECREF(fspath);
+        PyErr_Format(PyExc_ValueError, "os.fspath(%R) result has embedded NULs", object);
+        return nil;
+    }
+
+    NSString* path = [[NSString alloc] initWithUTF8String:utf8];
+    Py_DECREF(fspath);
+    if (path == nil) {
+        return nil;
+    }
+
+    self = [super initFileURLWithPath:path];
+    [path release];
+    if (self == nil) {
+        return nil;
+    }
+
+    SET_FIELD_INCREF(value, object);
+    return self;
+}
+
+- (oneway void)release
+{
+    /* See comment in OC_PythonUnicode */
+    if (unlikely(!Py_IsInitialized())) { // LCOV_BR_EXCL_LINE
+        // LCOV_EXCL_START
+        [super release];
+        return;
+        // LCOV_EXCL_STOP
+    }
+
+    PyObjC_BEGIN_WITH_GIL
+        @try {
+            [super release];
+            // LCOV_EXCL_START
+        } @catch (NSObject* exc) {
+            /* I'm 99% sure this path cannot be hit,
+             * this class cannot be subclassesed and
+             * -dealloc cannot raise.
+             */
+            PyObjC_LEAVE_GIL;
+            @throw;
+        }
+        // LCOV_EXCL_STOP
+
+    PyObjC_END_WITH_GIL
+}
+
+- (void)dealloc
+{
+    if (unlikely(!Py_IsInitialized())) { // LCOV_BR_EXCL_LINE
+        // LCOV_EXCL_START
+        [super dealloc];
+        return;
+        // LCOV_EXCL_STOP
+    }
+
+    PyObjC_BEGIN_WITH_GIL
+        Py_XDECREF(value);
+    PyObjC_END_WITH_GIL
+
+    [super dealloc];
+}
+
+/*
+ * NSURL implements safe coding, that's something we cannot
+ * do for arbitrary python objects. Therefore punt and encode
+ * as a regular NSURL.
+ */
+- (Class)classForCoder
+{
+    return [NSURL class];
+}
+
+- (Class _Nullable)classForKeyedArchiver
+{
+    return [NSURL class];
+}
+
+
+- (PyObject*)__pyobjc_PythonObject__
+{
+    Py_XINCREF(value);
+    return value;
+}
+
+- (PyObject*)__pyobjc_PythonTransient__:(int*)cookie
+{
+    *cookie = 0;
+    Py_XINCREF(value);
+    return value;
+}
+@end
+
+
+
+NS_ASSUME_NONNULL_END

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/OC_PythonUnicode.m

@@ -180,12 +180,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)getCharacters:(unichar*)buffer range:(NSRange)aRange
 {
-    return [[self __realObject__] getCharacters:buffer range:aRange];
+    [[self __realObject__] getCharacters:buffer range:aRange];
 }
 
 - (void)getCharacters:(unichar*)buffer
 {
-    return [[self __realObject__] getCharacters:buffer];
+    [[self __realObject__] getCharacters:buffer];
 }
 
 /*

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/block_support.m

@@ -385,7 +385,7 @@ error:
 static void
 PyObjCBlock_CleanupCapsule(PyObject* ptr)
 {
-    void* block_func = PyCapsule_GetPointer(ptr, "objc.__block_release__");
+    PyObjCBlockFunction block_func = (PyObjCBlockFunction)PyCapsule_GetPointer(ptr, "objc.__block_release__");
     if (block_func == NULL)
         return;
 
@@ -458,7 +458,7 @@ void* _Nullable PyObjCBlock_Create(PyObjCMethodSignature* signature, PyObject* c
     }
     block->invoke = block_func;
 
-    block->invoke_cleanup = PyCapsule_New(block->invoke, "objc.__block_release__",
+    block->invoke_cleanup = PyCapsule_New((void*)(block->invoke), "objc.__block_release__",
                                           PyObjCBlock_CleanupCapsule);
     if (block->invoke_cleanup == NULL) {            // LCOV_BR_EXCL_LINE
         PyObjCFFI_FreeBlockFunction(block->invoke); // LCOV_EXCL_LINE

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/bundle-variables.m

@@ -387,7 +387,7 @@ PyObject* _Nullable PyObjC_loadFunctionList(PyObject* self __attribute__((__unus
     len = PySequence_Fast_GET_SIZE(seq);
     for (i = 0; i < len; i++) {
         PyObject* item = PySequence_Fast_GET_ITEM(seq, i);
-        void*     value;
+        function  value;
         char*     signature;
         PyObject* name;
         PyObject* doc;
@@ -417,7 +417,7 @@ PyObject* _Nullable PyObjC_loadFunctionList(PyObject* self __attribute__((__unus
             }
 
         } else {
-            PyObject* py_val = PyObjCFunc_New(name, value, signature, doc, meta);
+            PyObject* py_val = PyObjCFunc_New(name, (void*)value, signature, doc, meta);
             if (py_val == NULL) {
                 Py_DECREF(seq);
                 return NULL;

{pyobjc-core-10.0 → pyobjc-core-10.2}/Modules/objc/class-builder.m

@@ -749,13 +749,13 @@ object_method_dealloc(ffi_cif* cif __attribute__((__unused__)),
                     PyObject* args[2] = {NULL, s};
                     obj               = PyObject_Vectorcall(delmethod, args + 1,
                                                             1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
-                    _PyObjCObject_FreeDeallocHelper(s);
                     if (obj == NULL) {
                         PyErr_WriteUnraisable(delmethod);
                     } else {
                         Py_DECREF(obj);
                     }
                     Py_DECREF(delmethod);
+                    _PyObjCObject_FreeDeallocHelper(s);
                 }
             }
 
@@ -995,7 +995,7 @@ object_method_valueForKey_(ffi_cif* cif __attribute__((__unused__)), void* retva
         /* Parent doesn't know the key, try to create in the
          * python side, just like for plain python objects.
          *
-         * NOTE: We have to be extermely careful in here, some classes,
+         * NOTE: We have to be extremely careful in here, some classes,
          * like NSManagedContext convert __getattr__ into a -valueForKey:,
          * and that can cause infinite loops.
          *