SrSSKrSSKrSSKrSSKrSSKJr SS/r/SQr\R"\ 5r Sr Sr S r\"\ \ \/5r\ rS rS rS rS rg)zCommon utility library.N)urllibzrafek@google.com (Rafe Kaplan)z#guido@google.com (Guido van Rossum)) positionalPOSITIONAL_WARNINGPOSITIONAL_EXCEPTIONPOSITIONAL_IGNOREWARNING EXCEPTIONIGNOREc^U4Sjn[T[R5(aU$[R"T5un p4[ [ U5[ U5- 5"T5$)aA decorator to declare that only the first N arguments my 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, kwonly1=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 ``util.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 the 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 key-word only argument is provided as a positional parameter, but only if util.positional_parameters_enforcement is set to POSITIONAL_EXCEPTION. cJ>^[R"T5UU4Sj5nU$)Nc>[U5T:akSnTS:waSnSRTRT[U5US9n[[:Xa [ U5e[[ :Xa[RU5 T"U0UD6$)NszV{function}() takes at most {args_max} positional argument{plural} ({args_given} given))functionargs_max args_givenplural) lenformat__name__!positional_parameters_enforcementr TypeErrorrloggerwarning)argskwargsplural_smessagemax_positional_argswrappeds $lib/third_party/oauth2client/util.pypositional_wrapperDpositional..positional_decorator..positional_wrapperys4y..&!+"HCCI6(/(8(8(;*-d)&. DJD0 58LL#G,,6:LLNN7+D+F+ +) functoolswraps)r!r#r s` r"positional_decorator(positional..positional_decoratorxs&  ! , " , "!r%) isinstancesix integer_typesinspect getargspecrr)r r(r_defaultss` r"rr0s[P"(%s'8'899##&112EFa#d)c(m345HIIr%cf[U[R5(aU$SRU5$)a?Converts scope value to a string. If scopes is a string then it is simply passed through. If scopes is an iterable then a string is returned that is all the individual scopes concatenated with spaces. Args: scopes: string or iterable of strings, the scopes. Returns: The scopes formatted as a single string.  )r*r+ string_typesjoinscopess r"scopes_to_stringr7s+&#**++ xxr%cxU(d/$[U[R5(aURS5$U$)aConverts stringifed scope value to a list. If scopes is a list then it is simply passed through. If scopes is an string then a list of each individual scope is returned. Args: scopes: a string or iterable of strings, the scopes. Returns: The scopes in a list. r2)r*r+r3splitr5s r"string_to_scopesr:s3  &#**++||C   r%c<UcU$[[RRU55n[ [RR US55nX$U'[RR U5US'[RRU5$)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. )listrparseurlparsedict parse_qsl urlencode urlunparse)urlnamevalueparsedqs r"_add_query_parameterrIsx } fll++C01 ''q 2 3$LL**1-q ||&&v..r%)__doc__r&r-loggingr+ six.movesr __author____all__ getLoggerrrrrr frozensetPOSITIONAL_SETrrr7r:rIr%r"rSs %)     8 $".0D-/0%7!`JF &(/r%