
    hC                         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       ~/home/visionen/pythonvenv/lib/python3.11/site-packages/google_api_python_client-2.181.0-py3.11.egg/googleapiclient/_helpers.pypositional_wrapperzDpositional.<locals>.positional_decorator.<locals>.positional_wrappero   s    4yy...&!++"H<<BF!(!1!4#&t99'	 =C = =  58LLL#G,,,6:LLLNN7+++7D+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HaA4z#d))c(mm3445H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//!Ah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7L&&|44I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!   