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

{pyobjc-core-10.2 → pyobjc_core-10.3.1}/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-10.3.1}/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-10.3.1}/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-10.3.1}/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-10.3.1}/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-10.3.1}/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)

{pyobjc-core-10.2 → pyobjc_core-10.3.1}/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-10.3.1}/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-10.3.1}/Lib/objc/_convenience_mapping.py

@@ -1,6 +1,7 @@
 """
 Convenience methods for Cocoa mapping types.
 """
+
 __all__ = ("addConvenienceForBasicMapping",)
 
 import collections.abc

{pyobjc-core-10.2 → pyobjc_core-10.3.1}/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-10.3.1}/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-10.3.1}/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-10.3.1}/Lib/objc/_convenience_nsdictionary.py

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

{pyobjc-core-10.2 → pyobjc_core-10.3.1}/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-10.3.1}/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-10.3.1}/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-10.3.1}/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

{pyobjc-core-10.2 → pyobjc_core-10.3.1}/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
 
 

pyobjc_core-10.3.1/Lib/objc/_new.py

@@ -0,0 +1,164 @@
+"""
+Implementation of `__new__` for arbitrary Cocoa classes
+
+The __new__ method just translates invocations into the
+corresponding invocation of the Cocoa pattern (
+`cls.alloc().init()` or `cls.new()`), based on a mapping
+maintaind in this file.
+
+The mapping is updated in two ways:
+    1. From framework bindings for native classes
+    2. Based on `init` methods in Python subclasses
+
+"""
+
+import objc
+
+__all__ = ()
+
+# Mapping: class name -> { kwds: selector_name }
+#
+# That is, keys are names of Objective-C classes, values
+# are mappings from keyword argument names to
+# the name of a selector.
+#
+# The selector_name can be `None` to disable a
+# mapping in a subclass.
+#
+# The complete mapping for a class is a chain map
+# for the submaps of all classes on the MRO.
+NEW_MAP = {
+    "NSObject": {(): "init"},
+}
+
+# Sentinel value
+UNSET = object()
+
+# Added to the docstring for __new__
+DOC_SUFFIX = "The order of keyword arguments is significant\n"
+
+
+def calculate_new_doc(cls):
+    """
+    Calculate the docstring for the __new__
+    for *cls*
+    """
+    result = {}
+    for c in reversed(cls.__mro__):
+        new_map = NEW_MAP.get(c.__name__, UNSET)
+        if new_map is UNSET:
+            continue
+
+        for kwds, selector in new_map.items():
+            if selector is None:
+                result.pop(kwds, None)
+
+            if not kwds:
+                result[kwds] = f"{cls.__name__}(): "
+            else:
+                result[kwds] = f"{cls.__name__}(*, " + ", ".join(kwds) + "): "
+            if selector.startswith("init"):
+                result[
+                    kwds
+                ] += f"\n   returns cls.alloc().{selector}({', '.join(kwds)})\n\n"
+            else:
+                result[kwds] += f"\n   returns cls.{selector}({', '.join(kwds)})\n\n"
+    return "".join(sorted(result.values())) + DOC_SUFFIX
+
+
+class function_wrapper:
+    """
+    Wrapper for the __new__ function to generate the
+    docstring dynamically.
+    """
+
+    __slots__ = ("_function", "_cls")
+
+    def __init__(self, function, cls):
+        self._function = function
+        self._cls = cls
+
+    @property
+    def __class__(self):
+        return self._function.__class__
+
+    @property
+    def __doc__(self):
+        return calculate_new_doc(self._cls)
+
+    def __getattr__(self, name):
+        return getattr(self._function, name)
+
+    def __setattr__(self, name, value):
+        if name in ("_function", "_cls"):
+            object.__setattr__(self, name, value)
+        return setattr(self._function, name, value)
+
+    def __call__(self, *args, **kwds):
+        return self._function(*args, **kwds)
+
+
+def make_generic_new(cls):
+    def __new__(cls, *args, **kwds):
+        """
+        Generic implementation for Objective-C `__new__`.
+        """
+        key = tuple(kwds.keys())
+
+        for c in cls.__mro__:
+            new_map = NEW_MAP.get(c.__name__, UNSET)
+            if new_map is UNSET:
+                continue
+
+            name = new_map.get(key, UNSET)
+            if name is UNSET:
+                continue
+
+            if name is None:
+                if key:
+                    raise TypeError(
+                        f"{cls.__name__}() does not support keyword arguments {', '.join(repr(k) for k in key)}"
+                    )
+                else:
+                    raise TypeError(f"{cls.__name__}() requires keyword arguments")
+
+            if not isinstance(name, str):
+                # Assume that 'name' is actually a callable.
+                #
+                # This is used to implement custom signatures for a number
+                # of classes in the various ._convenience sibling modules.
+                return name(cls, *args, **kwds)
+
+            if args:
+                raise TypeError(
+                    f"{cls.__name__}() does not accept positional arguments"
+                )
+
+            args = [kwds[n] for n in key]
+            if name.startswith("init") and len(name) == 4 or name[4].isupper():
+                return getattr(cls.alloc(), name)(*args)
+
+            else:
+                return getattr(cls, name)(*args)
+
+        if key in (("cobject",), ("c_void_p",)):
+            # Support for creating instances from raw pointers in the default
+            # __new__ implementation.
+            return objc.objc_object.__new__(cls, **kwds)
+
+        if key:
+            raise TypeError(
+                f"{cls.__name__}() does not support keyword arguments {', '.join(repr(k) for k in key)}"
+            )
+        else:
+            raise TypeError(f"{cls.__name__}() requires keyword arguments")
+
+    # XXX: Settings these helps, but does not yet result in the correct
+    #      output from help()
+    __new__.__name__ = cls.__name__ + ".__new__"
+    __new__.__qualname__ = cls.__name__ + ".__new__"
+    __new__.__module__ = cls.__module__
+    return function_wrapper(__new__, cls)
+
+
+objc.options._genericNewClass = function_wrapper

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

@@ -7,6 +7,7 @@ This can cause problems when the object state contains the
 object itself, which is why we need a 'setValue' callback for the
 load_* functions below.
 """
+
 __all__ = ()
 
 import copy

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

@@ -6,6 +6,7 @@ latter).
 The C code relies on this code to do most semantic checks, and only
 performs checks that are needed to avoid crashes.
 """
+
 import objc
 import types
 import inspect
@@ -14,6 +15,7 @@ import keyword
 import warnings
 import sys
 from ._informal_protocol import _informal_protocol_for_selector
+from . import _new
 
 # only public objc_method until the python_method implementation
 # in C is gone
@@ -23,7 +25,37 @@ __all__ = ("objc_method", "python_method")
 NO_VALUE = object()
 
 
+def _isSelectorPrefix(name, prefix):
+    return name.startswith(prefix) and (
+        len(name) == len(prefix) | name[len(prefix)].isupper()
+    )
+
+
+def _selectorToKeywords(selector):
+    if not selector.startswith("init"):
+        raise ValueError("selector is not a valid init selector")
+    if len(selector) > 4 and not selector[4].isupper():
+        raise ValueError("selector is a valid init selector")
+    selector = selector[4:]
+    if not selector:
+        return ()
+
+    parts = selector.split(":")[:-1]
+    if parts[0].startswith("With"):
+        parts[0] = parts[0][4:]
+    parts[0] = parts[0][:1].lower() + parts[0][1:]
+
+    return tuple(parts)
+
+
+def setDunderNew(
+    class_object,
+):
+    class_object.__new__ = _new.make_generic_new(class_object)
+
+
 def processClassDict(
+    class_name,
     class_dict,
     meta_dict,
     class_object,
@@ -73,7 +105,7 @@ def processClassDict(
 
     # First call all class setup hooks. Those can
     # update the class dictiory, which is why this
-    # loop# cannot be merged into the next one.
+    # loop cannot be merged into the next one.
     for key, value in list(class_dict.items()):
         setup = getattr(value, "__pyobjc_class_setup__", NO_VALUE)
         if setup is not NO_VALUE:
@@ -153,10 +185,30 @@ def processClassDict(
         elif sel.isHidden:
             hidden_class_methods[sel.selector] = sel
 
+    new_kw_map = {}
+
+    for name, value in class_dict.items():
+        if not isinstance(name, str) or not name.startswith("init"):
+            continue
+        if len(name) > 4 and not name[4].isupper():
+            continue
+        if value is None and name == "init":
+            new_kw_map[()] = None
+            continue
+        elif not isinstance(value, objc.selector):
+            continue
+
+        new_kw_map[_selectorToKeywords(value.selector.decode())] = name
+    if new_kw_map:
+        _new.NEW_MAP[class_name] = new_kw_map
+
     return (
         instance_variables,
         instance_methods,
         class_methods,
+        # Either __new__ in this class, or a custom new in a parent class
+        ("__new__" in class_dict)
+        or type(class_object.__new__) == type(lambda: 1),  # noqa: E721
     )
 
 
@@ -698,3 +750,4 @@ class python_method:
 
 objc.options._transformAttribute = transformAttribute
 objc.options._processClassDict = processClassDict
+objc.options._setDunderNew = setDunderNew