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

{pyobjc-core-10.2 → pyobjc_core-11.0}/Examples/GUITests/test_modalsession.py

@@ -4,6 +4,7 @@ Check if NSModalSessions are properly wrapped.
 NOTE: This is not a proper unittest, it requires human eyes to check if the
 output is correct.
 """
+
 import time
 
 from Cocoa import (

{pyobjc-core-10.2 → pyobjc_core-11.0}/Examples/NonFunctional/RemotePyInterpreter/setup.py

@@ -4,6 +4,7 @@ Script for building the example.
 Usage:
     python3 setup.py py2app
 """
+
 from setuptools import setup
 
 plist = {

{pyobjc-core-10.2 → pyobjc_core-11.0}/Examples/Scripts/instrumentSends.py

@@ -6,6 +6,7 @@ It sometimes is useful to see which Objective-C methods are called in a
 program. Luckily the Objective-C runtime contains a private API for logging
 all method calls. This file shows how to call that API.
 """
+
 import Foundation
 import objc
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/PyObjCTools/KeyValueCoding.py

@@ -29,10 +29,8 @@ weaker coupling between the view and model layers.
 import collections.abc
 import types
 
-import objc
 
 __all__ = ("getKey", "setKey", "getKeyPath", "setKeyPath")
-_null = objc.lookUpClass("NSNull").null()
 
 
 def keyCaps(s):
@@ -382,3 +380,13 @@ class kvc:
         if not isinstance(item, str):
             raise TypeError("Keys must be strings")
         setKeyPath(self.__pyobjc_object__, item, value)
+
+
+# The import of 'objc' is at the end of the module
+# to avoid problems when importing this module before
+# importing objc due to the objc package importing bits
+# of this module.
+
+import objc  # noqa: E402
+
+_null = objc.lookUpClass("NSNull").null()

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

@@ -803,7 +803,8 @@ class TestCase(_unittest.TestCase):
         if st is None:
             self.fail(
                 message
-                or "arg %d of %s is not of type block: no callable" % (argno, method)
+                or "arg %d of %s: no callable specified for the block signature"
+                % (argno, method)
             )
 
         try:
@@ -848,7 +849,8 @@ class TestCase(_unittest.TestCase):
         if st is None:
             self.fail(
                 message
-                or "result of %s is not of type block: no callable specified" % (method)
+                or "result of %s: no callable specified for the block signature"
+                % (method)
             )
 
         try:
@@ -1105,6 +1107,23 @@ class TestCase(_unittest.TestCase):
         self.assertEqual(clone, value)
         self.assertIsInstance(clone, type(value))
 
+    def assertFreeThreadedIfConfigured(self):
+        """
+        Assert that the process is running in free-threaded mode when
+        the interpreter was configured as such.
+        """
+
+        if not _get_config_var("Py_GIL_DISABLED"):
+            # Not a free threaded build
+            return
+
+        if "gil" in _sys._xoptions and _sys._xoptions["gil"]:
+            # User runs with '-Xgil=1'
+            return
+
+        # Check that the GIL is actually disabled
+        self.assertFalse(_sys._is_gil_enabled(), "GIL is enabled")
+
     def _validateCallableMetadata(
         self, value, class_name=None, skip_simple_charptr_check=False
     ):
@@ -1207,6 +1226,14 @@ class TestCase(_unittest.TestCase):
                         f"{value}: {idx}: pointer argument, but no by-ref annotation:{tp!r} {class_name or ''}"
                     )
 
+    def _validateBundleIdentifier(self, module):
+        if hasattr(module, "__bundle__"):
+            self.assertHasAttr(module, "__framework_identifier__")
+            self.assertEqual(
+                module.__bundle__.bundleIdentifier(),
+                module.__framework_identifier__,
+            )
+
     def assertCallableMetadataIsSane(
         self, module, *, exclude_cocoa=True, exclude_attrs=()
     ):
@@ -1220,13 +1247,8 @@ class TestCase(_unittest.TestCase):
         # XXX: exclude_cocoa may exclude too much depending on
         #      import order.
 
-        if hasattr(module, "__bundle__"):
-            with self.subTest("validate framework identifier"):
-                self.assertHasAttr(module, "__framework_identifier__")
-                self.assertEqual(
-                    module.__bundle__.bundleIdentifier(),
-                    module.__framework_identifier__,
-                )
+        with self.subTest("validate framework identifier"):
+            self._validateBundleIdentifier(module)
 
         if exclude_cocoa:
             try:
@@ -1391,6 +1413,10 @@ class TestCase(_unittest.TestCase):
             else:
                 continue
 
+        # Quick check that the GIL is actually disabled.  Testing this here isn't
+        # ideal, but avoids changing all framework bindings.
+        self.assertFreeThreadedIfConfigured()
+
     def __init__(self, methodName="runTest"):
         super().__init__(methodName)
 
@@ -1408,8 +1434,8 @@ class TestCase(_unittest.TestCase):
         """
         try:
             cls = objc.lookUpClass("NSApplication")
-        except objc.error:
-            pass
+        except objc.error:  # pragma: no cover
+            pass  # pragma: no cover
         else:
             cls.sharedApplication()
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/__init__.py

@@ -3,6 +3,7 @@ Python <-> Objective-C bridge (PyObjC)
 
 This module defines the core interfaces of the Python<->Objective-C bridge.
 """
+
 from . import _objc
 
 
@@ -43,6 +44,7 @@ from . import _structtype  # noqa: F401, F403, E402
 from . import _callable_docstr  # noqa: F401, F403, E402
 from . import _pycoder  # noqa: F401, F403, E402
 from ._informal_protocol import *  # noqa: F401, F403, E402
+from . import _new  # noqa: F401, E402
 
 
 # Helper function for new-style metadata modules

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

@@ -21,9 +21,6 @@ def registerListType(type_object):
     Register 'type' as a list-like type that will be proxied
     as an NSMutableArray subclass.
     """
-    if _objc.options._sequence_types is None:
-        _objc.options._sequence_types = ()
-
     _objc.options._sequence_types += (type_object,)
 
 
@@ -32,9 +29,6 @@ def registerMappingType(type_object):
     Register 'type' as a dictionary-like type that will be proxied
     as an NSMutableDictionary subclass.
     """
-    if _objc.options._mapping_types is None:
-        _objc.options._mapping_types = ()
-
     _objc.options._mapping_types += (type_object,)
 
 
@@ -43,9 +37,6 @@ def registerSetType(type_object):
     Register 'type' as a set-like type that will be proxied
     as an NSMutableSet subclass.
     """
-    if _objc.options._set_types is None:
-        _objc.options._set_types = ()
-
     _objc.options._set_types += (type_object,)
 
 
@@ -54,9 +45,6 @@ def registerDateType(type_object):
     Register 'type' as a date-like type that will be proxied
     as an NSDate subclass.
     """
-    if _objc.options._date_types is None:
-        _objc.options._date_types = ()
-
     _objc.options._date_types += (type_object,)
 
 
@@ -65,9 +53,6 @@ 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,)
 
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_bridgesupport.py

@@ -3,6 +3,7 @@ Backward compatibility with bridgesupport files
 
 This functionality is deprecated and will be removed in PyObjC 10.
 """
+
 __all__ = ("initFrameworkWrapper", "parseBridgeSupport")
 
 import os
@@ -364,9 +365,9 @@ class _BridgeSupportParser:
                 metadata["suggestion"] = suggestion
 
                 # Force minimal metadata for ignored methods
-                self.meta[
-                    (_as_bytes(class_name), _as_bytes(sel_name), is_class)
-                ] = metadata
+                self.meta[(_as_bytes(class_name), _as_bytes(sel_name), is_class)] = (
+                    metadata
+                )
                 continue
 
             if variadic:
@@ -395,9 +396,9 @@ class _BridgeSupportParser:
                 del metadata["arguments"]
 
             if metadata:
-                self.meta[
-                    (_as_bytes(class_name), _as_bytes(sel_name), is_class)
-                ] = metadata
+                self.meta[(_as_bytes(class_name), _as_bytes(sel_name), is_class)] = (
+                    metadata
+                )
 
     def do_enum(self, node):
         name = self.attribute_string(node, "name", None)
@@ -668,7 +669,7 @@ def _parseBridgeSupport(data, globals, frameworkName, *args, **kwds):  # noqa: A
         )
 
 
-if sys.version_info[:2] >= (3, 9):
+if sys.version_info[:2] >= (3, 9):  # pragma: no branch
 
     def resource_exists(package, resource):
         try:
@@ -677,7 +678,10 @@ if sys.version_info[:2] >= (3, 9):
         except ImportError:
             return False
 
-else:
+    def resource_string(package, resource):
+        return resources.files(package).joinpath(resource).read_text()
+
+else:  # pragma: no cover
 
     def resource_exists(package, resource):
         try:
@@ -686,14 +690,6 @@ else:
         except ImportError:
             return False
 
-
-if sys.version_info[:2] >= (3, 9):
-
-    def resource_string(package, resource):
-        return resources.files(package).joinpath(resource).read_text()
-
-else:
-
     def resource_string(package, resource):
         return resources.read_text(package, resource)
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_context.py

@@ -25,6 +25,7 @@ Use ``objc.context.unregister`` to remove the registration of ``myObject``
 when you're done. The argument to unregister is the same object as was
 passed in during registration.
 """
+
 __all__ = ("context",)
 from typing import Any
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience.py

@@ -2,6 +2,7 @@
 This module implements a callback function that is used by the C code to
 add Python special methods to Objective-C classes with a suitable interface.
 """
+
 from objc._objc import (
     _block_call,
     _rescanClass,
@@ -12,8 +13,16 @@ from objc._objc import (
     selector,
 )
 import PyObjCTools.KeyValueCoding as kvc
-
-__all__ = ("addConvenienceForClass", "registerABCForClass")
+from objc._new import make_generic_new, NEW_MAP
+from objc._transform import _selectorToKeywords
+
+__all__ = (
+    "addConvenienceForClass",
+    "registerABCForClass",
+    "registerUnavailableMethod",
+    "registerNewKeywords",
+    "registerNewKeywordsFromSelector",
+)
 
 CLASS_METHODS = {}
 CLASS_ABC = {}
@@ -53,6 +62,15 @@ def add_convenience_methods(cls, type_dict):
 
     Matching entries from both mappings are added to the 'type_dict'.
     """
+
+    # Only add the generic __new__ to pure ObjC classes,
+    # __new__ will be added to Python subclasses by
+    # ._transform.
+    if not cls.__has_python_implementation__ and type(  # noqa: E721
+        cls.__mro__[1].__new__
+    ) != type(lambda: None):
+        type_dict["__new__"] = make_generic_new(cls)
+
     for nm, value in CLASS_METHODS.get(cls.__name__, ()):
         type_dict[nm] = value
 
@@ -78,6 +96,56 @@ def makeBundleForClass():
     return selector(bundleForClass, isClassMethod=True)
 
 
+def registerUnavailableMethod(classname, selector):
+    """
+    Mark *selector* as unavailable for *classname*.
+    """
+    if not isinstance(selector, bytes):
+        raise TypeError("selector should by a bytes object")
+    selname = selector.decode()
+
+    # This adds None as a replacement value instead of
+    # registering metadata because NS_UNAVAILABLE is
+    # used to mark abstract base classes with concrete
+    # public subclasses.
+    # addConvenienceForClass(classname, ((selname.replace(":", "_"), None),))
+    registerMetaDataForSelector(
+        classname.encode(),
+        selector,
+        {"suggestion": f"{selector.decode()!r} is NS_UNAVAILABLE"},
+    )
+
+    if selname.startswith("init"):
+        kw = _selectorToKeywords(selname)
+        NEW_MAP.setdefault(classname, {})[kw] = None
+
+
+def registerNewKeywordsFromSelector(classname, selector):
+    """
+    Register keywords calculated from 'selector' as passible
+    keyword arguments for __new__ for the given class. The
+    selector should be an 'init' method.
+    """
+    if not isinstance(selector, bytes):
+        raise TypeError("selector should by a bytes object")
+    selname = selector.decode()
+    kw = _selectorToKeywords(selname)
+    NEW_MAP.setdefault(classname, {})[kw] = selname.replace(":", "_")
+
+
+def registerNewKeywords(classname, keywords, methodname):
+    """
+    Register the keyword tuple 'keywords' as a set of keyword
+    arguments for __new__ for the given class that will result
+    in the invocation of the given method.
+
+    Method should be either an init method or a class method.
+    """
+    if not isinstance(keywords, tuple) or not all(isinstance(x, str) for x in keywords):
+        raise TypeError("keywords must be tuple of strings")
+    NEW_MAP.setdefault(classname, {})[keywords] = methodname
+
+
 def registerABCForClass(classname, *abc_class):
     """
     Register *classname* with the *abc_class*-es when

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_mapping.py

@@ -1,6 +1,7 @@
 """
 Convenience methods for Cocoa mapping types.
 """
+
 __all__ = ("addConvenienceForBasicMapping",)
 
 import collections.abc
@@ -117,7 +118,7 @@ def addConvenienceForBasicMapping(classname, readonly=True):
     Add the convenience methods for a Cocoa mapping type
 
     Used to add the basic collections.abc.Mapping or collections.abc.MutableMapping
-    APIs to a Cocoa class that has an API simular to NSDictionary.
+    APIs to a Cocoa class that has an API similar to NSDictionary.
     """
     addConvenienceForClass(
         classname, _CONVENIENCES_MAPPING_RO if readonly else _CONVENIENCES_MAPPING_RW

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsarray.py

@@ -1,6 +1,7 @@
 """
 Convenience interface for NSArray/NSMutableArray
 """
+
 __all__ = ()
 
 import collections.abc
@@ -10,6 +11,7 @@ from objc._convenience import addConvenienceForClass, container_unwrap, containe
 from objc._objc import _C_ID, _C_NSInteger
 from objc._objc import _NSNotFound as NSNotFound
 from objc._objc import lookUpClass, registerMetaDataForSelector
+from ._new import NEW_MAP
 
 NSArray = lookUpClass("NSArray")
 NSMutableArray = lookUpClass("NSMutableArray")
@@ -296,6 +298,10 @@ def nsarray_new(cls, sequence=None):
         return NSArray.arrayWithArray_(sequence)
 
 
+for cls in ("NSArray", "__NSArrayI", "__NSArrayM", "__NSArray0"):
+    NEW_MAP.setdefault(cls, {})[()] = nsarray_new
+
+
 def nsmutablearray_new(cls, sequence=None):
     if not sequence:
         return NSMutableArray.array()
@@ -313,6 +319,11 @@ def nsmutablearray_new(cls, sequence=None):
         return NSMutableArray.arrayWithArray_(sequence)
 
 
+for cls in ("NSMutableArray",):
+    d = NEW_MAP.setdefault(cls, {})
+    d[()] = nsmutablearray_new
+
+
 def nsarray__contains__(self, elem):
     return bool(self.containsObject_(container_wrap(elem)))
 
@@ -373,7 +384,6 @@ def nsarray__iter__(self):
 addConvenienceForClass(
     "NSArray",
     (
-        ("__new__", staticmethod(nsarray_new)),
         ("__add__", nsarray_add),
         ("__radd__", nsarray_radd),
         ("__mul__", nsarray_mul),
@@ -411,7 +421,6 @@ def nsmutablearray__copy__(self):
 addConvenienceForClass(
     "NSMutableArray",
     (
-        ("__new__", staticmethod(nsmutablearray_new)),
         ("__copy__", nsmutablearray__copy__),
         ("__setitem__", nsarray__setitem__),
         ("__delitem__", nsarray__delitem__),

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsdata.py

@@ -5,8 +5,10 @@ NSData needs to be handles specially for correctness reasons,
 and is therefore in the core instead of the Foundation
 framework wrappers.
 """
+
 from objc._convenience import addConvenienceForClass
 from objc._objc import registerMetaDataForSelector
+from ._new import NEW_MAP
 import sys
 import operator
 
@@ -52,6 +54,10 @@ def nsdata__new__(cls, value=None):
         return cls.dataWithBytes_length_(view, len(view))
 
 
+for cls in ("NSData", "NSMutableData"):
+    NEW_MAP.setdefault(cls, {})[()] = nsdata__new__
+
+
 def nsdata__str__(self):
     if len(self) == 0:
         return str(b"")
@@ -248,7 +254,6 @@ def nsdata_isascii(self, *args, **kwds):
 addConvenienceForClass(
     "NSData",
     (
-        ("__new__", staticmethod(nsdata__new__)),
         ("__len__", lambda self: self.length()),
         ("__str__", nsdata__str__),
         ("__getitem__", nsdata__getitem__),

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsdecimal.py

@@ -4,11 +4,13 @@ Support for NSDecimalNumber.
 The actual class is defined in Foundation, but having the wrapper
 here is much more convenient.
 """
+
 __all__ = ()
 import operator
 
 from objc._convenience import addConvenienceForClass
 from objc._objc import NSDecimal, lookUpClass
+from ._new import NEW_MAP
 
 NSDecimalNumber = lookUpClass("NSDecimalNumber")
 
@@ -38,10 +40,11 @@ def decimal_new(cls, value=None):
                 raise TypeError("Value is not a number")
 
 
+NEW_MAP.setdefault("NSDecimalNumber", {})[()] = decimal_new
+
 addConvenienceForClass(
     "NSDecimalNumber",
     (
-        ("__new__", staticmethod(decimal_new)),
         (
             "__add__",
             lambda self, other: NSDecimalNumber(operator.add(NSDecimal(self), other)),

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsdictionary.py

@@ -1,6 +1,7 @@
 """
 Convenience interface for NSDictionary/NSMutableDictionary
 """
+
 __all__ = ()
 
 import collections.abc

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsobject.py

@@ -26,37 +26,37 @@ def nsobject_hash(self, _max=sys.maxsize, _const=((sys.maxsize + 1) * 2)):
 
 
 def nsobject__eq__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return self is other
     return bool(self.isEqualTo_(other))
 
 
 def nsobject__ne__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return self is not other
     return bool(self.isNotEqualTo_(other))
 
 
 def nsobject__gt__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return NotImplemented
     return bool(self.isGreaterThan_(other))
 
 
 def nsobject__ge__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return NotImplemented
     return bool(self.isGreaterThanOrEqualTo_(other))
 
 
 def nsobject__lt__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return NotImplemented
     return bool(self.isLessThan_(other))
 
 
 def nsobject__le__(self, other):
-    if self.__is_magic():
+    if self.__pyobjc_magic_coookie__():
         return NotImplemented
     return bool(self.isLessThanOrEqualTo_(other))
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsset.py

@@ -1,12 +1,14 @@
 """
 Convenience interface for NSSet/NSMutableSet
 """
+
 __all__ = ()
 
 import collections.abc
 
 from objc._convenience import addConvenienceForClass, container_unwrap, container_wrap
 from objc._objc import lookUpClass
+from ._new import NEW_MAP
 
 NSSet = lookUpClass("NSSet")
 NSMutableSet = lookUpClass("NSMutableSet")
@@ -341,6 +343,5 @@ def nsmutableset_new(cls, sequence=None):
     return value
 
 
-addConvenienceForClass("NSSet", (("__new__", staticmethod(nsset_new)),))
-
-addConvenienceForClass("NSMutableSet", (("__new__", staticmethod(nsmutableset_new)),))
+NEW_MAP.setdefault("NSSet", {})[()] = nsset_new
+NEW_MAP.setdefault("NSMutableSet", {})[()] = nsmutableset_new

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_nsstring.py

@@ -1,7 +1,9 @@
 """
 Convenience interface for NSString
 """
+
 from objc._convenience import addConvenienceForClass
+from ._new import NEW_MAP
 
 __all__ = ()
 
@@ -15,12 +17,14 @@ def nsstring_new(cls, value=_no_value):
         return cls.alloc().initWithString_(value)
 
 
+for cls in ("NSString", "NSMutableString"):
+    NEW_MAP.setdefault(cls, {})[()] = nsstring_new
+
 addConvenienceForClass(
     "NSString",
     (
         ("__len__", lambda self: self.length()),
         ("endswith", lambda self, pfx: self.hasSuffix_(pfx)),
         ("startswith", lambda self, pfx: self.hasPrefix_(pfx)),
-        ("__new__", staticmethod(nsstring_new)),
     ),
 )

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_convenience_sequence.py

@@ -2,6 +2,7 @@
 This module implements a callback function that is used by the C code to
 add Python special methods to Objective-C classes with a suitable interface.
 """
+
 from objc._convenience import addConvenienceForClass
 
 __all__ = ("addConvenienceForBasicSequence",)

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_lazyimport.py

@@ -4,6 +4,7 @@ Helper module that will enable lazy imports of Cocoa wrapper items.
 This improves startup times and memory usage, at the cost
 of not being able to use 'from Cocoa import *'
 """
+
 __all__ = ("ObjCLazyModule", "createFrameworkDirAndGetattr")
 
 import re
@@ -35,8 +36,6 @@ _DEFAULT_ALIASES = {
 
 
 def _deprecation_level(value):
-    if isinstance(value, int):
-        return value
     major, _, minor = value.partition(".")
     return int(major) * 100 + int(minor)
 
@@ -244,8 +243,8 @@ def createFrameworkDirAndGetattr(
             for nm, _val in re.findall(r"\$([A-Z0-9a-z_]*)@([^$]*)(?=\$)", enummap):
                 try:
                     expressions_mapping[nm]
-                except KeyError:
-                    pass
+                except KeyError:  # pragma: no cover
+                    pass  # pragma: no cover
 
             enummap = ""
 

{pyobjc-core-10.2 → pyobjc_core-11.0}/Lib/objc/_locking.py

@@ -4,6 +4,7 @@ Support for @synchronized blocks
 The python class object_lock is a contextmanager for with statements that
 can also be used manually.
 """
+
 import objc as _objc