§
    ÂiC  ã                   óš   — d Z ddlZddlZddlZddlZ ej        e¦  «        ZdZdZ	dZ
 eee	e
g¦  «        ZeZdZdZdZd	„ Zd
„ Zd„ Zd„ ZdS )z-Helper functions for commonly used utilities.é    NÚWARNINGÚ	EXCEPTIONÚIGNOREzFile: {0}: Is a symbolic link.z{0}: Is a directoryz,Cannot access {0}: No such file or directoryc                 óÞ   ‡ — ˆ fd„}t          ‰ t          ¦  «        r|S t          j        ‰ ¦  «        \  }}}}}}} t	          t          |¦  «        t          |¦  «        z
  ¦  «        ‰ ¦  «        S )aŠ  A decorator to declare that only the first N arguments may be positional.

    This decorator makes it easy to support Python 3 style keyword-only
    parameters. For example, in Python 3 it is possible to write::

        def fn(pos1, *, kwonly1=None, kwonly2=None):
            ...

    All named parameters after ``*`` must be a keyword::

        fn(10, 'kw1', 'kw2')  # Raises exception.
        fn(10, kwonly1='kw1')  # Ok.

    Example
    ^^^^^^^

    To define a function like above, do::

        @positional(1)
        def fn(pos1, kwonly1=None, kwonly2=None):
            ...

    If no default value is provided to a keyword argument, it becomes a
    required keyword argument::

        @positional(0)
        def fn(required_kw):
            ...

    This must be called with the keyword parameter::

        fn()  # Raises exception.
        fn(10)  # Raises exception.
        fn(required_kw=10)  # Ok.

    When defining instance or class methods always remember to account for
    ``self`` and ``cls``::

        class MyClass(object):

            @positional(2)
            def my_method(self, pos1, kwonly1=None):
                ...

            @classmethod
            @positional(2)
            def my_method(cls, pos1, kwonly1=None):
                ...

    The positional decorator behavior is controlled by
    ``_helpers.positional_parameters_enforcement``, which may be set to
    ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or
    ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do
    nothing, respectively, if a declaration is violated.

    Args:
        max_positional_arguments: Maximum number of positional arguments. All
                                  parameters after this index must be
                                  keyword only.

    Returns:
        A decorator that prevents using arguments after max_positional_args
        from being used as positional parameters.

    Raises:
        TypeError: if a keyword-only argument is provided as a positional
                   parameter, but only if
                   _helpers.positional_parameters_enforcement is set to
                   POSITIONAL_EXCEPTION.
    c                 óJ   •‡ — t          j        ‰ ¦  «        ˆˆ fd„¦   «         }|S )Nc                  ó6  •— t          | ¦  «        ‰k    r~d}‰dk    rd}d                     ‰j        ‰t          | ¦  «        |¬¦  «        }t          t          k    rt          |¦  «        ‚t          t          k    rt                               |¦  «          ‰| i |¤ŽS )NÚ é   ÚszV{function}() takes at most {args_max} positional argument{plural} ({args_given} given))ÚfunctionÚargs_maxÚ
args_givenÚplural)	ÚlenÚformatÚ__name__Ú!positional_parameters_enforcementÚPOSITIONAL_EXCEPTIONÚ	TypeErrorÚPOSITIONAL_WARNINGÚloggerÚwarning)ÚargsÚkwargsÚplural_sÚmessageÚmax_positional_argsÚwrappeds       €€úb/var/www/html/jarvis.com/web/backend/venv/lib/python3.11/site-packages/googleapiclient/_helpers.pyÚpositional_wrapperzDpositional.<locals>.positional_decorator.<locals>.positional_wrappero   s­   ø€ å�4‰yŒyÐ.Ò.Ð.Ø�Ø&¨!Ò+Ð+Ø"�Hð<ß<BºFØ!(Ô!1Ø!4Ý#& t¡9¤9Ø'ð	 =Cñ =ô =ð õ 5Õ8LÒLÐLÝ# GÑ,Ô,Ð,Ý6Õ:LÒLÐLÝ—N’N 7Ñ+Ô+Ð+Ø�7˜DÐ+ FÐ+Ð+Ð+ó    )Ú	functoolsÚwraps)r   r    r   s   ` €r   Úpositional_decoratorz(positional.<locals>.positional_decoratorn   s?   øø€ Ý	Œ˜Ñ	!Ô	!ð	,ð 	,ð 	,ð 	,ð 	,ñ 
"Ô	!ð	,ð( "Ð!r!   )Ú
isinstanceÚintÚinspectÚgetfullargspecÚ
positionalr   )r   r$   r   Ú_Údefaultss   `    r   r)   r)   &   sƒ   ø€ ðP"ð "ð "ð "ð "õ0 Ð%¥sÑ+Ô+ð JØ#Ð#å(/Ô(>Ð?RÑ(SÔ(SÑ%ˆˆa��H˜a  AØ4�z�#˜d™)œ)¥c¨(¡m¤mÑ3Ñ4Ô4Ð5HÑIÔIÐIr!   c                 ó  — t           j                             | ¦  «        }i }|                     ¦   «         D ]M\  }}t	          |¦  «        dk    r*d|›dd                     |¦  «        ›�}t          |¦  «        ‚|d         ||<   ŒN|S )a  Parses unique key-value parameters from urlencoded content.

    Args:
        content: string, URL-encoded key-value pairs.

    Returns:
        dict, The key-value pairs from ``content``.

    Raises:
        ValueError: if one of the keys is repeated.
    r
   z.URL-encoded content contains a repeated value:z -> z, r   )ÚurllibÚparseÚparse_qsÚitemsr   ÚjoinÚ
ValueError)ÚcontentÚurlencoded_paramsÚparamsÚkeyÚvalueÚmsgs         r   Úparse_unique_urlencodedr9   �   s‘   € õ œ×-Ò-¨gÑ6Ô6ÐØ€FØ'×-Ò-Ñ/Ô/ð ð ‰
ˆˆUÝˆu‰:Œ:˜Š?ˆ?ˆ?à��Ø—	’	˜%Ñ Ô Ð ðˆCõ ˜S‘/”/Ð!Ø˜A”hˆˆs‰ˆØ€Mr!   c                 ó:  — t           j                             | ¦  «        }t          |j        ¦  «        }|                     |¦  «         t           j                             |¦  «        }|                     |¬¦  «        }t           j                             |¦  «        S )a  Updates a URI with new query parameters.

    If a given key from ``params`` is repeated in the ``uri``, then
    the URI will be considered invalid and an error will occur.

    If the URI is valid, then each value from ``params`` will
    replace the corresponding value in the query parameters (if
    it exists).

    Args:
        uri: string, A valid URI, with potential existing query parameters.
        params: dict, A dictionary of query parameters.

    Returns:
        The same URI but with the new query parameters added.
    )Úquery)	r-   r.   Úurlparser9   r;   ÚupdateÚ	urlencodeÚ_replaceÚ
urlunparse)Úurir5   ÚpartsÚquery_paramsÚ	new_queryÚ	new_partss         r   Úupdate_query_paramsrF   ¦   sz   € õ" ŒL×!Ò! #Ñ&Ô&€EÝ*¨5¬;Ñ7Ô7€LØ×Ò˜ÑÔÐÝ”×&Ò& |Ñ4Ô4€IØ—’ Y�Ñ/Ô/€IÝŒ<×"Ò" 9Ñ-Ô-Ð-r!   c                 ó.   — |€| S t          | ||i¦  «        S )a\  Adds a query parameter to a url.

    Replaces the current value if it already exists in the URL.

    Args:
        url: string, url to add the query parameter to.
        name: string, query parameter name.
        value: string, query parameter value.

    Returns:
        Updated query parameter. Does not update the url if value is None.
    )rF   )ÚurlÚnamer7   s      r   Ú_add_query_parameterrJ   ¿   s"   € ð €}Øˆ
å" 3¨¨u¨Ñ6Ô6Ð6r!   )Ú__doc__r"   r'   Úloggingr-   Ú	getLoggerr   r   r   r   ÚPOSITIONAL_IGNOREÚ	frozensetÚPOSITIONAL_SETr   Ú_SYM_LINK_MESSAGEÚ_IS_DIR_MESSAGEÚ_MISSING_FILE_MESSAGEr)   r9   rF   rJ   © r!   r   ú<module>rU      sÛ   ðð 4Ð 3à Ð Ð Ð Ø €€€Ø €€€Ø €€€à	ˆÔ	˜8Ñ	$Ô	$€àÐ Ø"Ð ØÐ Ø�ØÐ-Ð/@ÐAñô €ð %7Ð !à4Ð Ø'€ØFÐ ðdJð dJð dJðNð ð ð2.ð .ð .ð27ð 7ð 7ð 7ð 7r!   