
    h9                     @   d Z ddlmZ ddlZddlZddlZddlZddlZddlm	Z	 ddlm
Z
 ddlmZ ddlmZ ddlmZ d	Zd
ZdZdZdZdZdZdZ ej        e          Zd ZefdZefdZd$dZd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&d Z'd  Z(d! Z) G d" d#e*          Z+dS )%z4Shared utilities used by both downloads and uploads.    )absolute_importN)parse_qs)	urlencode)urlsplit)
urlunsplit)commonrangezcontent-rangezcontent-encodingzCurrently using crcmod in pure python form. This is a slow implementation. Python 3 has a faster implementation, `google-crc32c`, which will be used if it is installed.zx-goog-generationzx-goog-hashzx-goog-stored-content-encodingzNo {checksum_type} checksum was returned from the service while downloading {}
(which happens for composite objects), so client-side content integrity
checking is not being performed.c                      dS )zSimple default callback.N r       c/var/www/html/e360mart/e360mart_env/lib/python3.11/site-packages/google/resumable_media/_helpers.py
do_nothingr   5         r   c                 p     ||           }||vr  |             t          j        | d|          ||         S )a  Checks that a specific header is in a headers dictionary.

    Args:
        response (object): An HTTP response object, expected to have a
            ``headers`` attribute that is a ``Mapping[str, str]``.
        name (str): The name of a required header.
        get_headers (Callable[Any, Mapping[str, str]]): Helper to get headers
            from an HTTP response.
        callback (Optional[Callable]): A callback that takes no arguments,
            to be executed when an exception is being raised.

    Returns:
        str: The desired header.

    Raises:
        ~google.resumable_media.common.InvalidResponse: If the header
            is missing.
    z$Response headers must contain header)r   InvalidResponse)responsenameget_headerscallbackheaderss        r   header_requiredr   9   sR    & k(##G7


$<d
 
 	
 4=r   c                 ~     ||           }||vr-|t           j        vr
 |             t          j        | d|dg|R  |S )a`  Require a response has a status code among a list.

    Args:
        response (object): The HTTP response object.
        status_codes (tuple): The acceptable status codes.
        get_status_code (Callable[Any, int]): Helper to get a status code
            from a response.
        callback (Optional[Callable]): A callback that takes no arguments,
            to be executed when an exception is being raised.

    Returns:
        int: The status code.

    Raises:
        ~google.resumable_media.common.InvalidResponse: If the status code
            is not one of the values in ``status_codes``.
    zRequest failed with status codezExpected one of)r   	RETRYABLEr   )r   status_codesget_status_coder   status_codes        r   require_status_coder   V   so    $ "/(++K,&&f...HJJJ$-	

 
 
 
 	
 r          @c                 Z    || z  }||k    r|}t          j        dd          }||d|z  z   fS )a  Calculate the amount of time to wait before a retry attempt.

    Wait time grows exponentially with the number of attempts, until
    ``max_sleep``.

    A random amount of jitter (between 0 and 1 seconds) is added to spread out
    retry attempts from different clients.

    Args:
        base_wait (float): The "base" wait time (i.e. without any jitter)
            that will be multiplied until it reaches the maximum sleep.
        max_sleep (float): Maximum value that a sleep time is allowed to be.
        multiplier (float): Multiplier to apply to the base wait.

    Returns:
        Tuple[float, float]: The new base wait time as well as the wait time
        to be applied (with a random amount of jitter between 0 and 1 seconds
        added).
    r   i  gMbP?)randomrandint)	base_wait	max_sleep
multipliernew_base_wait	jitter_mss        r   calculate_retry_waitr'   v   sD    ( *My  !q$''I-%)*;;;;r   c                      	 ddl } |                                 }n[# t          $ rN 	 ddl}|j                            d          }t                       n# t          $ r t          d          w xY wY nw xY w|S )zGet crc32c object
    Attempt to use the Google-CRC32c package. If it isn't available, try
    to use CRCMod. CRCMod might be using a 'slow' varietal. If so, warn...
    r   Nzcrc-32cz3Failed to import either `google-crc32c` or `crcmod`)google_crc32cChecksumImportErrorcrcmod
predefinedCrc_is_fast_crcmod)r)   crc_objr,   s      r   _get_crc32c_objectr1      s    
U((** U U U	UMMM'++I66G 	U 	U 	USTTT	U U Ns&    
A3,AA3A--A32A3c                      t          dt                      t                      dgd          } t          | dd          }|s!t	          j        t          t          d           |S )Nzcrcmod.crcmod_usingExtensionr   F   )
stacklevel)
__import__globalslocalsgetattrwarningswarn_SLOW_CRC32C_WARNINGRuntimeWarning)nested_crcmodfast_crcs     r   r/   r/      se    				 M }&7??H J*NqIIIIOr   c                     | dk    rdS | S )Nmd5md5Hashr   checksum_types    r   _get_metadata_keyrE      s    yr   c                 T    t          j        |           }|                    d          S )zConvert a checksum object into a digest encoded for an HTTP header.

    Args:
        bytes: A checksum digest bytestring.

    Returns:
        str: A base64 string representation of the input.
    zutf-8)base64	b64encodedecode)digest_bytestringencoded_digests     r   prepare_checksum_digestrL      s)     %&788N  )))r   c                    |dvrt          d          |dv r ||           }t          |                    t                    | |          }|Wt                              ||                                          }t                              |           t                      }n9|dk    rt          j                    }nt                      }nd}t                      }||fS )a  Get the expected checksum and checksum object for the download response.

    Args:
        response (~requests.Response): The HTTP response object.
        get_headers (callable: response->dict): returns response headers.
        media_url (str): The URL containing the media to be downloaded.
        checksum_type Optional(str): The checksum type to read from the headers,
            exactly as it will appear in the headers (case-sensitive). Must be
            "md5", "crc32c" or None.

    Returns:
        Tuple (Optional[str], object): The expected checksum of the response,
        if it can be detected from the ``X-Goog-Hash`` header, and the
        appropriate checksum object for the expected checksum.
    rA   crc32cN4checksum must be ``'md5'``, ``'crc32c'`` or ``None``rA   rO   checksum_labelNrC   rA   )
ValueError_parse_checksum_headerget_HASH_HEADER_MISSING_CHECKSUMformatupper_LOGGERinfo_DoNothingHashhashlibrA   r1   )r   r   	media_urlrD   r   expected_checksummsgchecksum_objects           r   _get_expected_checksumrc      s      333OPPP	+	+	++h''2KK%%x
 
 
 $#**)<)<)>)> +  C LL,..OO%%")+--"4"6"6 (**//r   c                     |dvrt          d          |dv r6 ||           }t          |                    t                    | |          }nd}|S )a  Get the computed checksum and checksum object from the response headers.

    Args:
        response (~requests.Response): The HTTP response object.
        get_headers (callable: response->dict): returns response headers.
        checksum_type Optional(str): The checksum type to read from the headers,
            exactly as it will appear in the headers (case-sensitive). Must be
            "md5", "crc32c" or None.

    Returns:
        Tuple (Optional[str], object): The checksum of the response,
        if it can be detected from the ``X-Goog-Hash`` header, and the
        appropriate checksum object for the expected checksum.
    rN   rP   rQ   rR   N)rT   rU   rV   rW   )r   r   rD   r   remote_checksums        r   #_get_uploaded_checksum_from_headersrf      sp     333OPPP	+	+	++h''0KK%%x
 
 
 r   c                 ~   | dS g }|                      d          D ]H}|                     dd          \  }}|                                |k    r|                    |           It          |          dk    rdS t          |          dk    r|d         S t	          j        |d                    |          | |          )aD  Parses the checksum header from an ``X-Goog-Hash`` value.

    .. _header reference: https://cloud.google.com/storage/docs/                          xml-api/reference-headers#xgooghash

    Expects ``header_value`` (if not :data:`None`) to be in one of the three
    following formats:

    * ``crc32c=n03x6A==``
    * ``md5=Ojk9c3dhfxgoKVVHYwFbHQ==``
    * ``crc32c=n03x6A==,md5=Ojk9c3dhfxgoKVVHYwFbHQ==``

    See the `header reference`_ for more information.

    Args:
        header_value (Optional[str]): The ``X-Goog-Hash`` header from
            a download response.
        response (~requests.Response): The HTTP response object.
        checksum_label (str): The label of the header value to read, as in the
            examples above. Typically "md5" or "crc32c"

    Returns:
        Optional[str]: The expected checksum of the response, if it
        can be detected from the ``X-Goog-Hash`` header; otherwise, None.

    Raises:
        ~google.resumable_media.common.InvalidResponse: If there are
            multiple checksums of the requested type in ``header_value``.
    N,=   r   z.X-Goog-Hash header had multiple ``{}`` values.)splitlstripappendlenr   r   rY   )header_valuer   rS   matcheschecksumr   values          r   rU   rU     s    < tG &&s++ " "nnS!,,e;;==N**NN5!!!
7||qt	W		qz$<CCNSS	
 
 	
r   c                     | dk    rt          j                    S | dk    rt                      S | dS t          d          )z~Respond with a checksum object for a supported type, if not None.

    Raises ValueError if checksum_type is unsupported.
    rA   rO   NrP   )r^   rA   r1   rT   rC   s    r   _get_checksum_objectrt   G  sL    
 {}}	(	"	"!###		tOPPPr   c                 t     ||           }|                     t          d          }|dS t          |          S )a  Parses the generation header from an ``X-Goog-Generation`` value.

    Args:
        response (~requests.Response): The HTTP response object.
        get_headers (callable: response->dict): returns response headers.

    Returns:
        Optional[long]: The object generation from the response, if it
        can be detected from the ``X-Goog-Generation`` header; otherwise, None.
    N)rV   _GENERATION_HEADERint)r   r   r   object_generations       r   _parse_generation_headerry   V  sB     k(##G$6== t$%%%r   c                     t          |           \  }}}}}t          |          }|                    dd          }|dS t          |d                   S )zRetrieve the object generation query param specified in the media url.

    Args:
        media_url (str): The URL containing the media to be downloaded.

    Returns:
        long: The object generation from the media url if exists; otherwise, None.
    
generationNr   )r   r   rV   rw   )r_   _queryquery_paramsrx   s        r   _get_generation_from_urlr   j  s\     !++Aq!UAE??L$((t<< t$Q'(((r   c                     t          |          dk    r| S t          |           \  }}}}}t          |          }i ||}t          |d          }t	          |||||f          S )a  Add query parameters to a base url.

    Args:
        media_url (str): The URL containing the media to be downloaded.
        query_params (dict): Names and values of the query parameters to add.

    Returns:
        str: URL with additional query strings appended.
    r   T)doseq)rn   r   r   r   r   )	r_   r~   schemenetlocpathr}   fragparams
new_paramss	            r   add_query_parametersr   ~  sz     <A(0(;(;%FFD%e__F+F+l+Jj---EvvtUD9:::r   c                      ||           }|                     t                    dk    o|                     t                    dk    S )a  Returns True if the object was served decompressed. This happens when the
    "x-goog-stored-content-encoding" header is "gzip" and "content-encoding" header
    is not "gzip". See more at: https://cloud.google.com/storage/docs/transcoding#transcoding_and_gzip
    Args:
        response (~requests.Response): The HTTP response object.
        get_headers (callable: response->dict): returns response headers.
    Returns:
        bool: Returns True if decompressive transcoding has occurred; otherwise, False.
    gzip)rV   _STORED_CONTENT_ENCODING_HEADERCONTENT_ENCODING_HEADER)r   r   r   s      r   _is_decompressive_transcodingr     sG     k(##G344> 	;KK/00F:r   c                       e Zd ZdZd ZdS )r]   zDo-nothing hash object.

    Intended as a stand-in for ``hashlib.md5`` or a crc32c checksum
    implementation in cases where it isn't necessary to compute the hash.
    c                     dS )zDo-nothing ``update`` method.

        Intended to match the interface of ``hashlib.md5`` and other checksums.

        Args:
            unused_chunk (bytes): A chunk of data.
        Nr   )selfunused_chunks     r   updatez_DoNothingHash.update  r   r   N)__name__
__module____qualname____doc__r   r   r   r   r]   r]     s-             r   r]   )r   ),r   
__future__r   rG   r^   loggingr    r:   urllib.parser   r   r   r   google.resumable_mediar   RANGE_HEADERCONTENT_RANGE_HEADERr   r<   rv   rW   r   rX   	getLoggerr   r[   r   r   r   r'   r1   r/   rE   rL   rc   rf   rU   rt   ry   r   r   r   objectr]   r   r   r   <module>r      s8   ; : & & & & & &      ! ! ! ! ! ! " " " " " " ! ! ! ! ! ! # # # # # # ) ) ) ) ) ) & , - 
 ) "B $  '
H
%
%# # # ;E    : KU    @< < < <8  ,    * * *'0 '0 '0T  82
 2
 2
jQ Q Q& & &() ) )(; ; ;*  "    V     r   