OwlCyberSecurity - MANAGER
Edit File: _hooks.cpython-311.pyc
� ������hP����������������������V����d�Z�ddlmZ�ddlZddlZddlZddlmZ�ddlm Z �ddlm Z �ddlmZ�ddlmZ�dd lm Z �dd lmZ�ddlmZ�ddlmZ�dd lmZ�ddlmZ�ddlmZ�ddlmZ�ddlmZ�ddlmZ�erddlmZ�ddlmZ��ed������������Z�ededef����������������������Zeeef���������ZeZ ee!ed���������ee!ef���������e"geee e���������f���������f���������Z#edeeedee���������df���������f���������f���������Z$er�G�d��de������������Z%�G�d��de������������Z&�G�d��d ������������Z'�G�d!��d"������������Z(d5d&�Z)�e*ed'������������Z+d6d+�Z,�G�d,��d-������������Z-e eee!ef���������eee gdf������������������f������������������Z.�G�d.��d/������������Z/�G�d0��d1e/������������Z0�G�d2��d������������Z1�G�d3��d4������������Z2dS�)7zA Internal hook annotation, representation and calling machinery. �����)�annotationsN)� ModuleType)�AbstractSet)�Any)�Callable)� Generator)�List)�Mapping)�Optional)�overload)�Sequence)�Tuple)� TYPE_CHECKING)�TypeVar)�Union����)�_Result)� TypedDict)�Final�_T�_F.)�bound�HookImplc�������������������.�����e�Zd�ZU�ded<���ded<���ded<���dS�)� _HookSpecOpts�bool�firstresult�historic�Warning | None�warn_on_implN��__name__� __module__�__qualname__�__annotations__��������^/builddir/build/BUILD/cloudlinux-venv-1.0.8/venv/lib/python3.11/site-packages/pluggy/_hooks.pyr���r���*���s3������������������������$�$�$�$�$�$r'���r���c�������������������L�����e�Zd�ZU�ded<���ded<���ded<���ded<���ded<���ded<���d S�) � _HookImplOptsr����wrapper�hookwrapper�optionalhook�tryfirst�trylast� str | None�specnameNr!���r&���r'���r(���r*���r*���/���sQ����������������� � � �������������� � � ������r'���r*���c�������������������r�����e�Zd�ZdZdZdd�Ze � � �ddd���������������Ze � � � �ddd���������������Z � � � �ddd�Zd S�)�HookspecMarkera��Decorator for marking functions as hook specifications. Instantiate it with a project_name to get a decorator. Calling :meth:`PluginManager.add_hookspecs` later will discover all marked functions if the :class:`PluginManager` uses the same project_name. ��project_namer5����str�return�Nonec����������������������||�_���������d�S��Nr4�����selfr5���s��� r(����__init__zHookspecMarker.__init__B����������#/����r'���FN�functionr���r���r���r���r ���r���c����������������������d�S�r:���r&����r<���r?���r���r���r ���s��� r(����__call__zHookspecMarker.__call__E���� ������� �r'���.�Callable[[_F], _F]c����������������������d�S�r:���r&���rA���s��� r(���rB���zHookspecMarker.__call__O���rC���r'���� _F | None�_F | Callable[[_F], _F]c�����������������:����������d�����fd�}|��||������������S�|S�)a���If passed a function, directly sets attributes on the function which will make it discoverable to :meth:`PluginManager.add_hookspecs`. If passed no function, returns a decorator which can be applied to a function later using the attributes supplied. If ``firstresult`` is ``True``, the 1:N hook call (N being the number of registered hook implementation functions) will stop at I<=N when the I'th function returns a non-``None`` result. If ``historic`` is ``True``, every call to the hook will be memorized and replayed on plugins registered after the call was made. �funcr���r7���c�����������������l�������r�rt����������d����������������d�}t����������|��j��������dz���|�������������|�S�)Nz'cannot have a historic firstresult hook)r���r���r ����_spec)� ValueError�setattrr5���)rI����optsr���r���r<���r ���s��� ����r(����setattr_hookspec_optsz6HookspecMarker.__call__.<locals>.setattr_hookspec_optsn���sY��������� L�K�� L� �!J�K�K�K�*�$� ,�#��#�D� � �D�$�+�g�5�t�<�<�<��Kr'���N�rI���r���r7���r���r&���)r<���r?���r���r���r ���rO���s���` ``` r(���rB���zHookspecMarker.__call__Y���sR����������* �� �� �� �� �� �� �� �� ����(�(��2�2�2�(�(r'����r5���r6���r7���r8���)FFN) r?���r���r���r���r���r���r ���r���r7���r���)....) r?���r8���r���r���r���r���r ���r���r7���rD���)NFFN) r?���rF���r���r���r���r���r ���r���r7���rG����r"���r#���r$����__doc__� __slots__r=���r���rB���r&���r'���r(���r3���r3���8���s�������������������"�I�0��0��0��0����"��'+����������X��������'*����������X���#�!��'+�#)��#)��#)��#)��#)��#)��#)r'���r3���c������������������������e�Zd�ZdZdZdd�Ze � � � � � �ddd���������������Ze � � � � � � �ddd���������������Z � � � � � � �d d!d�ZdS�)"�HookimplMarkera��Decorator for marking functions as hook implementations. Instantiate it with a ``project_name`` to get a decorator. Calling :meth:`PluginManager.register` later will discover all marked functions if the :class:`PluginManager` uses the same project_name. r4���r5���r6���r7���r8���c����������������������||�_���������d�S�r:���r4���r;���s��� r(���r=���zHookimplMarker.__init__����r>���r'���.r?���r���r,���r���r-���r.���r/���r1���r0���r+���c����������������������d�S�r:���r&����r<���r?���r,���r-���r.���r/���r1���r+���s��� r(���rB���zHookimplMarker.__call__����� ������� �r'���rD���c����������������������d�S�r:���r&���rY���s��� r(���rB���zHookimplMarker.__call__����rZ���r'���NFrF���rG���c�����������������F�������������d��������fd�}|�|S��||������������S�)a���If passed a function, directly sets attributes on the function which will make it discoverable to :meth:`PluginManager.register`. If passed no function, returns a decorator which can be applied to a function later using the attributes supplied. If ``optionalhook`` is ``True``, a missing matching hook specification will not result in an error (by default it is an error if no matching spec is found). If ``tryfirst`` is ``True``, this hook implementation will run as early as possible in the chain of N hook implementations for a specification. If ``trylast`` is ``True``, this hook implementation will run as late as possible in the chain of N hook implementations. If ``wrapper`` is ``True``("new-style hook wrapper"), the hook implementation needs to execute exactly one ``yield``. The code before the ``yield`` is run early before any non-hook-wrapper function is run. The code after the ``yield`` is run after all non-hook-wrapper functions have run. The ``yield`` receives the result value of the inner calls, or raises the exception of inner calls (including earlier hook wrapper calls). The return value of the function becomes the return value of the hook, and a raised exception becomes the exception of the hook. If ``hookwrapper`` is ``True`` ("old-style hook wrapper"), the hook implementation needs to execute exactly one ``yield``. The code before the ``yield`` is run early before any non-hook-wrapper function is run. The code after the ``yield`` is run after all non-hook-wrapper function have run The ``yield`` receives a :class:`_Result` object representing the exception or result outcome of the inner calls (including earlier hook wrapper calls). This option is mutually exclusive with ``wrapper``. If ``specname`` is provided, it will be used instead of the function name when matching this hook implementation to a hook specification during registration. .. versionadded:: 1.2.0 The ``wrapper`` parameter. rI���r���r7���c�����������������L������������d�}t����������|��j��������dz���|�������������|�S�)N)r+���r,���r-���r.���r/���r1����_impl)rM���r5���) rI���rN���r,���r-���r<���r1���r.���r/���r+���s ��� �������r(����setattr_hookimpl_optsz6HookimplMarker.__call__.<locals>.setattr_hookimpl_opts����sB�������"�*� ,�$�"�$� #��#�D�� �D�$�+�g�5�t�<�<�<��Kr'���NrP���r&���) r<���r?���r,���r-���r.���r/���r1���r+���r_���s ���` `````` r(���rB���zHookimplMarker.__call__����se�������������f �� �� �� �� �� �� �� �� �� �� �� ����(�(�(�(��2�2�2r'���rQ���)......)r?���r���r,���r���r-���r���r.���r���r/���r���r1���r0���r+���r���r7���r���).......)r?���r8���r,���r���r-���r���r.���r���r/���r���r1���r0���r+���r���r7���rD���)NFFFFNF)r?���rF���r,���r���r-���r���r.���r���r/���r���r1���r0���r+���r���r7���rG���rR���r&���r'���r(���rV���rV������s�������������������"�I�0��0��0��0���� � ���"�� �� �� �� ���X� ������ ���"�� �� �� �� ���X� ��#�!�"���#��B3��B3��B3��B3��B3��B3��B3r'���rV���rN���r7���r8���c���������������������|�����������������������dd�������������|�����������������������dd�������������|�����������������������dd�������������|�����������������������dd�������������|�����������������������dd�������������|�����������������������dd��������������d�S�)Nr.���Fr/���r+���r,���r-���r1���)� setdefault)rN���s��� r(����normalize_hookimpl_optsrb�������s��������O�O�J��&�&�&��O�O�I�u�%�%�%��O�O�I�u�%�%�%��O�O�M�5�)�)�)��O�O�N�E�*�*�*��O�O�J��%�%�%�%�%r'����pypy_version_inforI����object�'tuple[tuple[str, ...], tuple[str, ...]]c�����������������d��� ��t����������j��������|�������������r �|�j��������}�nI#�t����������$�r�Y�dS�w�xY�wt����������j��������|�������������s$ �t����������|�d|�������������}�n#�t����������$�r�Y�dS�w�xY�w �t����������j��������t����������j��������|�������������r|�j ��������n|�������������}n#�t����������$�r�Y�dS�w�xY�wt�����������j��������j��������t�����������j��������j ��������f� � fd�|j�������������������������������������������D���������������}t!����������|������������}t!����������d��|�����������������������������������D���������������������������pd}|r2t%����������|�������������}|d|����������t!����������||d����������������������}}nd}t&����������sd}nd}|r=t����������|�d d ������������}t����������j��������|�������������sd|v�r|d���������|v�r |d d����������}||fS�)z�Return tuple of positional and keywrord argument names for a function, method, class or callable. In case of a class, its ``__init__`` method is considered. For methods the ``self`` parameter is not included. )r&���r&���rB���c�����������������.������i�|�]\��}}|j����������v��||��S�r&���)�kind)�.0�name�param�_valid_param_kindss��� �r(���� <dictcomp>zvarnames.<locals>.<dictcomp>��s7��������������D�%��:�+�+�+�� �e�+�+�+r'���c��������������3���@���K����|�]}|j���������|j��������u�|j���������V����d�S�r:���)�default�empty)ri���rk���s��� r(���� <genexpr>zvarnames.<locals>.<genexpr>��s?����������� �� ���}�E�K�/�/�� �M�/�/�/�/� �� r'���Nr&����r<���)r<����objr$������.r���r���)�inspect�isclassr=����AttributeError� isroutine�getattr� Exception� signature�ismethod�__func__� TypeError� Parameter�POSITIONAL_ONLY�POSITIONAL_OR_KEYWORD� parameters�items�tuple�values�len�_PYPY) rI����sig� _valid_params�args�defaults�index�kwargs�implicit_names�qualnamerl���s ��� @r(����varnamesr��������s=���������t���� � ��=�D�D���� �� �� ��6�6� ���� � �t� $� $��� ��4��T�2�2�D�D���� �� �� ��6�6� �������$�-�d�3�3�=�D�M�M�� �� �������������v�v������ ��)���/�����������>�/�/�1�1������M� �����D� �� �� �&�-�-�/�/� �� �� �� �� �� � �� � ������X������F�U�F�|�U�4����<�%8�%8�f��������)�*3���(�������n�b�9�9����D�!�!�� �c�X�o�o�$�q�'�^�:S�:S�����8�D���<�s0������ -�-�A�� A%�$A%�)/B�� B'�&B'c�������������������&�����e�Zd�ZdZdZerd d�ZdS�dS�) � _HookRelayzaHook holder object for performing 1:N hook calls where N is the number of registered plugins.)�__dict__rj���r6���r7����_HookCallerc����������������������d�S�r:���r&���)r<���rj���s��� r(����__getattr__z_HookRelay.__getattr__@��s�������Cr'���N)rj���r6���r7���r����)r"���r#���r$���rS���rT���r���r����r&���r'���r(���r����r����8��sK�������������������I���� �� �� �� �� �� ���r'���r����c������������������������e�Zd�ZdZ � �d,d-d �Zd.d�Zd/d�Zd.d�Zd0d�Zd1d�Z d2d�Z d3d�Zd4d�Zd5d"�Z � �d,d6d&�Zd7d)�Zd8d+�ZdS�)9r����)rj����spec� _hookexec� _hookimpls� _call_historyNrj���r6����hook_execute� _HookExec�specmodule_or_class�_Namespace | None� spec_opts�_HookSpecOpts | Noner7���r8���c����������������������||�_���������||�_��������g�|�_��������d�|�_��������d�|�_��������|�|�J��|����������������������||�������������d�S�d�S�r:���)rj���r����r����r����r�����set_specification)r<���rj���r����r����r����s��� r(���r=���z_HookCaller.__init__P��s_������� �� � ,���13���26���%)�� ��*��(�(�(��"�"�#6� �B�B�B�B�B��+�*r'���r���c����������������������|�j���������d�uS�r:���)r����rr���s��� r(����has_specz_HookCaller.has_spec`��s�������y��$�$r'���� _Namespacer���c�����������������������|�j����������)t����������d|�j���������j���������d|�j���������j������������������������t ����������||�j��������|������������|�_���������|���������������������d������������r g�|�_��������d�S�d�S�)NzHook z( is already registered within namespace r���)r����rL���rj���� namespace�HookSpec�getr����)r<���r����r����s��� r(���r����z_HookCaller.set_specificationc��s������� ��9� ��:�� ���:��:�$(�I�$7�:��:����� ���0�$�)�Y�G�G�� ��=�=��$�$�� $�!#�D���� $�� $r'���c����������������������|�j���������d�uS�r:���)r����rr���s��� r(����is_historicz_HookCaller.is_historicq��s�������!��-�-r'����plugin�_Pluginc����������������������t����������|�j��������������������D�]\��}}|j��������|k����r|�j��������|=��d�S��t����������d|�d��������������)Nzplugin z not found)� enumerater����r����rL���)r<���r�����i�methods��� r(����_remove_pluginz_HookCaller._remove_plugint��s^������"�4�?�3�3�� �� �I�A�v��}��&�&��O�A�&�����'���7�6�7�7�7�8�8�8r'����list[HookImpl]c�����������������4�����|�j��������������������������������������������S�r:���)r�����copyrr���s��� r(���� get_hookimplsz_HookCaller.get_hookimpls{��s��������#�#�%�%�%r'����hookimplr���c���������������������t����������|�j��������������������D�]\��}}|j��������s|j��������r|}�n�t ����������|�j��������������������}|j��������s|j��������r|t ����������|�j��������������������}}nd|}}|j��������r|�j�����������������������������||�������������dS�|j��������r|�j�����������������������������||�������������dS�|dz ��}||k����r/|�j��������|���������j��������r|dz��}||k����r|�j��������|���������j���������|�j�����������������������������|dz���|�������������dS�)z,Add an implementation to the callback chain.r���r���N)r����r����r,���r+���r����r/����insertr.���)r<���r����r����r����� splitpoint�start�ends��� r(���� _add_hookimplz_HookCaller._add_hookimpl~��s>�����"�4�?�3�3�� .�� .�I�A�v��!�� �V�^�� �� ��� ���T�_�-�-�J���� '�8�#3�� '�#�S���%9�%9�3�E�E��J�3�E���� 4��O�"�"�5�(�3�3�3�3�3� � �� 4��O�"�"�3��1�1�1�1�1���a��A��u�*�*����!3�!<�*��Q�����u�*�*����!3�!<�*��O�"�"�1�q�5�(�3�3�3�3�3r'���c����������������������d|�j����������d�S�)Nz <_HookCaller �>�rj���rr���s��� r(����__repr__z_HookCaller.__repr__���s������-�t�y�-�-�-�-r'���r�����Mapping[str, object]c������������������������|�j���������rj|�j���������j��������D�]_}|�vrWd����������������������fd�|�j���������j��������D���������������������������}t����������j��������d���������������������|������������d���������������d�S��^d�S�d�S�)Nz, c��������������3���b����K����|�])}|�������������������������������������v�t����������|������������V����*d�S�r:���)�keys�repr)ri����argnamer����s��� �r(���rq���z<_HookCaller._verify_all_args_are_provided.<locals>.<genexpr>���sJ������������*��*�#�"�&�+�+�-�-�7�7���W� � ��8�7�7�7� *��*r'���zSArgument(s) {} which are declared in the hookspec cannot be found in this hook call����)� stacklevel)r�����argnames�join�warnings�warn�format)r<���r����r����� notincalls��� ` r(����_verify_all_args_are_providedz)_HookCaller._verify_all_args_are_provided���s���������9�� ��9�-�� �� ���&�(�(� $� � ��*��*��*��*�'+�y�'9�*��*��*��!��!�I���M�<�<B�F�9�<M�<M�#$�������� ��E�E��)� �� � �� r'���rd���r���c����������������������|�������������������������������������r J�d���������������|����������������������|�������������|�j��������r |�j��������j�����������������������������dd������������nd}|����������������������|�j��������|�j��������||������������S�)N�ACannot directly call a historic hook - use call_historic instead.r���F)r����r����r����rN���r����r����rj���r����)r<���r����r���s��� r(���rB���z_HookCaller.__call__���s�������� � �"�"� O�� O�N� O�� O�"��*�*�6�2�2�2�BF�)�V�d�i�n�(�(���>�>�>�QV���~�~�d�i���&�+�N�N�Nr'����result_callback�Callable[[Any], None] | None�Mapping[str, object] | Nonec���������������������|�j����������J��|pi�}|����������������������|�������������|�j������������������������������||f�������������|����������������������|�j��������|�j��������|d������������}|�dS�t ����������|t����������������������r|D�]}�||��������������dS�dS�)a��Call the hook with given ``kwargs`` for all registered plugins and for all plugins which will be registered afterwards. If ``result_callback`` is provided, it will be called for each non-``None`` result obtained from a hook implementation. NF)r����r�����appendr����rj���r����� isinstance�list)r<���r����r�����res�xs��� r(���� call_historicz_HookCaller.call_historic���s���������!�-�-�-���2���*�*�6�2�2�2���!�!�6�?�";�<�<�<���n�n�T�Y�����G�G���"��F��c�4� � �� #��� #�� #�����"�"�"�"� #�� #� #�� #r'����methods�Sequence[Callable[..., object]]c�����������������z����|�������������������������������������r J�d���������������|����������������������|�������������ddddddd�}|�j�������������������������������������������}|D�]�}t ����������dd||������������}t����������|������������dz ��}|dk����rY||���������j��������rL||���������j��������s?||���������j��������s2|dz��}|dk����r'||���������j��������r||���������j��������s ||���������j���������2|� ��������������������|dz���|���������������|�j ��������r |�j ��������j�����������������������������dd������������nd}|�� ��������������������|�j��������|||������������S�) zCall the hook with some additional temporarily participating methods using the specified ``kwargs`` as call parameters.r����FN)r+���r,���r-���r/���r.���r1���z<temp>r���r���r���)r����r����r����r����r���r����r.���r,���r+���r����r����rN���r����r����rj���) r<���r����r����rN���� hookimplsr����r����r����r���s ��� r(���� call_extraz_HookCaller.call_extra���s�������� � �"�"� O�� O�N� O�� O�"��*�*�6�2�2�2�� �!���� �� ����O�(�(�*�*� ��� .�� .�F���h���=�=�H��I����"�A��Q����a�L�)���"�1��1���5>�q�\�5I�����Q��� ��Q����a�L�)���"�1��1���5>�q�\�5I��� � ���Q��U�H�-�-�-�-�BF�)�V�d�i�n�(�(���>�>�>�QV���~�~�d�i��F�K�H�H�Hr'���r����c�����������������������|�������������������������������������r`|�j���������J��|�j��������D�]Q\��}}|����������������������|�j��������|g|d������������}|r*|�(t ����������|t ����������������������sJ���||d�����������������������PdS�dS�)zAApply call history to a new hookimpl if it is marked as historic.NFr���)r����r����r����rj���r����r����)r<���r����r����r����r����s��� r(����_maybe_apply_historyz _HookCaller._maybe_apply_history���s������������� ,��%�1�1�1�+/�+=�� ,�� ,�'����n�n�T�Y���&�%�H�H����,�?�6�%�c�4�0�0�0�0�0�#�O�C��F�+�+�+�� ,�� ,� ,�� ,r'���)NN) rj���r6���r����r����r����r����r����r����r7���r8���)r7���r���)r����r����r����r���r7���r8���)r����r����r7���r8����r7���r����)r����r���r7���r8����r7���r6���)r����r����r7���r8���)r����rd���r7���r���)r����r����r����r����r7���r8���)r����r����r����r����r7���r���)r����r���r7���r8���)r"���r#���r$���rT���r=���r����r����r����r����r����r����r����r����rB���r����r����r����r&���r'���r(���r����r����G��sG��������������I��26�*.�C��C��C��C��C� %��%��%��%�$��$��$��$�.��.��.��.�9��9��9��9�&��&��&��&�4��4��4��4�0.��.��.��.��������$O��O��O��O��9=�.2�#��#��#��#��#�0I��I��I��I�@ ,�� ,�� ,�� ,�� ,�� ,r'���r����c�������������������n�����e�Zd�ZdZdZdd �Zedd���������������Zedd ���������������Zedd���������������Z dd�Z dS�)�_SubsetHookCallerztA proxy to another HookCaller which manages calls to all registered plugins except the ones from remove_plugins.)�_orig�_remove_plugins�origr�����remove_plugins�AbstractSet[_Plugin]r7���r8���c�����������������R�����||�_���������||�_��������|j��������|�_��������|j��������|�_��������d�S�r:���)r����r����rj���r����)r<���r����r����s��� r(���r=���z_SubsetHookCaller.__init__ ��s'�������� �-����I�� ������r'���r����c�����������������4���������fd���j���������j��������D���������������S�)Nc�����������������0������g�|�]}|j����������j��������v�|��S�r&���)r����r����)ri����implr<���s��� �r(���� <listcomp>z0_SubsetHookCaller._hookimpls.<locals>.<listcomp>��s3�������� �� �� ���{�$�"6�6�6�� �6�6�6r'���)r����r����rr���s���`r(���r����z_SubsetHookCaller._hookimpls��s3������� �� �� �� �� �-� �� �� �� r'����HookSpec | Nonec����������������������|�j���������j��������S�r:���)r����r����rr���s��� r(���r����z_SubsetHookCaller.spec��s�������z��r'����_CallHistory | Nonec����������������������|�j���������j��������S�r:���)r����r����rr���s��� r(���r����z_SubsetHookCaller._call_history��s �������z�'�'r'���r6���c����������������������d|�j����������d�S�)Nz<_SubsetHookCaller r����r����rr���s��� r(���r����z_SubsetHookCaller.__repr__ ��s������3�T�Y�3�3�3�3r'���N)r����r����r����r����r7���r8���r����)r7���r����)r7���r����r����)r"���r#���r$���rS���rT���r=����propertyr����r����r����r����r&���r'���r(���r����r�������s���������������4��4��I� (��(��(��(��� �� �� ���X� ����������X����(��(��(���X�(�4��4��4��4��4��4r'���r����c�������������������"�����e�Zd�ZdZdd�Zdd �ZdS�)r���)r?���r����� kwargnamesr����rN����plugin_namer+���r,���r-���r.���r/���r����r����r����r6���r?����_HookImplFunction[object]�hook_impl_optsr*���r7���r8���c���������������������||�_���������t����������|�j���������������������\��|�_��������|�_��������||�_��������||�_��������||�_��������|d���������|�_��������|d���������|�_��������|d���������|�_ ��������|d���������|�_ ��������|d���������|�_��������d�S�)Nr+���r,���r-���r.���r/���)r?���r����r����r����r����rN���r����r+���r,���r-���r.���r/���)r<���r����r����r?���r����s��� r(���r=���zHookImpl.__init__3��s{������� (�� �)1�$�-�)@�)@�&�� �t�����"�� �&���%�i�0���)�-�8���*�>�:���&�z�2�� �%�i�0����r'���c�����������������(�����d|�j����������d|�j���������d�S�)Nz<HookImpl plugin_name=z , plugin=r����)r����r����rr���s��� r(���r����zHookImpl.__repr__E��s ������U��(8�U�U�T�[�U�U�U�Ur'���N) r����r����r����r6���r?���r����r����r*���r7���r8���r����)r"���r#���r$���rT���r=���r����r&���r'���r(���r���r���$��sI���������������I�1��1��1��1�$V��V��V��V��V��Vr'���c������������������������e�Zd�ZdZdd �ZdS�) r����)r����r?���rj���r����r����rN���r ���r����r����rj���r6���rN���r���r7���r8���c�����������������������||�_���������t����������||������������|�_��������||�_��������t ����������|�j��������������������\��|�_��������|�_��������||�_��������|���������������������d������������|�_ ��������d�S�)Nr ���) r����rz���r?���rj���r����r����r����rN���r����r ���)r<���r����rj���rN���s��� r(���r=���zHookSpec.__init__T��sZ������"���/6�y�$�/G�/G�� ��� �)1�$�-�)@�)@�&�� �t���� � �H�H�^�4�4����r'���N)r����r����rj���r6���rN���r���r7���r8���)r"���r#���r$���rT���r=���r&���r'���r(���r����r����I��s/���������������I�5��5��5��5��5��5r'���r����)rN���r*���r7���r8���)rI���rd���r7���re���)3rS���� __future__r���rv����sysr�����typesr����typingr���r���r���r���r ���r ���r���r���r ���r���r���r���r����_resultr����typing_extensionsr���r���r���rd���r����typer����r����r6���r���r�����_HookImplFunctionr���r*���r3���rV���rb����hasattrr����r����r�����_CallHistoryr����r����r���r����r&���r'���r(����<module>r �����s/��������#��"��"��"��"��"������� � � � ������������������������������������������������������������������������������������������������������������������������������������������� �� �� �� �� �� ���������������������������������������(�+�+�+�+�+�+�'�'�'�'�'�'�� �W�T�]�]���W�T��#�v�+�.�/�/�/�� �:�t�#� $� � ����(�:� ���V�� 4�d�;� �&�$�v�,� ��!� � ���S�%��I�d�G�B�K��6M�,N�(N�"O�O�P����� �%��%��%��%��%� ��%��%��%� ��������� �������D)��D)��D)��D)��D)��D)��D)��D)�Ni3��i3��i3��i3��i3��i3��i3��i3�X&��&��&��&�� ���(�)�)��>��>��>��>�B �� �� �� �� �� �� �� ���E�'�#�v�+�.���3�%��+�9N�0O�O�P�Q��m,��m,��m,��m,��m,��m,��m,��m,�`*4��*4��*4��*4��*4���*4��*4��*4�Z"V��"V��"V��"V��"V��"V��"V��"V�J5��5��5��5��5��5��5��5��5��5r'���