o &hͥ@szddlZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'gdZ(dgZ)d gZ*d d Z+e+d Z,e+d Z-e+dZ.e&dGdddeZ/e&dGddde/Z0e'dGdddeZ1e'dGddde/Z2GdddeZ3GdddeZ4Gdd d eZ5Gd!d"d"eZ6Gd#d$d$e Z7de,j8_9ege,j8_:ee-j;_9e2eeeege-j;_:ee-j<_9e2e1e3ege-j<_:ee-j=_9e2eee7ege-j=_:ee-j>_9e2e/ge-j>_:ee-j?_9e2e/ge-j?_:ee5e-j@_9e2eege-j@_:ee4e-jA_9e2eege-jA_:ee6e-jB_9e2eege-jB_:ee/e-jC_9e2eege-jC_:e4e-jD_9e2e1ge-jD_:e5e-jE_9e2ege-jE_:e4e-jF_9e2e1ge-jF_:ee-jG_9e2ge-jG_:e5e-jH_9e2ege-jH_:ee-jI_9e2ge-jI_:e3e-jJ_9e2e1ge-jJ_:ee-jK_9e2ge-jK_:e6e-jL_9e2ege-jL_:e2e-jM_9e2ge-jM_:ee-jN_9e2ge-jN_:ee-jO_9e2ge-jO_:ee-jP_9e2ge-jP_:e3e-jQ_9e2e1e3ege-jQ_:ee-jR_9e2e1ge-jR_:de-jS_9e2ege-jS_:de-jT_9e2ege-jT_:de-jU_9e2ege-jU_:ee-jV_9e5ge-jV_:e"e-jW_9e5ge-jW_:ee-jX_9e5ge-jX_:de-jY_9e4e4ge-jY_:e3e-jZ_9e4ge-jZ_:e1e-j[_9e4ge-j[_:ee-j\_9e4ge-j\_:e3e-j]_9e4e3ge-j]_:e2e-j^_9e2eege-j^_:ee-j__9ge-j__:de-j`_9ege-j`_:e/e-ja_9e/ge-ja_:ee/e-jb_9eege-jb_:e/e-jc_9e/ege-jc_:e2e-jd_9ege-jd_:e2e-je_9ege-je_:e/e-jf_9ege-jf_:e/e-jg_9ege-jg_:e/e-jh_9ee/ge-jh_:e se!serde-ji_9de-jj_9e se!ree-jk_9de-jl_9e2ge-jl_:de-jm_9e/ge-jm_:de-jn_9e/ee/ege-jn_:e2e-jo_9e/ge-jo_:ze-jpZpWneqyd%d&ZpYnweep_9e/gep_:ee-jr_9e/ge-jr_:e/e-js_9e/e5ge-js_:de-jt_9e/e5e/ge-jt_:ee-ju_9e6ge-ju_:ee-jv_9e6ge-jv_:ee7e-jw_9e6eege-jw_:Gd'd(d(e Zxde-jy_9e/e1eeege-jy_:de-jz_9e/e/ge-jz_:de-j{_9e/eee7eeege-j{_:e/e-j|_9ege-j|_:ee-j}_9e/e/ge-j}_:eexe-j~_9e/eeeege-j~_:ee6e-j_9e/eege-j_:ee/e-j_9e/eege-j_:exe-j_9e/e1eege-j_:ee-j_9e/ge-j_:de-j_9e/ge-j_:ee-j_9e1ge-j_:ee-j_9e1e1ge-j_:e1e-j_9ege-j_:d)d*Zd+d,Zd-d.Zd/d0ZiZd1d2Zddd3d4d5ZGd6d7d7e Zeddd8d9d:d;ZgZdFdd?ZdFd@dAZdFdBdCZedDdEZdS)GN)contextmanager)CDLL CFUNCTYPEPOINTER ArgumentError StructureUnion addressof alignmentbyrefc_boolc_char_pc_doublec_floatc_int c_longdoublec_size_tc_uintc_uint8c_void_pcastmemmovesizeofutil) ctypes_patch) __arm____i386__ __x86_64__ c_ptrdiff_tctype_for_encodingctype_for_typeencoding_for_ctype with_encodingwith_preferred_encoding)Class FoundationIMPIvarMethodSELadd_ivar add_methodautoreleasepool get_classget_ivarlibclibobjc load_library objc_blockobjc_idobjc_method_descriptionobjc_property_t objc_superobject_isClass send_message send_superset_ivarshould_use_fpretshould_use_stretz/usr/libz/System/Library/Frameworksc Cst|}|dur t|StD]}zttj|d|dWSty*YqwtD]}zttj||d|WStyGYq-wt d|d)aLoad and return the C library with the given name. If the library could not be found, a :class:`ValueError` is raised. Internally, this function uses :func:`ctypes.util.find_library` to search for the library in the system-standard locations. If the library cannot be found this way, it is attempted to load the library from certain hard-coded locations, as a fallback for systems where ``find_library`` does not work (such as iOS). Nlibz.dylibz .frameworkzLibrary z not found) rZ find_libraryr _lib_pathospathjoinOSError_framework_path ValueError)namerAlocrHk/Users/merlin/projects/employee-monitoring-system/venv/lib/python3.10/site-packages/rubicon/objc/runtime.pyr2Ms    r2cobjcr&@c@eZdZdZdS)r4zxThe `id `__ type from ````. N__name__ __module__ __qualname____doc__rHrHrHrIr4wr4s@?c@rM)r3aThe low-level type of block pointers. This type tells Rubicon's internals that the object in question is a block and not just a regular Objective-C object, which affects method argument and return value conversions. For more details, see :ref:`objc_blocks`. .. note:: This type does not correspond to an actual C type or Objective-C class. Although the internal structure of block objects is documented, as well as the fact that they are Objective-C objects, they do not have a documented type or class name and are not fully defined in any header file. Aside from the special conversion behavior, this type is equivalent to :class:`objc_id`. NrNrHrHrHrIr3~rSr3:csDeZdZdZeddZd fdd Zd fdd Zd d ZZ S) r*zzThe `SEL `__ type from ````. cCs|jdur tdt|S)z&The selector's name as :class:`bytes`.Nz Cannot get name of null selector)valuerEr1 sel_getNameselfrHrHrIrFs  zSEL.nameNcs>t|ttfrtt|}d|_|St||}d|_|S)zThe constructor can be called with a :class:`bytes` or :class:`str` object to obtain a selector with that value. (The normal arguments supported by :class:`~ctypes.c_void_p` are still accepted.) TF) isinstancebytesstrr1sel_registerName ensure_bytes_initedsuper__new__)clsinitrX __class__rHrIr`sz SEL.__new__cs|js t|dSdSN)r^r___init__)rXrbrcrHrIrfsz SEL.__init__cCs&djt||jdurddS|jdS)Nz-{cls.__module__}.{cls.__qualname__}({name!r}))rarF)formattyperUrFrWrHrHrI__repr__s z SEL.__repr__re) rOrPrQrRpropertyrFr`rfri __classcell__rHrHrcrIr*s r*#c@rM)r%z~The `Class `__ type from ````. NrNrHrHrHrIr%rSr%c@rM)r'a/The `IMP `__ type from ````. An :class:`IMP` cannot be called directly --- it must be cast to the correct :func:`~ctypes.CFUNCTYPE` first, to provide the necessary information about its signature. NrNrHrHrHrIr'r'c@rM)r)zThe `Method `__ type from ````. NrNrHrHrHrIr)rmr)c@rM)r(zThe `Ivar `__ type from ````. NrNrHrHrHrIr(rmr(c@rM)r6zThe `objc_property_t `__ type from ````. NrNrHrHrHrIr6rmr6c@s eZdZdZdefdefgZdS)objc_property_attribute_tz The `objc_property_attribute_t `__ structure from ````. rFrUN)rOrPrQrRr _fields_rHrHrHrIrns rncCstt|S)zReturn whether the given Objective-C object is a class (or a metaclass). This is the emulated version of the object_isClass runtime function, for systems older than OS X 10.10 or iOS 8, where the real function doesn't exist yet. )r1class_isMetaClassobject_getClass)objrHrHrIr8sr8c@ eZdZdZdefdefgZdS)r5zThe `objc_method_description `__ structure from ````. rFtypesN)rOrPrQrRr*r rorHrHrHrIr5$ r5cCst|tr|S|dS)zConvert the given string to :class:`bytes` if necessary. If the argument is already :class:`bytes`, it is returned unchanged; if it is :class:`str`, it is encoded as UTF-8. utf-8)rYrZencode)xrHrHrIr]s  r]cCstt|S)zGet the Objective-C class with the given name as a :class:`Class` object. If no class with the given name is loaded, ``None`` is returned, and the Objective-C runtime will log a warning message. )r1 objc_getClassr])rFrHrHrIr.sr.cCsTt|ttur d}|Strt|dv}|Str t|dk}|Str&d}|Sd}|S)zwReturn whether a method returning the given type must be called using ``objc_msgSend_stret`` on the current system.F)rT)rhrrrrr)restyperetvalrHrHrIr=s   r=cCs"tr|tkStr|tttfvSdS)zwReturn whether a method returning the given type must be called using ``objc_msgSend_fpret`` on the current system.F)rrrrr)r~rHrHrIr<s r<cCsvz t|g|RWSty:t|rd}n t|rd}nd}t|}||_ttg||_|t|g|R<|YSw)aTGet the appropriate variant of ``objc_msgSend`` for calling a method with the given return and argument types. :param restype: The return type of the method to be called. :param argtypes: The argument types of the method to be called, excluding the self and _cmd arguments. :return: A C function for ``objc_msgSend`` or one of its variants, with its return and argument types configured correctly based on the ``restype`` and ``argtypes`` arguments. The ``restype`` and ``argtypes`` attributes of the returned function *must not* be modified. objc_msgSend_fpretobjc_msgSend_stretZ objc_msgSend) _msg_send_cacheKeyErrorr<r=r1r~r4r*argtypes)r~rZ send_namesendrHrHrI_msg_send_for_typess   r)rvarargsc Gs:z|j}Wn tyYnwt|ts$tdt|jdt|jt|ts-t|}|dur3g}|dur9g}t |t |krPtdt |dt |dt ||}z |||g||R}Wn0t y}z$|j d} |j jdd } d d d |D} | d | d| g|_ |d}~ww|tkrt|}|S)a Call a method on the receiver with the given selector and arguments. This is the equivalent of an Objective-C method call like ``[receiver sel:args]``. .. note:: Some Objective-C methods take variadic arguments (``varargs``), for example `+[NSString stringWithFormat:] `_. When using :func:`send_message`, variadic arguments are treated differently from regular arguments: they are not passed as normal function arguments in ``*args``, but as a list in a separate ``varargs`` keyword argument. This explicit separation of regular and variadic arguments protects against accidentally passing too many arguments into a method. By default these extra arguments would be considered ``varargs`` and passed on to the method, even if the method in question doesn't take ``varargs``. Because of how the Objective-C runtime and most C calling conventions work, this error would otherwise be silently ignored. The types of ``varargs`` are not included in the ``argtypes`` list. Instead, the values are automatically converted to C types using the default :mod:`ctypes` argument conversion rules. To ensure that all ``varargs`` are converted to the expected C types, it is recommended to manually convert all ``varargs`` to :mod:`ctypes` types instead of relying on automatic conversions. For example: .. code-block:: python send_message( NSString, "stringWithFormat:", at("%i %s %@"), restype=objc_id, argtypes=[objc_id], varargs=[c_int(123), cast(b"C string", c_char_p), at("ObjC string")], ) :param receiver: The object on which to call the method, as an :class:`~rubicon.objc.api.ObjCInstance` or :class:`.objc_id`. :param selector: The name of the method as a :class:`str`, :class:`bytes`, or :class:`SEL`. :param args: The method arguments. :param restype: The return type of the method. :param argtypes: The argument types of the method, as a :class:`list`. Defaults to ``[]``. :param varargs: Variadic arguments for the method, as a :class:`list`. Defaults to ``[]``. These arguments are converted according to the default :mod:`ctypes` conversion rules. z1Receiver must be an ObjCInstance or objc_id, not .N"Inconsistent number of arguments () and argument types ()rbackslashreplace)errorsz, css|]}|jVqdSre)rO).0trHrHrI Tszsend_message.. z ; argtypes: )_as_parameter_AttributeErrorrYr4 TypeErrorrhrPrQr*lenrrargsrFdecoderBr) receiverselectorr~rrrrresulterrorerrselZ valid_argsrHrHrIr9sN4       r9c@rs)r7zThe `objc_super `__ structure from ````. rZ super_classN)rOrPrQrRr4r%rorHrHrHrIr7]rur7F)r~rr_allow_deallocc Gsz|j}Wn tyYnwt|tst|}|durg}|dur$g}t|t|kr;tdt|dt|dt|tsQtdt|jdt|j d|sa|j dkrat j d d d dSz|j}Wn tyoYnwt|t rvnt|turt|t }ntd t|jdt|j t|}|jdurt|d } td| dt||} t|rtd} ntd} || _tttg|| _| t| |g||R} |tkrt| } | S)a In the context of the given class, call a superclass method on the receiver with the given selector and arguments. This is the equivalent of an Objective-C method call like ``[super sel:args]`` in the class ``cls``. In practice, the first parameter should always be the special variable ``__class__``, and the second parameter should be ``self``. A typical :func:`send_super` call would be ``send_super(__class__, self, 'init')`` for example. The special variable ``__class__`` is defined by Python and stands for the class object that is being created by the current ``class`` block. The exact reasons why ``__class__`` must be passed manually are somewhat technical, and are not directly relevant to users of :func:`send_super`. For a full explanation, see issue `beeware/rubicon-objc#107 `__ and PR `beeware/rubicon-objc#108 `__. Although it is possible to pass other values than ``__class__`` and ``self`` for the first two parameters, this is strongly discouraged. Doing so is not supported by the Objective-C language, and relies on implementation details of the superclasses. :param cls: The class in whose context the ``super`` call is happening, as an :class:`~rubicon.objc.api.ObjCClass` or :class:`Class`. :param receiver: The object on which to call the method, as an :class:`~rubicon.objc.api.ObjCInstance`, :class:`.objc_id`, or :class:`~ctypes.c_void_p`. :param selector: The name of the method as a :class:`str`, :class:`bytes`, or :class:`SEL`. :param args: The method arguments. :param restype: The return type of the method. :param argtypes: The argument types of the method, as a :class:`list`. Defaults to ``[]``. :param varargs: Variadic arguments for the method, as a :class:`list`. Defaults to ``[]``. These arguments are converted according to the default :mod:`ctypes` conversion rules. NrrrzEMissing or invalid cls argument: expected an ObjCClass or Class, not rz send_super requires the current class to be passed explicitly as the first argument. To fix this error, pass the special name __class__ as the first argument to send_super.sdealloczYou should not call the superclass dealloc manually when overriding dealloc. Rubicon-objc will call it for you after releasing objects stored in properties and ivars.rz) stacklevelzInvalid type for receiver: rvzThe specified class z3 is a root class, it cannot be used with send_superobjc_msgSendSuper_stretZobjc_msgSendSuper)rrrYr*rrr%rhrPrQrFwarningswarnr4rrr1class_getSuperclassrU class_getNamerrEr7r=r~rrr ) rarrr~rrrrZ super_ptr class_nameZ super_structrrrHrHrIr:is~3               r:c Csdd|D}|dtksJ|dtksJ|ddur-t|dttfr-t|dt|}ddd |D}t|}||}|rQt ||t |t |nt ||t |t |} | sgtd |jd t||S) aAdd a new instance method to the given class. To add a class method, add an instance method to the metaclass. :param cls: The Objective-C class to which to add the method, as an :class:`~rubicon.objc.api.ObjCClass` or :class:`Class`. :param selector: The name for the new method, as a :class:`str`, :class:`bytes`, or :class:`SEL`. :param method: The method implementation, as a Python callable or a C function address. :param encoding: The method's signature (return type and argument types) as a :class:`list`. The types of the implicit ``self`` and ``_cmd`` parameters must be included in the signature. :param replace: If the class already implements a method with the given name, replaces the current implementation if ``True``. Raises a :class:`ValueError` error otherwise. :return: The ctypes C function pointer object that was created for the method's implementation. This return value can be ignored. (In version 0.4.0 and older, callers were required to manually keep a reference to this function pointer object to ensure that it isn't garbage-collected. Rubicon now does this automatically.) cSsg|]}t|qSrH)r!)rtprHrHrI szadd_method..rrzrNcss|]}t|VqdSre)r")rctyperHrHrIrszadd_method..zA method with the name z already exists)r4r* issubclassrrrZmake_callback_returnablerBrr1class_replaceMethodrr'class_addMethodrErF_keep_alive_impsappend) rarmethodencodingreplace signaturertZ cfunctypeimpresrHrHrIr,s  r,c Cs&t|t|t|t|tt|S)z;Add a new instance variable of type ``vartype`` to ``cls``.)r1 class_addIvarr]rr r"r!)rarFvartyperHrHrIr+'s r+cCsz|j}Wn tyYnwtt|t|}tt|}|r3t|j t |}t |St |t rAtt|||S||j t |S)apGet the value of obj's ``ivar`` named ``varname``. The returned object is a :mod:`ctypes` data object. For non-object types (everything except :class:`.objc_id` and subclasses), the returned data object is backed by the ``ivar``'s actual memory. This means that the data object is only usable as long as the "owner" object is alive, and writes to it will directly change the ``ivar``'s value. For object types, the returned data object is independent of the ``ivar``'s memory. This is because object ``ivars`` may be weak, and thus cannot always be accessed directly by their address. )rrr1class_getInstanceVariablerqr]r ivar_getTypeEncodingobjc_loadWeakRetainedrUivar_getOffsetobjc_autoreleaseReturnValuerr4robject_getIvarZ from_address)rrvarnameweakivarrrUrHrHrIr/3s    r/c Csz|j}Wn tyYnwtt|t|}tt|}t||s5t d|dt |d|t t |t |krZt d|dt |dt t |d|dt | |rjt |j t||dSt|trxt|||dSt|j t|t|t |dS)zSet obj's ``ivar`` ``varname`` to value. If ``weak`` is ``True``, only a weak reference to the value is stored. value must be a :mod:`ctypes` data object whose type matches that of the ``ivar``. zIncompatible type for ivar z: z& is not a subclass of the ivar's type z has size z, but the ivar's type N)rrr1rrqr]r rrYrrhrobjc_storeWeakrUrrr4object_setIvarrr )rrrrUrrrrHrHrIr;Us@     r;c cs.t}z dVWt|dSt|w)akA context manager that has the same effect as a @autoreleasepool block in Objective-C. Any objects that are autoreleased within the context will receive a release message when exiting the context. When running an event loop, AppKit will create an autorelease pool at the beginning of each cycle of the event loop and drain it at the end. You therefore do not need to use @autoreleasepool blocks when running an event loop. However, they may be still be useful when your code temporarily allocates large amounts of memory which you want to explicitly free before the end of a cycle. N)r1objc_autoreleasePoolPushobjc_autoreleasePoolPop)poolrHrHrIr-}s  r-)F)r@r contextlibrctypesrrrrrrr r r r r rrrrrrrrrrrrrrtrrrrr r!r"r#r$__all__r?rDr2r0r1r&r4r3r*r%r'r)r(r6rnfreer~rrrZclass_addPropertyZclass_addProtocolZclass_conformsToProtocolZclass_copyIvarListZclass_copyMethodListZclass_copyPropertyListZclass_copyProtocolListZclass_getClassMethodZclass_getClassVariableZclass_getInstanceMethodZclass_getInstanceSizerZclass_getIvarLayoutZclass_getMethodImplementationrZclass_getPropertyrZclass_getVersionZclass_getWeakIvarLayoutrprZclass_respondsToSelectorZclass_setIvarLayoutZclass_setVersionZclass_setWeakIvarLayoutZ ivar_getNamerrZmethod_exchangeImplementationsZmethod_getImplementationZmethod_getNameZmethod_getTypeEncodingZmethod_setImplementationZobjc_allocateClassPairrrrZobjc_copyProtocolListZobjc_getAssociatedObjectryZobjc_getMetaClassZobjc_getProtocolrrrrrZobjc_registerClassPairZobjc_removeAssociatedObjectsZobjc_setAssociatedObjectrqr8rZobject_getClassNamerrZproperty_getAttributesZproperty_getNameZproperty_copyAttributeListr5Zprotocol_addMethodDescriptionZprotocol_addProtocolZprotocol_addPropertyZobjc_allocateProtocolZprotocol_conformsToProtocolZ"protocol_copyMethodDescriptionListZprotocol_copyPropertyListZprotocol_copyProtocolListZprotocol_getMethodDescriptionZprotocol_getNameZobjc_registerProtocolrVZ sel_isEqualr\r]r.r=r<rrr9r7r:rr,r+r/r;r-rHrHrHrIs d , %)                                                                  ,_  0 "(