o &h@sddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1gdZ2iZ3hdZ4de5d e5fd d Z6d e5d e5e7e5d fffddZ8d_ddZ9GdddZ:GdddZ;GdddZGdddZ?GdddZ@Gd d!d!ZAGd"d#d#ZBiZCd$d%ZDd&d'ZEd(d)ZFd*d+ZGd,d-ZHGd.d/d/ZIGd0d1d1eIeJZKGd2d3d3eKZLe1eIe&e1eKeeKd4ZMeMNd5eMNd6eKd7ZOeKd8ZPeKd9ZQeQNd:eKd;ZReKd<ZSeKd=ZTeKd>ZUeKd?ZVeKd@ZWdAdBZXdCdDZYeYZZeHeWGdEdFdFeIZ[e[d4Z\zeKdGZ]Wne^yzGdHdGdGeMZ]YnwdIdJZ_e eeZ`e eeZae eeeZbGdKdLdLe ZcGdMdNdNe ZdGdOdPdPe ZedQdRZfdSdTZgehZiGdUdVdVZjGdWdXdXZkGdYdZdZeIZled[me#d\ZnehZoGd]d^d^ZpdS)`N) CFUNCTYPEPOINTERArray StructureUnion addressofbyrefc_boolc_char_pc_intc_uintc_uint8c_ulongc_void_pcast py_objectsizeof string_at)SELClassadd_ivar add_method ensure_bytes get_classget_ivarlibclibobjc objc_blockobjc_idobjc_property_attribute_tobject_isClass send_message send_superset_ivar)compound_value_for_sequencectype_for_typectypes_for_method_encodingencoding_for_ctyperegister_ctype_for_type)BlockNSArrayNSDataNSDecimalNumber NSDictionaryNSMutableArrayNSMutableDictionaryNSNumberNSObjectNSObjectProtocolNSString ObjCBlock ObjCClass ObjCInstance ObjCMetaClass ObjCProtocolProtocolat for_objcclassget_type_for_objcclass_map ns_from_pyobjc_classmethod objc_const objc_ivar objc_method objc_propertyobjc_rawmethod py_from_nsregister_type_for_objcclasstype_for_objcclassunregister_type_for_objcclass>newcopyZ mutableCopyinitalloc method_namereturncCsR|ddd}tD]}||r&||}|dks"|ds&|Sq dS)zReturns the method family from the method name. See https://clang.llvm.org/docs/AutomaticReferenceCounting.html#method-families for documentation on method families and corresponding selector names. _:r)lstripsplit_RETURNS_RETAINED_FAMILIES startswith removeprefixislower)rMZfirst_componentfamily remainderrZg/Users/merlin/projects/employee-monitoring-system/venv/lib/python3.10/site-packages/rubicon/objc/api.pyget_method_familycs  r\name.cCsH|dr|d^}}}|ddt|}||fS|}d}||fS)aj Performs the following transformation: "methodWithArg0:withArg1:withArg2:" -> "methodWithArg0", ("", "withArg1", "withArg2") "methodWithArg0:" -> "methodWithArg0", ("", ) "method" -> "method", () The first element of the returned tuple is the "base name" of the method. The second element is a tuple with its argument names. rPrrQrZ)endswithrSinserttuple)r]firstrestrOrZrZr[method_name_to_tuplets  rccCsVtt|}t|}|dtttg}|j|dD] }| ||tq|S)NrN) inspectgetfullargspecunwraptypingget_type_hintsgetr7rargsappend)foffsetZargspechintsencodingvarnamerZrZr[encoding_from_annotations  rqc@s0eZdZdZddZddZddddd Zd S) ObjCMethodaAn unbound Objective-C method. This is Rubicon's high-level equivalent of :class:`~rubicon.objc.runtime.Method`. :class:`ObjCMethod` objects normally don't need to be used directly. To call a method on an Objective-C object, you should use the method call syntax supported by :class:`ObjCInstance`, or the :func:`~rubicon.objc.runtime.send_message` function. .. note:: This is *not* the same class as the one used for *bound* Objective-C methods, as returned from :meth:`ObjCInstance.__getattr__`. Currently, Rubicon doesn't provide any documented way to get an unbound :class:`ObjCMethod` object for an instance method of an :class:`ObjCClass`. cCsbt||_|jj|_t||_t|j^|_|_|jddt t gks'J|jdd|_ dS)a)The constructor takes a :class:`~rubicon.objc.runtime.Method` object, whose information is used to create an :class:`ObjCMethod`. This can be used to call or introspect a :class:`~rubicon.objc.runtime.Method` pointer received from the Objective-C runtime. N) rmethod_getNameselectorr]Zmethod_getTypeEncodingror'restypeZ imp_argtypesrrmethod_argtypes)selfmethodrZrZr[__init__s   zObjCMethod.__init__cCs*dt|jd|jd|jdS)N<:  >)type __qualname__r]decoderorxrZrZr[__repr__szObjCMethod.__repr__T) convert_argsconvert_resultc Gsht|t|jkrtd|jdt|dt|jd|rtg}t|j|D]K\}}t|tjr4|j}t |t rP|durBt |}n+t |rOt|t sOt |}nt |trZt |}nt|tjjrmt |ttfrmt||}||q'n|}t|j}|dkrt|dtgdt||jg|R|j|jd} |s| S|jdurt |jtr|tv} t| | d } | S) aCall the method on an object with the given arguments. The passed arguments are automatically converted to the expected argument types as needed: * :class:`enum.Enum` objects are replaced by their :attr:`~enum.Enum.value` before further conversion * For parameters that expect a block, Python callables are converted to :class:`Block`\s * For parameters that expect an Objective-C object, Python objects are converted using :func:`ns_from_py` * For parameters that expect a C structure, Python sequences are converted using :func:`~rubicon.objc.types.compound_value_for_sequence`. * Finally, :mod:`ctypes` applies its normal function argument conversions. The above argument conversions (except those performed by :mod:`ctypes`) can be disabled by setting the ``convert_args`` keyword argument to ``False``. If the method returns an Objective-C object, it is automatically converted to an :class:`ObjCInstance`. This conversion can be disabled by setting the ``convert_result`` keyword argument to ``False``, in which case the object is returned as a raw :class:`~rubicon.objc.runtime.objc_id` value. The ``_cmd`` selector argument does *not* need to be passed in manually --- the method's :attr:`selector` is automatically added between the receiver and the method arguments. zMethod z takes z arguments, but got z argumentsNrKretainrvargtypes)_implicitly_owned)lenrw TypeErrorr]zip isinstanceenumEnumvalue issubclassrr>callabler*r collectionsabcSequencerrr%rkr\rr"rurvrTr7) rxreceiverrrrjZconverted_argsargtypeargZ method_familyresultZimplicitly_ownedrZrZr[__call__s\!          zObjCMethod.__call__N__name__ __module__r__doc__rzrrrZrZrZr[rrs rrcs6eZdZeZfddZddZefddZZS)ObjCPartialMethodcst||_i|_dSN)superrz name_startmethods)rxr __class__rZr[rz-s  zObjCPartialMethod.__init__cCt|jd|jdSN())rrrrrZrZr[r6zObjCPartialMethod.__repr__c Kstdd|D}t|}|tjur|rtd|}n |d|d|}z|j|}|j |}||g|RWSt yDYnw||jurN|j }n|j dd | d}|j |}|rq||j|<||g|RStd|dd d d|jDd) Ncss|] }|ddVqdS)__rN)rS).0argnamerZrZr[ ;sz-ObjCPartialMethod.__call__..z#Missing first (positional) argumentr)rQrPzInvalid selector z. Available selectors are: , css|]}|VqdSrrZ)rselrZrZr[r]s)r`listvaluesr _sentinelrr_r objc_class _cache_methodKeyErrorrjoinkeys ValueError) rxrZ first_argkwargsorderrjrbr]methrZrZr[r9s:         zObjCPartialMethod.__call__) rrrobjectrrzrr __classcell__rZrZrr[r*s   rc@(eZdZdZddZddZddZdS) ObjCBoundMethodzThis represents an Objective-C method (an IMP) which has been bound to some id which will be passed as the first parameter to the method.cCs,||_t|turt|t|_dS||_dS)z>Initialize with a method and ObjCInstance or ObjCClass object.N)ryrrrrr)rxryrrZrZr[rzes  zObjCBoundMethod.__init__cCs t|jd|jd|jdS)Nrrr)rrryrrrZrZr[rms zObjCBoundMethod.__repr__cOs|j|jg|Ri|S)z)Call the method with the given arguments.)ryrrxrjrrZrZr[rpszObjCBoundMethod.__call__NrrZrZrZr[ras  rcCsLg}t|dd|D]\}}t|ttfr|t|q ||q |S)zvUsed to convert Objective-C method arguments to Python values before passing them on to the Python-defined method.N)rrrr7rk)rorjnew_argsearZrZr[convert_method_argumentsus  rc8eZdZdZfddZddZddZdd ZZS) rBaExposes the decorated method as an Objective-C instance method in a custom class or protocol. In a custom Objective-C class, decorating a method with :func:`@objc_method ` makes it available to Objective-C: a corresponding Objective-C method is created in the new Objective-C class, whose implementation calls the decorated Python method. The Python method receives all arguments (including ``self``) from the Objective-C method call, and its return value is passed back to Objective-C. In a custom Objective-C protocol, the behavior is similar, but the method body is ignored, since Objective-C protocol methods have no implementations. By convention, the method body in this case should be empty (``pass``). (Since the method is never called, you could put any other code there as well, but doing so is misleading and discouraged.) ct||_t||_dSrrrz py_methodrqrorxrrrZr[rz zobjc_method.__init__cGsrt|}t|j|}|j|g|R}|jddur/t|jdttfr/t|}|dur/|j}t|t r7|j S|SNr) r7rrorrrr>ptrrrr)rx objc_selfobjc_cmdrjZpy_selfrrZrZr[r  zobjc_method.__call__cC |dd}t||||jdSNrOrPreplacerrorx class_ptr attr_namer]rZrZr[class_register zobjc_method.class_registercCs<|dd}ddd|jD}t|t||dddS)NrOrPcs|] }tt|VqdSrr(r&rtprZrZr[rz0objc_method.protocol_register..TrrrorZprotocol_addMethodDescriptionrrx proto_ptrrr]typesrZrZr[protocol_register zobjc_method.protocol_register rrrrrzrrrrrZrZrr[rBs  rBcr) r?a6Exposes the decorated method as an Objective-C class method in a custom class or protocol. This decorator behaves exactly like :func:`@objc_method `, except that the decorated method becomes a class method, so it is exposed on the Objective-C class rather than its instances. crrrrrrZr[rzrzobjc_classmethod.__init__cGsrt|}t|j|}|j|g|R}|jddur/t|jdttfr/t|}|dur/|j}t |t r7|j S|Sr) r6rrorrrr7r>rrrr)rxZobjc_clsrrjZpy_clsrrZrZr[rrzobjc_classmethod.__call__cCs&|dd}tt||||jdSr)rrrobject_getClassrorrZrZr[rs zobjc_classmethod.class_registercCs<|dd}ddd|jD}t|t||dddS)NrOrPrcsrrrrrZrZr[rrz5objc_classmethod.protocol_register..TFrrrZrZr[rrz"objc_classmethod.protocol_registerrrZrZrr[r?s  r?c@r) rAaDefines an ``ivar`` in a custom Objective-C class. If you want to store additional data on a custom Objective-C class, it is recommended to use properties (:func:`objc_property`) instead of ``ivars``. Properties are a more modern and high-level Objective-C feature, which automatically deal with reference counting for objects, and creation of getters and setters. The ``ivar`` type may be any :mod:`ctypes` type. Unlike properties, the contents of an ``ivar`` cannot be accessed or modified using Python attribute syntax. Instead, the :func:`get_ivar` and :func:`set_ivar` functions need to be used. cCs ||_dSr)vartype)rxrrZrZr[rz zobjc_ivar.__init__cCst|||jSr)rr)rxrrrZrZr[rszobjc_ivar.class_registercCtd)Nz'Objective-C protocols cannot have ivarsrrxrrrZrZr[rszobjc_ivar.protocol_registerN)rrrrrzrrrZrZrZr[rAs  rAcsFeZdZdZedffdd ZddZddZd d Zd d Z Z S) rCaiDefines a property in a custom Objective-C class or protocol. This class should be called in the body of an Objective-C subclass or protocol, for example: .. code-block:: python class MySubclass(NSObject): counter = objc_property(NSInteger) The property type may be any :mod:`ctypes` type, as well as any of the Python types accepted by :func:`~rubicon.objc.types.ctype_for_type`. Defining a property automatically defines a corresponding getter and setter. Following standard Objective-C naming conventions, for a property ``name`` the getter is called ``name`` and the setter is called ``setName:``. In a custom Objective-C class, implementations for the getter and setter are also generated, which store the property's value in an ``ivar`` called ``_name``. If the property has an object type, the generated setter keeps the stored object retained, and releases it when it is replaced. In a custom Objective-C protocol, only the metadata for the property is generated. If ``weak`` is ``True``, the property will be created as a weak property. When assigning an object to it, the reference count of the object will not be increased. When the object is deallocated, the property value is set to None. Weak properties are only supported for Objective-C or Python object types. Fcsttt||_||_t|jt|_t|jt|_ |jo!|j |_ |jr4|js6|j s8t d|ddSdSdS)NzIncompatible type for ivar zK: Weak properties are only supported for Objective-C or Python object types) rrzr&rweakrr _is_py_objectr_is_objc_object _ivar_weakr)rxrrrrZr[rzs    zobjc_property.__init__cCsFtdt|jg}|jr|jrdnd}|t|dtt||S)NTW&r)r r(rrrrkr)rxattrs referencerZrZr[_get_property_attributes)s z&objc_property._get_property_attributescsd|t|jfdd}fdd}d|d|ddd }t|||jttgt|||dttjg}t|t ||t |dS) NrOcsRt|jd}t|ttfsz|j}Wn tyYnwjr'jr'|}|S)Nr) rrrrrrAttributeErrorrr)r_cmdr ivar_namerxrZr[ _objc_getterDs   z2objc_property.class_register.._objc_gettercsjr jr t|}t|js|}jr,js,t|jd}|j|jkr,dSt ||j djrSjsS|rEt |ddgd|rQt |dt gddSdSjr`|jt |jf<dSdS)Nrreleaserr)rrweakrefrefrrrrrr$rr"r_keep_alive_objects)rr new_value old_valuerrZr[ _objc_setterWs$       z2objc_property.class_register.._objc_settersetrrrP) rrupperrr7rrrZclass_addPropertyrr)rxrrrrZ setter_namerrZrr[r3s& %  zobjc_property.class_registercCsbd|}|jrt|||dddn|jr&t|||jd}t|ddgdt|j |fddS)NrOTrrr) rr$rrrrr"rpopr)rxrrrrrZrZr[dealloc_callbackszobjc_property.dealloc_callbackcCs(|}t|t||t|dddS)NT)rrZprotocol_addPropertyrr)rxrrrrZrZr[rszobjc_property.protocol_register) rrrrrrzrrrrrrZrZrr[rCs  [rCcr) rDaPExposes the decorated method as an Objective-C instance method in a custom class, with fewer convenience features than :func:`objc_method`. This decorator behaves similarly to :func:`@objc_method `. However, unlike with :func:`objc_method`, no automatic conversions are performed (aside from those by :mod:`ctypes`). This means that all parameter and return types must be provided as :mod:`ctypes` types (no :func:`~rubicon.objc.types.ctype_for_type` conversion is performed), all arguments are passed in their raw form as received from :mod:`ctypes`, and the return value must be understood by :mod:`ctypes`. In addition, the implicit ``_cmd`` parameter is exposed to the Python method, which is not the case when using :func:`objc_method`. This means that the decorated Python method must always have an additional ``_cmd`` parameter after ``self``; if it is missing, there will be errors at runtime due to mismatched argument counts. Like ``self``, ``_cmd`` never needs to be annotated, and any annotations on it are ignored. cs"t||_t|dd|_dS)Nrs)rmrrrrZr[rzs zobjc_rawmethod.__init__cOs|j|i|Sr)rrrZrZr[rzobjc_rawmethod.__call__cCrrrrrZrZr[rrzobjc_rawmethod.class_registercCr)NzWProtocols cannot have method implementations, use objc_method instead of objc_rawmethodrrrZrZr[rsz objc_rawmethod.protocol_registerrrZrZrr[rDs  rDcCst|tr|j}|}g}t}|jdur4zt|j}Wnty-||t |}Ynwn|jdus|D]}t ||q6|S)aLook up the :class:`ObjCInstance` subclass used to represent instances of the given Objective-C class in Python. If the exact Objective-C class is not registered, each superclass is also checked, defaulting to :class:`ObjCInstance` if none of the classes in the superclass chain is registered. Afterwards, all searched superclasses are registered for the :class:`ObjCInstance` subclass that was found. (This speeds up future lookups, and ensures that previously computed mappings are not changed by unrelated registrations.) This method is mainly intended for internal use by Rubicon, but is exposed in the public API for completeness. N) rr6rr7r_type_for_objcclass_maprrkrclass_getSuperclassrF) objcclass superclassZtraversed_classespytypeclsrZrZr[rGs"      rGcCst|tr|j}|t|j<dS)aRegister a conversion from an Objective-C class to an :class:`ObjCInstance` subclass. After a call of this function, when Rubicon wraps an Objective-C object that is an instance of ``objcclass`` (or a subclass), the Python object will have the class ``pytype`` rather than :class:`ObjCInstance`. See :func:`type_for_objcclass` for a full description of the lookup process. .. warning:: This function should only be called if no instances of ``objcclass`` (or a subclass) have been wrapped by Rubicon yet. If the function is called later, it will not fully take effect: the types of existing instances do not change, and mappings for subclasses of ``objcclass`` are not updated. Nrr6rr r)rr rZrZr[rFs rFcCst|tr|j}t|j=dS)aUnregister a conversion from an Objective-C class to an :class:`ObjCInstance` subclass. .. warning:: This function should only be called if no instances of ``objcclass`` (or a subclass) have been wrapped by Rubicon yet. If the function is called later, it will not fully take effect: the types of existing instances do not change, and mappings for subclasses of ``objcclass`` are not removed. Nrr rZrZr[rH s  rHcCsttS)zGet a copy of all currently registered :class:`ObjCInstance` subclasses as a mapping. Keys are Objective-C class addresses as :class:`int`\s. )dictr rZrZrZr[r=sr=csfdd}|S)zDecorator for registering a conversion from an Objective-C class to an :class:`ObjCInstance` subclass. This is equivalent to calling :func:`register_type_for_objcclass` on the decorated class. cst||Sr)rF)rrrZr[_for_objcclass0s z%for_objcclass.._for_objcclassrZ)r rrZrr[r<(s r<cseZdZdZeZeZ e fddZ e ddZ dfdd Zd d Zd d ZddZddZfddZfddZZS)r7z+Python wrapper for an Objective-C instance.c sdz ttt||dWSty1ttt||dtt|ttt||dYSw)z9The Objective-C object's class, as an :class:`ObjCClass`.Z _objc_class) rr7r__getattribute__r __setattr__r6rrrrrZr[rQs  zObjCInstance.objc_classcCstd|S)Nzrubicon.objc.py_attr.)r)r]rZrZr[_associated_attr_key_for_namegsz*ObjCInstance._associated_attr_key_for_nameNFc sxt|ts t|t}|jsdStjz|j|j}|r$t|dtgd|WWdSty6Ynw|sAt|dtgdt |t sUt |rUt |WdSt |t rdt ||||}nt|trlt}ntt|}t |}t tt ||d|t tt ||d|t|trt tt ||dt|||j|j<Wd|S1swY|S)amThe constructor accepts an :class:`~rubicon.objc.runtime.objc_id` or anything that can be cast to one, such as a :class:`~ctypes.c_void_p`, or an existing :class:`ObjCInstance`. :class:`ObjCInstance` objects are cached --- this means that for every Objective-C object there can be at most one :class:`ObjCInstance` object at any time. Rubicon will automatically create new :class:`ObjCInstance`\s or return existing ones as needed. The returned object's Python class is not always exactly :class:`ObjCInstance`. For example, if the passed pointer refers to a class or a metaclass, an instance of :class:`ObjCClass` or :class:`ObjCMetaClass` is returned as appropriate. Additional custom :class:`ObjCInstance` subclasses may be defined and registered using :func:`register_type_for_objcclass`. Creating an :class:`ObjCInstance` from a ``nil`` pointer returns ``None``. Rubicon retains an Objective-C object when it is wrapped in an :class:`ObjCInstance` and autoreleases it when the :class:`ObjCInstance` is garbage collected. The only exception to this are objects returned by methods which create an object (starting with "alloc", "new", "copy", or "mutableCopy"). We do not explicitly retain them because we already own objects created by us, but we do autorelease them on garbage collection of the Python wrapper. This ensures that the :class:`ObjCInstance` can always be used from Python without segfaults while preventing Rubicon from leaking memory. Nrrrr_as_parameter_block)rrrrr7_instance_lock_cached_objectsr"rrr6r!rr__new__rObjCBlockInstancerGrrrr5)rZ object_ptr_nameZ_basesZ_nsrZ cached_objrxrrZr[rksL "     $     ;;zObjCInstance.__new__c Cs0z t|dtgdWdSttfyYdSw)NZ autoreleaser)r"r NameErrorrrrZrZr[__del__s zObjCInstance.__del__cCs4|j}|dur t|S|j}|durt|St|S)aYGet a human-readable representation of ``self``. By default, ``self.description`` converted to a Python string is returned. If ``self.description`` is ``nil``, ``self.debugDescription`` converted to a Python is returned instead. If that is also ``nil``, ``repr(self)`` is returned as a fallback. N) descriptionstrdebugDescriptionrepr)rxZdescrZrZr[__str__s zObjCInstance.__str__c Cs0dt|jd|jjdt|dd|jd S)z{Get a debugging representation of ``self``, which includes the Objective-C object's class and ``debugDescription``.r{r|z at #xr~)rrrr]idr"rrZrZr[rs zObjCInstance.__repr__c CsP|ds|j|}|rt||S|j}|durT|j+|jdur'|z |j|}WWdn!ty@|j }YnwWdn1sKwY|dusd}|dusbt |j dhkrl|j | dd}|rst||S||}t||}|jdurtt|jdt|jd|jjd|t|d}t|jt}|jS) aAllows accessing Objective-C properties and methods using Python attribute syntax. If ``self`` has a Python attribute with the given name, its value is returned. If there is an Objective-C property with the given name, its value is returned using its getter method. An attribute is considered a property if any of the following are true: * A property with the name is present on the class (i.e. declared using ``@property`` in the source code) * There is both a getter and setter method for the name * The name has been declared as a property using :meth:`ObjCClass.declare_property` Otherwise, a method matching the given name is looked up. :class:`ObjCInstance` understands two syntaxes for calling Objective-C methods: * "Flat" syntax: the Objective-C method name is spelled out in the attribute name, with all colons replaced with underscores, and all arguments are passed as positional arguments. For example, the Objective-C method call ``[self initWithWidth:w height:h]`` translates to ``self.initWithWidth_height_(w, h)``. * "Interleaved" syntax: the Objective-C method name is split up between the attribute name and the keyword arguments passed to the returned method. For example, the Objective-C method call ``[self initWithRed:r green:g blue:b]`` translates to ``self.initWithRed(r, green=g, blue=b)``. The "interleaved" syntax is usually preferred, since it looks more similar to normal Objective-C syntax. However, the "flat" syntax is also fully supported. If two arguments have the same name (e.g. ``performSelector:withObject:withObject:``), you can use ``__`` in the keywords to disambiguate (e.g., ``performSelector(..., withObject__1=..., withObject__2=...)``. Any content after and including the ``__`` in an argument will be ignored. rONrZrP.r} has no attribute wrapped_pointer)r^r_cache_property_accessorr cache_lock methods_ptr _load_methodspartial_methodsrr rrrrrrobjc_getAssociatedObjectrrrrrr]rrr)rxr]ryrkey pyo_wrapperaddresspyorZrZr[ __getattr__sJ 2             zObjCInstance.__getattr__cs||jvrttt||||dS|j|}|r-t|tj r$|j }t |||dSt t t ddtgddt|ttgd}||}t|||dt |dtgddS)a Allows modifying Objective-C properties using Python syntax. If ``self`` has a Python attribute with the given name, it is set. Otherwise, the name should refer to an Objective-C property, whose setter method is called with ``value``. WrappedPyObjectrLrzinitWithObjectId:rN)__dict__rr7rrr_cache_property_mutatorrrrrrr"rrr&rrobjc_setAssociatedObject)rxr]rrywrapperr0rrZr[rYs,    zObjCInstance.__setattr__cs||jvrttt|||dS||}t||}|jdur9t t|j dt|j d|j j d|t||dddS)Nr'r}r(r6)r7rr7r __delattr__rrr/rrrrrr]r9)rxr]r0r1rrZr[r;s    zObjCInstance.__delattr__)NNNF)rrrrrWeakValueDictionaryr threadingRLockrpropertyr staticmethodrrrr$rr4rr;rrZrZrr[r77s  f  b*r7cseZdZdZeddZeddZdZ eddZ ed d Z ed d Z d,dd dfdd Z fddZ ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+ZZS)-r6zPython wrapper for an Objective-C class. :class:`ObjCClass` is a subclass of :class:`ObjCInstance` and supports the same syntaxes for calling methods and accessing properties. cCs t|}|jdur dSt|S)zfThe superclass of this class, or ``None`` if this is a root class (such as :class:`NSObject`).N)rr rr6)rxZ super_ptrrZrZr[r s  zObjCClass.superclassc2t}t|t|tfddt|jDS)z$The protocols adopted by this class.c3|] }t|VqdSrr9riZ protocols_ptrrZr[rrz&ObjCClass.protocols..)r rZclass_copyProtocolListrr`rangerrxZ out_countrZrFr[ protocolszObjCClass.protocolsFcCs2t|}t|}|jdurtd|d||fS)Nz ObjC Class z couldn't be found.)rrrr)rr]rrZrZr[_new_from_names  zObjCClass._new_from_namecCsPt|t}|jdurtdt|std|d|jddt|}||fS)Nz(Cannot create ObjCClass from nil pointerPointer  (r%z) does not refer to a class)rrrrr!rZ class_getName)rrr]rZrZr[ _new_from_ptrs   zObjCClass._new_from_ptrc s|}t|}t|jdur<|s|dur4|jr4d}t|jdur3|d7}|d|}t|jdusntd|dz|\}WntyW} z tdt|| d} ~ wwt|t smt dt |j dt |j |D]'} t| tst dt | j dt | j || dkrtd | jd qot||d durtd |D]} t| std | jqD]\} } | dkrz| j} Wn tyYqw| | qddfdd}td|dttgt|fS)NrrOzAn Objective-C class named  already existsz;An Objective-C class must have exactly one base class, not zCThe superclass of an Objective-C class must be an ObjCClass, not a r'zRThe protocols list of an Objective-C class must contain ObjCProtocol objects, not z Protocol z is adopted more than oncerzClass pair allocation failedzFailed to adopt protocol deallocc s`r||D]\}}z|j}Wn tyYq w|||q t|ddgdddS)NrPT)rvrZ_allow_dealloc)itemsrrr#)rrrobjrrrZ user_deallocrZr[ _new_dellocs"     z8ObjCClass._new_from_class_statement.._new_delloc)rrr auto_renameencode RuntimeErrorrrrr6rrrrr9countr]rZobjc_allocateClassPairZclass_addProtocolrQrrrirr7rZobjc_registerClassPair)rr]basesrrIrUbasenamesuffixr excprotorrRrrTrZrSr[_new_from_class_statements           z#ObjCClass._new_from_class_statementNrZrIrUc s|du|duAr td|durA|durA|rtdi}t|ttfr+||\}}n#||\}}t|ts@t |r@t|Sn |j |||||d\}}}| d}|diiit itd} d|vrk|d| d<t|||tf| } | S)aThe constructor accepts either the name of an Objective-C class to look up (as :class:`str` or :class:`bytes`), or a pointer to an existing class object (in any form accepted by :class:`ObjCInstance`). If given a pointer, it must refer to an Objective-C class; pointers to other objects are not accepted. (Use :class:`ObjCInstance` to wrap a pointer that might also refer to other kinds of objects.) If the pointer refers to a metaclass, an instance of :class:`ObjCMetaClass` is returned instead. Creating an :class:`ObjCClass` from a ``Nil`` pointer returns ``None``. :class:`ObjCClass` can also be called like :class:`type`, with three arguments (name, bases list, namespace mapping). This form is called implicitly by Python's ``class`` syntax, and is used to create a new Objective-C class from Python (see :ref:`custom-classes-and-protocols`). The bases list must contain exactly one :class:`ObjCClass` to be extended by the new class. An optional ``protocols`` keyword argument is also accepted, which must be a sequence of :class:`ObjCProtocol`\s for the new class to adopt. If the name of the class has already registered with the Objective C runtime, the ``auto_rename`` option can be used to ensure that the Objective C name for the new class will be unique. A numeric suffix will be appended to the Objective C name to ensure uniqueness (for example, ``MyClass`` will be renamed to ``MyClass_2``, ``MyClass_3`` etc until a unique name is found). By default, classes will *not* be renamed, unless :attr:`ObjCClass.auto_rename` is set at the class level. Nz2ObjCClass arguments 2 and 3 must be given togetherzHprotocols kwarg is not allowed for the single-argument form of ObjCClassr_utf-8)r]r,instance_method_ptrsinstance_methodsinstance_propertiesforced_propertiesr.r+r)rrrbytesr!rKrNrr8rclass_isMetaClassr^rrr=r>rrr7) r name_or_ptrrYrrIrUrr]Zobjc_class_name new_attrsrxrrZr[r5sJ&  zObjCClass.__new__cstj|dSr)rrzrrrZr[rzszObjCClass.__init__c Cs|joz |j|WWdStyq|}d}|durT|jdur)|z|j|}Wn#ty9Ynwz t|j|}WntyLYnw|j}|dus |duraYWddS||j|<|YWdSw1suwYdS)zReturns a python representation of the named instance method, either by looking it up in the cached list of methods or by searching for and creating a new method object.N)r+rbrr,r-rrrar )rxr]ZsuperclsrBrZrZr[rs@       zObjCClass._cache_methodcCs|dr d}|St||d}||}|d|d|ddd}d}|}|durA||jvr:d }n|j}|dus2|sI|rG|sI|rO||f}|Sd}|S) z7Return the accessor and mutator for the named property.rONr`rrrrPFT)r^rZclass_getPropertyrVrtitlerdr )rxr]rZrespondsaccessorZmutatorZforcedr rZrZr[_cache_property_methodss&  & z!ObjCClass._cache_property_methodsc Cl|j#z|j|}Wnty||}||j|<YnwWdn1s)wY|r4|dSdS)Returns a python representation of an accessor for the named property. Existence of a property is done by looking for the write selector (set:). Nrr+rcrrkrxr]rrZrZr[r*  z"ObjCClass._cache_property_accessorc Crl)rmNrrnrorZrZr[r8rpz!ObjCClass._cache_property_mutatorcCs|j|dS)aDeclare the instance method ``name`` to be a property getter. This causes the attribute named ``name`` on instances of this class to be treated as a property rather than a method --- accessing it returns the property's value, without requiring an explicit method call. See :class:`ObjCInstance.__getattr__` for a full description of how attribute access behaves for properties. Most properties do not need to be declared explicitly using this method, as they are detected automatically by :class:`ObjCInstance.__getattr__`. This method only needs to be used for properties that are read-only and don't have a ``@property`` declaration in the source code, because Rubicon cannot tell such properties apart from normal zero-argument methods. .. note:: In the standard Apple SDKs, some properties are introduced as regular methods in one system version, and then declared as properties in a later system version. For example, the ``description`` method/property of :class:`NSObject` was declared as a regular method `up to OS X 10.9 `__, but changed to a property `as of OS X 10.10 `__. Such properties cause compatibility issues when accessed from Rubicon: ``obj.description()`` works on 10.9 but is a :class:`TypeError` on 10.10, whereas ``obj.description`` works on 10.10 but returns a method object on 10.9. To solve this issue, the property can be declared explicitly using ``NSObject.declare_property('description')``, so that it can always be accessed using ``obj.description``. N)rdaddrxr]rZrZr[declare_property s!zObjCClass.declare_propertycCs|jj|dS)zDeclare the class method ``name`` to be a property getter. This is equivalent to ``self.objc_class.declare_property(name)``. N)rrdrqrrrZrZr[declare_class_property.sz ObjCClass.declare_class_propertycCdt|jd|jdSNr{r|r~rrr]rrZrZr[r7zObjCClass.__repr__cCrr)rrr]rrZrZr[r$:rzObjCClass.__str__cCst|jdSr)rfreer,rrZrZr[r=r zObjCClass.__del__cCt|tr t||SdS)a]Check whether the given object is an instance of this class. If the given object is not an Objective-C object, ``False`` is returned. This method allows using :class:`ObjCClass`\es as the second argument of :func:`isinstance`: ``isinstance(obj, NSString)`` is equivalent to ``obj.isKindOfClass(NSString)``. F)rr7bool isKindOfClassrxinstancerZrZr[__instancecheck__@ zObjCClass.__instancecheck__cCs>t|tr t||Std|dt|jdt|j)akCheck whether the given class is a subclass of this class. If the given object is not an Objective-C class, :class:`TypeError` is raised. This method allows using :class:`ObjCClass`\es as the second argument of :func:`issubclass`: ``issubclass(cls, NSValue)`` is equivalent to ``obj.isSubclassOfClass(NSValue)``. issubclass(X, z") arg 1 must be an ObjCClass, not r')rr6r{ZisSubclassOfClassrrrrrxsubclassrZrZr[__subclasscheck__Os zObjCClass.__subclasscheck__c Cs@|jdur t|d|j}|durP|jdur/|j |Wdn1s*wY|jD]\}}t|}||j|<|j |jq4|j}|dust d}t |t |}t|jD]9}||}t |jd} ||j| <t| \} } z|j| }Wntyt| }||j| <Ynw| |j| <qa||_dS)Nz.._load_methods cannot be called more than oncerr`)r,rWr r+r-r.rQrrupdater rZclass_copyMethodListrrGrrtr]rrarcr) rxr raZ superpartialpartialZmethods_ptr_countr,rEryr] base_nameZargument_namesrZrZr[r-bs:         zObjCClass._load_methods)NN)rrrrr?r rIrU classmethodrKrNr^rrzrrkr*r8rsrtrr$rrrr-rrZrZrr[r6sB     e l$## r6cs eZdZdZfddZZS)r8a6Python wrapper for an Objective-C metaclass. :class:`ObjCMetaClass` is a subclass of :class:`ObjCClass` and supports almost exactly the same operations and methods. However, there is usually no need to look up a metaclass manually. The main reason why :class:`ObjCMetaClass` is a separate class is to differentiate it from :class:`ObjCClass` in the :func:`repr`. (Otherwise there would be no way to tell classes and metaclasses apart, since metaclasses are also classes, and have exactly the same name as their corresponding class.) cst|ttfrt|}t|}|jdurtd|dn$t|t }|jdur,t dt |r5t |sBt d|d|jddt ||S) a!The constructor accepts either the name of an Objective-C metaclass to look up (as :class:`str` or :class:`bytes`), or a pointer to an existing metaclass object (in any form accepted by :class:`ObjCInstance`). If given a pointer, it must refer to an Objective-C metaclass; pointers to other objects are not accepted. (Use :class:`ObjCInstance` to wrap a pointer that might also refer to other kinds of objects.) Creating an :class:`ObjCMetaClass` from a ``Nil`` pointer returns ``None``. NzObjective-C metaclass not foundz+Cannot create ObjCMetaClass for nil pointerrLrMr%z) does not refer to a metaclass)rrer!rrZobjc_getMetaClassrrrrrr!rfrr)rrgr]rrrZr[rs     zObjCMetaClass.__new__)rrrrrrrZrZrr[r8s r8r2r"r r1r-r4Z UTF8Stringr,r+r/r.r0r:cCs t|ttfr t|}t|ts|S|tr!tt| dS|t rM|j }|dkr0|j S|dvr7|j S|dvr>|jS|dvrE|jStd|d|trVt|S|tritt|dttgd |jS|trwd d |DS|trd d |DS|S)a,Convert a Foundation object into an equivalent Python object if possible. Currently supported types: * :class:`~rubicon.objc.runtime.objc_id`: Wrapped in an :class:`ObjCInstance` and converted as below * :class:`NSString`: Converted to :class:`str` * :class:`NSData`: Converted to :class:`bytes` * :class:`NSDecimalNumber`: Converted to :class:`decimal.Decimal` * :class:`NSDictionary`: Converted to :class:`dict`, with all keys and values converted recursively * :class:`NSArray`: Converted to :class:`list`, with all elements converted recursively * :class:`NSNumber`: Converted to a :class:`bool`, :class:`int` or :class:`float` based on the type of its contents Other objects are returned unmodified as an :class:`ObjCInstance`. NBscsilqsCSILQsfdz%NSNumber containing unsupported type z' cannot be converted to a Python objectrercSsi|] \}}t|t|qSrZrE)rkvrZrZr[ szpy_from_ns..cSg|]}t|qSrZr)rorZrZr[ zpy_from_ns..)rrrr7r|r-decimalDecimalr!ZdescriptionWithLocaler1ZobjCTypeZ boolValueZ longLongValueZunsignedLongLongValueZ doubleValuerr4r,rr"rr lengthr.rQr+)nsobjZ objc_typerZrZr[rEs>        rEcCsnt|tjr |j}|dust|tr|St|tr%ttj|dddSt|t r5tt j |t |dSt|t jrFttj|ddSt|trdtt |}|D] \}}|j||dqV|St|tr|tt |}|D]}||qr|St|trttj|ddSt|trttj|ddSt|t rttj!|ddSt"dt#|j$dt#|j%d ) aConvert a Python object into an equivalent Foundation object. The returned object is autoreleased. This function is also available under the name :func:`at`, because its functionality is very similar to that of the Objective-C ``@`` operator and literals. Currently supported types: * ``None``, :class:`ObjCInstance`: Returned as-is * :class:`enum.Enum`: Replaced by their :attr:`~enum.Enum.value` and converted as below * :class:`str`: Converted to :class:`NSString` * :class:`bytes`: Converted to :class:`NSData` * :class:`decimal.Decimal`: Converted to :class:`NSDecimalNumber` * :class:`dict`: Converted to :class:`NSDictionary`, with all keys and values converted recursively * :class:`list`: Converted to :class:`NSArray`, with all elements converted recursively * :class:`bool`, :class:`int`, :class:`float`: Converted to :class:`NSNumber` Other types cause a :class:`TypeError`. Nr`F)r)r)ZforKeyzDon't know how to convert a r'z to a Foundation object)&rrrrr7r!r4ZstringWithUTF8String_rVrer,Z dataWithBytesrrrr-ZdecimalNumberWithString_ to_eng_stringrr0ZdictionaryWithCapacityrQZ setObjectrr/ZarrayWithCapacityZ addObjectr{r1ZnumberWithBool_intZnumberWithLong_floatZnumberWithDouble_rrrr)ZpyobjZdiktrrarrayrZrZr[r>sN          r>csXeZdZdZeddZeddZdZ dfdd Zd d Z d d Z ddZ Z S)r9z+Python wrapper for an Objective-C protocol.cCst|dS)z-The name of this protocol, as a :class:`str`.r`)rZprotocol_getNamerrrZrZr[r]SszObjCProtocol.namecrA)z)The protocols that this protocol extends.c3rBrrCrDrFrZr[r_rz)ObjCProtocol.protocols..)r rZprotocol_copyProtocolListrr`rGrrHrZrFr[rIYrJzObjCProtocol.protocolsFNc s|du|duAr td|durX|durXt|ttfr2t|}t|}|jdur1td|dnt |t }|jdur@t dt |dt tt gdsWt d|d |jd d n|}t|}t|jdur|so|dur|jrd }t|jdur|d 7}|d |}t|jdusyntd|d|D]} t| tstdt| jdt| jqt|}|durtd|D]} t|| q|D]\} } t| dr| || qt|t||S)aThe constructor accepts either the name of an Objective-C protocol to look up (as :class:`str` or :class:`bytes`), or a pointer to an existing protocol object (in any form accepted by :class:`ObjCInstance`). If given a pointer, it must refer to an Objective-C protocol; pointers to other objects are not accepted. (Use :class:`ObjCInstance` to wrap a pointer that might also refer to other kinds of objects.) Creating an :class:`ObjCProtocol` from a ``nil`` pointer returns ``None``. :class:`ObjCProtocol` can also be called like :class:`type`, with three arguments (name, bases list, namespace mapping). This form is called implicitly by Python's ``class`` syntax, and is used to create a new Objective-C protocol from Python (see :ref:`custom-classes-and-protocols`). The bases list can contain any number of :class:`ObjCProtocol` objects to be extended by the new protocol. If the name of the protocol has already registered with the Objective C runtime, the ``auto_rename`` option can be used to ensure that the Objective C name for the new protocol will be unique. A numeric suffix will be appended to the Objective C name to ensure uniqueness (for example, ``MyProtocol`` will be renamed to ``MyProtocol_2``, ``MyProtocol_3`` etc until a unique name is found). By default, protocols will *not* be renamed, unless :attr:`ObjCProtocol.auto_rename` is set at the class level. Nz5ObjCProtocol arguments 2 and 3 must be given togetherzObjective-C protocol rz*Cannot create ObjCProtocol for nil pointerzisKindOfClass:rrLrMr%z) does not refer to a protocolrrOzAn Objective-C protocol named rOzBAn Objective-C protocol can only extend ObjCProtocol objects, not r'zProtocol allocation failedr)rrrer!rrZobjc_getProtocolrrrrrr"r:r rUrVrWr9rrrZobjc_allocateProtocolZprotocol_addProtocolrQhasattrrZobjc_registerProtocolrr) rrgrYnsrUr]rrZr[baser]rrRrrZr[resj           zObjCProtocol.__new__cCrurvrwrrZrZr[rrxzObjCProtocol.__repr__cCrz)acCheck whether the given object conforms to this protocol. If the given object is not an Objective-C object, ``False`` is returned. This method allows using :class:`ObjCProtocol`\s as the second argument of :func:`isinstance`: ``isinstance(obj, NSCopying)`` is equivalent to ``obj.conformsToProtocol(NSCopying)``. F)rr7r{conformsToProtocolr}rZrZr[rrzObjCProtocol.__instancecheck__cCsXt|tr t||St|trtt||Std|dt|j dt|j )aCheck whether the given class or protocol conforms to this protocol. If the given object is not an Objective-C class or protocol, :class:`TypeError` is raised. This method allows using :class:`ObjCProtocol`\s as the second argument of :func:`issubclass`: ``issubclass(cls, NSCopying)`` is equivalent to ``cls.conformsToProtocol(NSCopying)``, and ``issubclass(proto, NSCopying)`` is equivalent to ``protocol_conformsToProtocol(proto, NSCopying))``. rz2) arg 1 must be an ObjCClass or ObjCProtocol, not r') rr6r{rr9rZprotocol_conformsToProtocolrrrrrrZrZr[rs  zObjCProtocol.__subclasscheck__)NNN) rrrrr?r]rIrUrrrrrrZrZrr[r9Os  \r9r5csDeZdZeeZeddZed ddZed fdd Z Z S) r5cCsFt|dtgd}|dur t|t}|jt|j|jf<t|d||jS)NrKrr))r"rrrrrr$)rxcmdr2r3rZrZr[initWithObjectId_s   z!WrappedPyObject.initWithObjectId_rNNcCs&t|d}|jrt|j|jf=dSdS)Nr))rrrrxrr2rZrZr[rPs zWrappedPyObject.dealloccs4t|d}|jrt|j|jf=t|ddgddS)Nr)finalizer)rrrr#rrrZr[rs zWrappedPyObject.finalize)rNN) rrrrArr)rDrrPrrrZrZrr[r5s  cCstt||S)aOCreate an :class:`ObjCInstance` from a global pointer variable in a :class:`~ctypes.CDLL`. This function is most commonly used to access constant object pointers defined by a library/framework, such as `NSCocoaErrorDomain `__. )r7rin_dll)Zdllr]rZrZr[r@#s r@c@s.eZdZdefdefdefdefdefgZdS)ObjCBlockStructisaflagsreservedinvoke descriptorN)rrrrr _cfunc_type_block_invoke_fields_rZrZrZr[r4rc@s.eZdZdefdefdefdefdefgZdS)BlockDescriptorrsize copy_helperdispose_helper signatureN)rrrr_cfunc_type_block_copy_cfunc_type_block_disposer rrZrZrZr[r>rrc@s.eZdZdefdefdefdefdefgZdS) BlockLiteralrrrrrN)rrrrr rrZrZrZr[rHrrcCsPdtfdtfg}|r|dtfdtfg|r|dtfgtdtfd|iS)NrrrrrZObjCBlockDescriptorr)rextendrrr rr) has_helpers has_signatureZdescriptor_fieldsrZrZr[create_block_descriptor_structRsrcCs"t|j|j}t|jjjt|Sr)rrrrstructcontentsrr)rZdescriptor_structrZrZr[cast_block_descriptorgsrc@s eZdZdZdZdZdZdZdS) BlockConstsiiii i@N)rrrHAS_COPY_DISPOSEZHAS_CTORZ IS_GLOBAL HAS_STRET HAS_SIGNATURErZrZrZr[rqs rc@s,eZdZdZefddZddZddZdS) r5alPython wrapper for an Objective-C block object. This class is used to manually wrap an Objective-C block so that it can be called from Python. Usually Rubicon will do this automatically, if the block object was returned from an Objective-C method whose return type is declared to be a block type. If this automatic detection fails, for example if the method's return type is generic ``id``, Rubicon has no way to tell that the object in question is a block rather than a regular Objective-C object. In that case, the object needs to be manually wrapped using :class:`ObjCBlock`. cGst|tr|j}||_t|jtt|_|jjj t j @|_ |jjj t j @|_t||_|jr3|jjjnd|_|turQ|r@td|jsGtdt|j^}}g}ntg}t||_|dd|D|_dS)aThe constructor takes a block object, which can be either an :class:`ObjCInstance`, or a raw :class:`~rubicon.objc.runtime.objc_id` pointer. .. note:: :class:`~rubicon.objc.runtime.objc_block` is also accepted, because it is a subclass of :class:`~rubicon.objc.runtime.objc_id`). Normally you do not need to make use of this, because in most cases Rubicon will automatically convert :class:`~rubicon.objc.runtime.objc_block`\s to a callable object. In most cases, Rubicon can automatically determine the block's return type and parameter types. If a block object doesn't have return/parameter type information at runtime, Rubicon will raise an error when attempting to convert it. In that case, you need to explicitly pass the correct return type and parameter types to :class:`ObjCBlock` using the ``restype`` and ``argtypes`` parameters. Nz%Cannot use argtypes with restype AUTOz3Cannot use AUTO types for blocks without signaturescSrrZr&)rZarg_typerZrZr[rsz&ObjCBlock.__init__..)rr7rpointerrrrrrrrrrrrrrrAUTOrr'rr&invoke_restypeinvoke_argtypes)rxrrvrZ block_argrZrZr[rzs*   zObjCBlock.__init__cCsHdtt|j}|jr|d7}|jr|d|jd7}|d7}|S)Nz .cSrrrZrrZrZr[rrz$Expected structure with field types z for argument z; got z with field types ) enumeraterrrrgetattrrrrrrrrrrvrr)rxrjrErZ anon_fieldsZ arg_fieldsrrZrZr[rs2    zObjCBlock.__call__N)rrrrrrzrrrZrZrZr[r5ys  6 r5c@seZdZddZdS)rcGs |j|Sr)r)rxrjrZrZr[rrzObjCBlockInstance.__call__N)rrrrrZrZrZr[rs r _NSConcreteStackBlockc@s8eZdZdZiZefddZddZddZdd Z d S) r*zA wrapper that exposes a Python callable object to Objective-C as a block. .. note:: :class:`Block` instances are currently *not* callable from Python, unlike :class:`ObjCBlock`. c Gst|std||_|turs|rtdz t|}t|}Wnttfy4}ztd|d}~wwz|d}Wnt yL}ztd|d}~wwg}|j D] }z | ||WqRt yr}z td|d|d}~wwt d d |D}t |}t|tg|R}t|_tt|j_tjtjBtjB|j_d |j_||j} t| t|j_t|_d |j_t t|j_!t"|j#|_$t%|j&|_'|j$|j_#|j'|j_&t(|d d )dd |D|j_tt*|jt|j_tt*|jt+|_,|j,|_-dS)aThe constructor accepts any Python callable object. If the callable has parameter and return type annotations, they are used as the block's parameter and return types. This allows using :class:`Block` as a decorator: .. code-block:: python @Block def the_block(arg: NSInteger) -> NSUInteger: return abs(arg) For callables without type annotations, the parameter and return types need to be passed to the :class:`Block` constructor in the ``restype`` and ``argtypes`` arguments: .. code-block:: python the_block = Block(abs, NSUInteger, NSInteger) zBlocks must be callablez&Cannot pass argtypes without a restypezmCould not retrieve function signature information - please pass return and argument types directly into BlockNrNznFunction has no return type annotation - please add one, or pass return and argument types directly into Blockz7Function has no argument type annotation for parameter zH - please add one, or pass return and argument types directly into Blockcs|]}t|VqdSrrrrZrZr[rJ z!Block.__init__..rs@?rcsrr)r()rrrZrZr[rf r).rrfuncNOTHINGrrgrhrdrr parametersrkr`r&rrrliteralrrrrrrrrrr:rrrrrrrrZcfunc_copy_helperrrZcfunc_dispose_helperr(rrrrr) rxrrvrrnrr\r]Z cfunc_typeZ cfunc_wrapperrZrZr[rz s           zBlock.__init__cGs |j|Sr)r)rxrrjrZrZr[r:l s z Block.wrappercCstj|ddSr)r*_keep_alive_blocks_r)rxdstrZrZr[rr szBlock.dispose_helpercCs|tj|<dSr)r*r)rxrsrcrZrZr[ru s zBlock.copy_helperN) rrrrrrrzr:rrrZrZrZr[r*s b r*r)qcollections.abcrrrrdr=rgrctypesrrrrrrrr r r r r rrrrrrZruntimerrrrrrrrrrrr r!r"r#r$rr%r&r'r(r)__all__rrTr!r\r`rcrqrrrrrrBr?rArCrDr rGrFrHr=r<r7rr6r8r2rsr1r-r4r,r+r/r.r0r:rEr>r;r9r3r5rr@rrrrrrrrrrrr5rrrrr*rZrZrZr[sPH%  7 1(1($ fu (    >F      {