z*SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK J r \R"\ 5r SrSrSr\"\\\/5r\rSrSrS rS rS rS rS rSrSrSrSrSrSSjr Sr!Sr"Sr#g)z-Helper functions for commonly used utilities.N)urllibWARNING EXCEPTIONIGNOREzFile: {0}: Is a symbolic link.z{0}: Is a directoryz,Cannot access {0}: No such file or directoryc^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 ``_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 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 _helpers.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_enforcementPOSITIONAL_EXCEPTION TypeErrorPOSITIONAL_WARNINGloggerwarning)argskwargsplural_smessagemax_positional_argswrappeds 4platform/bq/third_party/oauth2client_4_0/_helpers.pypositional_wrapperDpositional..positional_decorator..positional_wrappervs4y..&!+"HCCI6(/(8(8(;*-d)&. DJD0 58LL#G,,6:LLNN7+D+F+ +) functoolswraps)rr!rs` r positional_decorator(positional..positional_decoratorus&  ! , " , "!r#) isinstancesix integer_typesinspect getargspec positionalr)rr&r_defaultss` r r-r--s[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_stringr6s+&#**++ 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. r1)r(r)r2splitr4s r string_to_scopesr9s3  FC,, - -||C   r#c[RRU5n0n[R"U5H?up4[ U5S:wa$SU<SSR U5<3n[U5eUSX#'MA U$)zParses 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)rparseparse_qsr) iteritemsrr3 ValueError)contenturlencoded_paramsparamskeyvaluemsgs r parse_unique_urlencodedrEsp --g6 Fmm$56  u:?!$dii&68CS/ !Ah 7 Mr#c&[RRU5n[UR5nUR U5 [RR U5nURUS9n[RRU5$)aUpdates 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) rr;urlparserErGupdate urlencode_replace urlunparse)urirAparts query_params new_query new_partss r update_query_paramsrRsm" LL ! !# &E*5;;7L &&|4IY/I << " "9 --r#c&UcU$[XU05$)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. )rR)urlnamerCs r _add_query_parameterrVs } "3u 66r#c[RRU5(a[[R U55e[RR U5(a[[R U55e[RRU5(d*[R"[R U55 gg)N) ospathislinkIOError_SYM_LINK_MESSAGErisdir_IS_DIR_MESSAGEisfilewarningswarn_MISSING_FILE_MESSAGE)filenames r validate_filerds ww~~h'..x899 x o,,X677 WW^^H % % +228<=&r#c:URS5nUS:waXS$g)aVIdentify and extract PEM keys. Determines whether the given key is in the format of PEM key, and extracts the relevant part of the key if it is. Args: raw_key_input: The contents of a private key file (either PEM or PKCS12). Returns: string, The actual key if the contents are from a PEM file, or else None. s -----BEGIN N)find) raw_key_inputoffsets r _parse_pem_keyrjs+   /F |W%%r#c,[R"USS9$)N),:) separators)jsondumps)datas r _json_encoderrs ::dz 22r#c[U[R5(aURU5OUn[U[R5(aU$[ SR U55e)aConverts a string value to bytes, if necessary. Unfortunately, ``six.b`` is insufficient for this task since in Python2 it does not modify ``unicode`` objects. Args: value: The string/bytes value to be converted. encoding: The encoding to use to convert unicode to bytes. Defaults to "ascii", which will not allow any characters from ordinals larger than 127. Other useful values are "latin-1", which which will only allows byte ordinals (up to 255) and "utf-8", which will encode any unicode that needs to be. Returns: The original value converted to bytes (if unicode) or as passed in if it started out as bytes. Raises: ValueError if the value could not be converted to bytes. z%{0!r} could not be converted to bytes)r(r) text_typeencode binary_typer>r)rCencodingresults r _to_bytesrysX,E3==11ll8$7< &#//** @GGNOOr#c[U[R5(aURS5OUn[U[R5(aU$[ SR U55e)a%Converts bytes to a string value, if necessary. Args: value: The string/bytes value to be converted. Returns: The original value converted to unicode (if bytes) or as passed in if it started out as unicode. Raises: ValueError if the value could not be converted to unicode. utf-8z'{0!r} could not be converted to unicode)r(r)rvdecodertr>r)rCrxs r _from_bytesr}7s^E3??33ll7#9> &#--((  5 < rs 4       8 $".0D-/0%7!4'F`JF &(..27&>&&3P:E,< ,r#