(phVSrSSKrSSKrSSKrSSKrSSKrSSKrSSKr SSK J r SSK J r SSK Jr SSKJr SrSrS rS r\"\"\R.S - 55rS R3\5rS rSrSrSr\R>"S\R@S9r!Sr"Sr#Sr$Sr%Sr&Sr'Sr(Sr)Sr*Sr+Sr,Sr-Sr."S S!\/5r0"S"S#\05r1"S$S%\05r2"S&S'\05r3"S(S)\05r4"S*S+\05r5S,r6S-r7S.r8S/r9S0r:g)1zVirtual bases classes for uploading media via Google APIs. Supported here are: * simple (media) uploads * multipart uploads that contain both metadata and a small file as payload * resumable uploads (with metadata as well) N)resumable_media)_helpers)common) ElementTreez content-typezbytes {:d}-{:d}/{:d}zbytes {:d}-{:d}/*z bytes */{:d}z==============={{:0{:d}d}}==s--s s3 content-type: application/json; charset=UTF-8 smultipart/related; boundary="zbytes=0-(?P\d+))flagszBytes stream is in unexpected state. The local stream has had {:d} bytes read from it while {:d} bytes have already been updated (they should match).zQ{:d} bytes have been read from the stream, which exceeds the expected total {:d}.DELETEPOSTPUTzjThe computed ``{}`` checksum, ``{}``, and the checksum reported by the remote host, ``{}``, did not match.zGResponse metadata had no ``{}`` value; checksum could not be validated.zFResponse headers had no ``{}`` value; checksum could not be validated.z?uploadsz'?partNumber={part}&uploadId={upload_id}z){http://s3.amazonaws.com/doc/2006-03-01/}UploadIdz?uploadId={upload_id}ch\rSrSrSrS Sjr\S5rSr\ S5r \ S5r \ S 5r S r g) UploadBaseOa|Base class for upload helpers. Defines core shared behavior across different upload types. Args: upload_url (str): The URL where the content will be uploaded. headers (Optional[Mapping[str, str]]): Extra headers that should be sent with the request, e.g. headers for encrypted data. Attributes: upload_url (str): The URL where the content will be uploaded. NchXlUc0nX lSUl[R"5Ulg)NF) upload_url_headers _finishedr RetryStrategy_retry_strategy)selfrheaderss Q/var/www/html/venv/lib/python3.13/site-packages/google/resumable_media/_upload.py__init__UploadBase.__init__]s.$ ?G %335cUR$)z2bool: Flag indicating if the upload has completed.)rrs rfinishedUploadBase.finishedes~~rcSUl[R"U[RR 4UR 5 g)aProcess the response from an HTTP request. This is everything that must be done after a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.InvalidResponse: If the status code is not 200. .. _sans-I/O: https://sans-io.readthedocs.io/ TN)rrrequire_status_codehttpclientOK_get_status_coderresponses r_process_responseUploadBase._process_responsejs.$$$X /@$BWBWXrc[S5e)zAccess the status code from an HTTP response. Args: response (object): The HTTP response object. Raises: NotImplementedError: Always, since virtual. This implementation is virtual.NotImplementedErrorr's rr%UploadBase._get_status_code""CDDrc[S5e)zAccess the headers from an HTTP response. Args: response (object): The HTTP response object. Raises: NotImplementedError: Always, since virtual. r+r,r.s r _get_headersUploadBase._get_headersr0rc[S5e)zAccess the response body from an HTTP response. Args: response (object): The HTTP response object. Raises: NotImplementedError: Always, since virtual. r+r,r.s r _get_bodyUploadBase._get_bodyr0r)rrrrN)__name__ __module__ __qualname____firstlineno____doc__rpropertyrr( staticmethodr%r2r5__static_attributes__rrrrOsh 6Y* E E E E E Errc(\rSrSrSrSrSSjrSrg) SimpleUploadaUpload a resource to a Google API. A **simple** media upload sends no metadata and completes the upload in a single request. Args: upload_url (str): The URL where the content will be uploaded. headers (Optional[Mapping[str, str]]): Extra headers that should be sent with the request, e.g. headers for encrypted data. Attributes: upload_url (str): The URL where the content will be uploaded. cUR(a [S5e[U[5(d[ S[ U55eX R ['[URXR 4$)a!Prepare the contents of an HTTP request. This is everything that must be done before a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. .. note: This method will be used only once, so ``headers`` will be mutated by having a new key added to it. Args: data (bytes): The resource content to be uploaded. content_type (str): The content type for the request. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always POST) * the URL for the request * the body of the request * headers for the request Raises: ValueError: If the current upload has already finished. TypeError: If ``data`` isn't bytes. .. _sans-I/O: https://sans-io.readthedocs.io/ An upload can only be used once.`data` must be bytes, received) r ValueError isinstancebytes TypeErrortyper_CONTENT_TYPE_HEADER_POSTr)rdata content_types r_prepare_requestSimpleUpload._prepare_requestsX< ==?@ @$&&[[U] XS9 X0lgNr)superrXr_checksum_type)rrrchecksum __class__s rrMultipartUpload.__init__s ot-j-J&rcUR(a [S5e[U[5(d[ S[ U55e[ R"UR5nUbYURU5 [ R"UR55n[ R"UR5nXRU'[XU5upx[U-S-n XR[ '["UR$XpR4$)aPrepare the contents of an HTTP request. This is everything that must be done before a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. .. note: This method will be used only once, so ``headers`` will be mutated by having a new key added to it. Args: data (bytes): The resource content to be uploaded. metadata (Mapping[str, str]): The resource metadata, such as an ACL list. content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always POST) * the URL for the request * the body of the request * headers for the request Raises: ValueError: If the current upload has already finished. TypeError: If ``data`` isn't bytes. .. _sans-I/O: https://sans-io.readthedocs.io/ rErF")rrGrHrIrJrKr_get_checksum_objectr^updateprepare_checksum_digestdigest_get_metadata_keyconstruct_multipart_request_RELATED_HEADERrrLrMr) rrNmetadatarOchecksum_objectactual_checksum metadata_keycontentmultipart_boundarymultipart_content_types rrP MultipartUpload._prepare_requestsB ==?@ @$&&>?U?U?WXO#55d6I6IJL%4\ "&A L' #"13E!E!L.D *+doow ==rc[S5e)a>Transmit the resource to be uploaded. Args: transport (object): An object which can make authenticated requests. data (bytes): The resource content to be uploaded. metadata (Mapping[str, str]): The resource metadata, such as an ACL list. content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. timeout (Optional[Union[float, Tuple[float, float]]]): The number of seconds to wait for the server response. Depending on the retry strategy, a request may be repeated several times using the same timeout each time. Can also be passed as a tuple (connect_timeout, read_timeout). See :meth:`requests.Session.request` documentation for details. Raises: NotImplementedError: Always, since virtual. r+r,)rrSrNrkrOrTs rrUMultipartUpload.transmit>,""CDDr)r^NNr7) r8r9r:r;r<rrPrUr? __classcell__r`s@rrXrXs&'4>lEErrXc^\rSrSrSrSU4Sjjr\S5r\S5r\S5r \S5r \S5r SS jr S r SS jrS rS rSrSrSrSSjrSrSrSrSrU=r$)ResumableUploadiWaInitiate and fulfill a resumable upload to a Google API. A **resumable** upload sends an initial request with the resource metadata and then gets assigned an upload ID / upload URL to send bytes to. Using the upload URL, the upload is then done in chunks (determined by the user) until all bytes have been uploaded. Args: upload_url (str): The URL where the resumable upload will be initiated. chunk_size (int): The size of each chunk used to upload the resource. headers (Optional[Mapping[str, str]]): Extra headers that should be sent with every request. checksum (Optional([str])): The type of checksum to compute to verify the integrity of the object. After the upload is complete, the server-computed checksum of the resulting object will be read and google.resumable_media.common.DataCorruption will be raised on a mismatch. The corrupted file will not be deleted from the remote host automatically. Supported values are "md5", "crc32c" and None. The default is None. Attributes: upload_url (str): The URL where the content will be uploaded. Raises: ValueError: If ``chunk_size`` is not a multiple of :data:`.UPLOAD_CHUNK_SIZE`. c4>[[U] XS9 U[R-S:wa+[ SR [RS- 55eX lSUlSUl SUl SUl X0l SUl SUlSUlSUlg)Nr\rz{} KB must divide chunk sizeiF)r]rzrrUPLOAD_CHUNK_SIZErGformat _chunk_size_stream _content_type_bytes_uploaded_bytes_checksummedr^_checksum_object _total_bytes_resumable_url_invalid)rr chunk_sizer_rr`s rrResumableUpload.__init__ts ot-j-J 99 9Q >.55#55<  & ! "#& $ " rcUR$)zbool: Indicates if the upload is in an invalid state. This will occur if a call to :meth:`transmit_next_chunk` fails. To recover from such a failure, call :meth:`recover`. rrs rinvalidResumableUpload.invalids}}rcUR$)z8int: The size of each chunk used to upload the resource.)r~rs rrResumableUpload.chunk_sizesrcUR$)z;Optional[str]: The URL of the in-progress resumable upload.)rrs r resumable_urlResumableUpload.resumable_urls"""rcUR$)z-int: Number of bytes that have been uploaded.)rrs rbytes_uploadedResumableUpload.bytes_uploadeds###rcUR$)aOptional[int]: The total number of bytes to be uploaded. If this upload is initiated (via :meth:`initiate`) with ``stream_final=True``, this value will be populated based on the size of the ``stream`` being uploaded. (By default ``stream_final=True``.) If this upload is initiated with ``stream_final=False``, :attr:`total_bytes` will be :data:`None` since it cannot be determined from the stream. )rrs r total_bytesResumableUpload.total_bytess   rcURb [S5eUR5S:wa [S5eXlX0l[ R RUR5n[ R RUR5nSU;dSU;a0URE[U0EnO0URE[SSU0EnUbX@l OU(a[U5Ul URbSRUR5n XS '[ R""U5R%S 5n [&URX4$) aPrepare the contents of HTTP request to initiate upload. This is everything that must be done before a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: stream (IO[bytes]): The stream (i.e. file-like object) that will be uploaded. The stream **must** be at the beginning (i.e. ``stream.tell() == 0``). metadata (Mapping[str, str]): The resource metadata, such as an ACL list. content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. total_bytes (Optional[int]): The total number of bytes to be uploaded. If specified, the upload size **will not** be determined from the stream (even if ``stream_final=True``). stream_final (Optional[bool]): Indicates if the ``stream`` is "final" (i.e. no more bytes will be added to it). In this case we determine the upload size from the size of the stream. If ``total_bytes`` is passed, this argument will be ignored. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always POST) * the URL for the request * the body of the request * headers for the request Raises: ValueError: If the current upload has already been initiated. ValueError: If ``stream`` is not at the beginning. .. _sans-I/O: https://sans-io.readthedocs.io/ 'This upload has already been initiated.rzStream must be at beginning.zx-goog-signaturezX-Goog-Signaturezapplication/json; charset=UTF-8zx-upload-content-typez{:d}zx-upload-content-lengthutf-8)rrGtellrrurllibparseurlparserparse_qsqueryrrLrget_total_bytesr}jsondumpsencoderM) rstreamrkrOr stream_final parse_result parsed_queryrcontent_lengthpayloads r_prepare_initiate_request)ResumableUpload._prepare_initiate_requests0N    )FG G ;;=A ;< < )||,,T__= ||,,\-?-?@  -1C|1SKK(#?!#CD rcURcg[R"UR5nUR5nUR U5nUc:[ R "U[RU5URU55e[R"URR55nXT:waC[ R"U[RURR5XT55eg)aCheck the computed checksum, if any, against the recieved metadata. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.DataCorruption: If the checksum computed locally and the checksum reported by the remote host do not match. N)r^rrhrgetrr0_UPLOAD_METADATA_NO_APPROPRIATE_CHECKSUM_MESSAGEr}r2rfrrgDataCorruption!_UPLOAD_CHECKSUM_MISMATCH_MESSAGEupper)rr'rnrkremote_checksumlocal_checksums rr"ResumableUpload._validate_checksums    & 11$2E2EF ==?",,|4  "((@GG U!!(+  "99  ! ! ( ( *   ,''188''--/  -rc[S5e)aTTransmit the next chunk of the resource to be uploaded. If the current upload was initiated with ``stream_final=False``, this method will dynamically determine if the upload has completed. The upload will be considered complete if the stream produces fewer than :attr:`chunk_size` bytes when a chunk is read from it. Args: transport (object): An object which can make authenticated requests. timeout (Optional[Union[float, Tuple[float, float]]]): The number of seconds to wait for the server response. Depending on the retry strategy, a request may be repeated several times using the same timeout each time. Can also be passed as a tuple (connect_timeout, read_timeout). See :meth:`requests.Session.request` documentation for details. Raises: NotImplementedError: Always, since virtual. r+r,rrSrTs rtransmit_next_chunk#ResumableUpload.transmit_next_chunkrurcN[RS0n[URSU4$)aPrepare the contents of HTTP request to recover from failure. This is everything that must be done before a request that doesn't require network I/O. This is based on the `sans-I/O`_ philosophy. We assume that the :attr:`resumable_url` is set (i.e. the only way the upload can end up :attr:`invalid` is if it has been initiated. Returns: Tuple[str, str, NoneType, Mapping[str, str]]: The quadruple * HTTP verb for the request (always PUT) * the URL for the request * the body of the request (always :data:`None`) * headers for the request The headers **do not** incorporate the ``_headers`` on the current instance. .. _sans-I/O: https://sans-io.readthedocs.io/ z bytes */*N)rrrr)rrs r_prepare_recover_request(ResumableUpload._prepare_recover_requests),00+>T''w66rc[R"U[RR4UR 5 UR U5n[RU;agU[Rn[RU5nUc[R"USUS5e[URS55S-UlOSUlURR!UR5 SUlg)a?Process the response from an HTTP request to recover from failure. This is everything that must be done after a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.InvalidResponse: If the status code is not 308. ~google.resumable_media.common.InvalidResponse: If the status code is 308 and the ``range`` header is not of the form ``bytes 0-{end}``. .. _sans-I/O: https://sans-io.readthedocs.io/ NrrrrrF)rr!r"r#rr%r2rrrrrrrrrseekr)rr'rrrs r_process_recover_response)ResumableUpload._process_recover_response*s& $$ t{{5579N9N ##H-  G +!("7"78K#))+6E},,/@  $'u{{:'>#?!#CD $%D  $../ rc[S5e)aRecover from a failure. This method should be used when a :class:`ResumableUpload` is in an :attr:`~ResumableUpload.invalid` state due to a request failure. This will verify the progress with the server and make sure the current upload is in a valid state before :meth:`transmit_next_chunk` can be used again. Args: transport (object): An object which can make authenticated requests. Raises: NotImplementedError: Always, since virtual. r+r,)rrSs rrecoverResumableUpload.recoverSs"""CDDr) rrrr^r~rrrrrrrv)NT)NTNr7)r8r9r:r;r<rr=rrrrrrrrrPrrrrrrrrr?rwrxs@rrzrzWs8&  ##$$ ! !NRG8R @3Ej7:r-,9DvBE072'REErrzc^\rSrSrSrSU4Sjjr\S5rSrSr Sr SSjr S r S r SS jrS rS rSSjrSrU=r$)XMLMPUContaineriga Initiate and close an upload using the XML MPU API. An XML MPU sends an initial request and then receives an upload ID. Using the upload ID, the upload is then done in numbered parts and the parts can be uploaded concurrently. In order to avoid concurrency issues with this container object, the uploading of individual parts is handled separately, by XMLMPUPart objects spawned from this container class. The XMLMPUPart objects are not necessarily in the same process as the container, so they do not update the container automatically. MPUs are sometimes referred to as "Multipart Uploads", which is ambiguous given the JSON multipart upload, so the abbreviation "MPU" will be used throughout. See: https://cloud.google.com/storage/docs/multipart-uploads Args: upload_url (str): The URL of the object (without query parameters). The initiate, PUT, and finalization requests will all use this URL, with varying query parameters. filename (str): The name (path) of the file to upload. headers (Optional[Mapping[str, str]]): Extra headers that should be sent with every request. Attributes: upload_url (str): The URL where the content will be uploaded. upload_id (Optional(str)): The ID of the upload from the initialization response. cF>[TU]XS9 X lX@l0Ulgr[)r]r _filename _upload_id_parts)rrfilenamer upload_idr`s rrXMLMPUContainer.__init__s$ 5!# rcUR$r7rrs rrXMLMPUContainer.upload_id rc X RU'g)aRegister an uploaded part by part number and corresponding etag. XMLMPUPart objects represent individual parts, and their part number and etag can be registered to the container object with this method and therefore incorporated in the finalize() call to finish the upload. This method accepts part_number and etag, but not XMLMPUPart objects themselves, to reduce the complexity involved in running XMLMPUPart uploads in separate processes. Args: part_number (int): The part number. Parts are assembled into the final uploaded object with finalize() in order of their part numbers. etag (str): The etag included in the server response after upload. N)r)r part_numberetags r register_partXMLMPUContainer.register_parts"$( K rcURb [S5eUR[-n0URE[ U0En[ USU4$)aPrepare the contents of HTTP request to initiate upload. This is everything that must be done before a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always POST) * the URL for the request * the body of the request * headers for the request Raises: ValueError: If the current upload has already been initiated. .. _sans-I/O: https://sans-io.readthedocs.io/ Nr)rrGr_MPU_INITIATE_QUERYrrLrM)rrO initiate_urlrs rr)XMLMPUContainer._prepare_initiate_requestsW0 >> %FG G)<<  mm , lD'11rc[R"U[RR4UR 5 [ R"UR5nUR[[-5RUl g)a_Process the response from an HTTP request that initiated the upload. This is everything that must be done after a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. This method takes the URL from the ``Location`` header and stores it for future use. Within that URL, we assume the ``upload_id`` query parameter has been included, but we do not check. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.InvalidResponse: If the status code is not 200. .. _sans-I/O: https://sans-io.readthedocs.io/ N) rr!r"r#r$r%r fromstringtextfind_S3_COMPAT_XML_NAMESPACE_UPLOAD_ID_NODEr)rr'roots rr*XMLMPUContainer._process_initiate_responsesW( $$X /@$BWBWX%%hmm4))$<$NOTTrc[S5e)aInitiate an MPU and record the upload ID. Args: transport (object): An object which can make authenticated requests. content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. timeout (Optional[Union[float, Tuple[float, float]]]): The number of seconds to wait for the server response. Depending on the retry strategy, a request may be repeated several times using the same timeout each time. Can also be passed as a tuple (connect_timeout, read_timeout). See :meth:`requests.Session.request` documentation for details. Raises: NotImplementedError: Always, since virtual. r+r,)rrSrOrTs rrXMLMPUContainer.initiates0""CDDrcURc [S5e[RURS9nUR U-n[ R"S5nURR5H]upE[ R"US5n[U5[ R"US5l U[ R"US5l M_ [ R"U5n[X'UR4$)aPrepare the contents of an HTTP request to finalize the upload. All of the parts must be registered before calling this method. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always POST) * the URL for the request * the body of the request * headers for the request Raises: ValueError: If the upload has not been initiated. 'This upload has not yet been initiated.rCompleteMultipartUploadPart PartNumberETag)rrG_MPU_FINAL_QUERY_TEMPLATEr}rrrElementritems SubElementstrr tostringrMr)r final_query finalize_urlfinal_xml_rootrrpartrs r_prepare_finalize_request)XMLMPUContainer._prepare_finalize_requests >> !FG G/666Q 4 $,,-FG!%!2!2!4 K)).&AD>A+>NK " "4 6 ;8> !FG G077$//7R __|3  D$--77rcz[R"U[RR4UR 5 g)aProcess the response from an HTTP request that canceled the upload. This is everything that must be done after a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.InvalidResponse: If the status code is not 204. .. _sans-I/O: https://sans-io.readthedocs.io/ N)rr!r"r# NO_CONTENTr%r&s r_process_cancel_response(XMLMPUContainer._process_cancel_responseWs," $$ t{{--/1F1F rc[S5e)aoCancel an MPU request and permanently delete any uploaded parts. This cannot be undone. Args: transport (object): An object which can make authenticated requests. timeout (Optional[Union[float, Tuple[float, float]]]): The number of seconds to wait for the server response. Depending on the retry strategy, a request may be repeated several times using the same timeout each time. Can also be passed as a tuple (connect_timeout, read_timeout). See :meth:`requests.Session.request` documentation for details. Raises: NotImplementedError: Always, since virtual. r+r,rs rcancelXMLMPUContainer.cancells.""CDDr)rrrrrvr7)r8r9r:r;r<rr=rrrrrr"r%r(r/r3r6r?rwrxs@rrrgsn@ (&!2FU8 E4;:.E.8* 0EErrc^\rSrSrSrSU4Sjjr\S5r\S5r\S5r \S5r \S5r \S 5r S r S rSS jrS rSrU=r$) XMLMPUPartia8Upload a single part of an existing XML MPU container. An XML MPU sends an initial request and then receives an upload ID. Using the upload ID, the upload is then done in numbered parts and the parts can be uploaded concurrently. In order to avoid concurrency issues with the container object, the uploading of individual parts is handled separately by multiple objects of this class. Once a part is uploaded, it can be registered with the container with `container.register_part(part.part_number, part.etag)`. MPUs are sometimes referred to as "Multipart Uploads", which is ambiguous given the JSON multipart upload, so the abbreviation "MPU" will be used throughout. See: https://cloud.google.com/storage/docs/multipart-uploads Args: upload_url (str): The URL of the object (without query parameters). upload_id (str): The ID of the upload from the initialization response. filename (str): The name (path) of the file to upload. start (int): The byte index of the beginning of the part. end (int): The byte index of the end of the part. part_number (int): The part number. Part numbers will be assembled in sequential order when the container is finalized. headers (Optional[Mapping[str, str]]): Extra headers that should be sent with every request. checksum (Optional([str])): The type of checksum to compute to verify the integrity of the object. The request headers will be amended to include the computed value. Supported values are "md5", "crc32c" and None. The default is None. Attributes: upload_url (str): The URL of the object (without query parameters). upload_id (str): The ID of the upload from the initialization response. filename (str): The name (path) of the file to upload. start (int): The byte index of the beginning of the part. end (int): The byte index of the end of the part. part_number (int): The part number. Part numbers will be assembled in sequential order when the container is finalized. etag (Optional(str)): The etag returned by the service after upload. c >[T U]XS9 X0lX@lXPlX lX`lSUlXlSUl gr[) r]rr_start_endr _part_number_etagr^r) rrrrstartendrrr_r`s rrXMLMPUPart.__init__sD 5!  #' & $rcUR$r7)r=rs rrXMLMPUPart.part_numbers   rcUR$r7rrs rrXMLMPUPart.upload_idrrcUR$r7)rrs rrXMLMPUPart.filenames ~~rcUR$r7)r>rs rrXMLMPUPart.etags zzrcUR$r7)r;rs rr?XMLMPUPart.starts {{rcUR$r7)r<rs rr@XMLMPUPart.ends yyrcPUR(a [S5e[URS5nUR UR 5 UR URUR - 5nSSS5 [R"UR5Ul URbURRW5 [RURUR S9nUR"U-n[$UWUR&4$!,(df  N=f)aPrepare the contents of HTTP request to upload a part. This is everything that must be done before a request that doesn't require network I/O. This is based on the `sans-I/O`_ philosophy. For the time being, this **does require** some form of I/O to read a part from ``stream`` (via :func:`get_part_payload`). However, this will (almost) certainly not be network I/O. Returns: Tuple[str, str, bytes, Mapping[str, str]]: The quadruple * HTTP verb for the request (always PUT) * the URL for the request * the body of the request * headers for the request The headers incorporate the ``_headers`` on the current instance. Raises: ValueError: If the current upload has finished. .. _sans-I/O: https://sans-io.readthedocs.io/ z$This part has already been uploaded.brN)r!r)rrGopenrrr;readr<rrdr^rre_MPU_PART_QUERY_TEMPLATEr}r=rrrr)rfr part_queryrs r_prepare_upload_request"XMLMPUPart._prepare_upload_requests2 ==CD D $..$ '1 FF4;; ffTYY45G(!) = =d>Q>Q R  ,  ! ! ( ( 1-44""doo5 __z1 Z$--77( 's AD D%c[R"U[RR4UR 5 UR U5 [R"USUR5nX l SUl g)aProcess the response from an HTTP request. This is everything that must be done after a request that doesn't require network I/O (or other I/O). This is based on the `sans-I/O`_ philosophy. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.InvalidResponse: If the status code is not 200 or the response is missing data. .. _sans-I/O: https://sans-io.readthedocs.io/ rTN) rr!r"r#r$r%rrr2r>r)rr'rs r_process_upload_response#XMLMPUPart._process_upload_response sb $$  [[^^   ! ! )''&$:K:KL rc[S5e)a'Upload the part. Args: transport (object): An object which can make authenticated requests. timeout (Optional[Union[float, Tuple[float, float]]]): The number of seconds to wait for the server response. Depending on the retry strategy, a request may be repeated several times using the same timeout each time. Can also be passed as a tuple (connect_timeout, read_timeout). See :meth:`requests.Session.request` documentation for details. Raises: NotImplementedError: Always, since virtual. r+r,rs ruploadXMLMPUPart.upload%r*rcURcg[R"XRUR5nUcZ[R"UR5n[ R "U[RU5URU55e[R"URR55nXB:waC[ R"U[RURR5XB55eg)aCheck the computed checksum, if any, against the response headers. Args: response (object): The HTTP response object. Raises: ~google.resumable_media.common.DataCorruption: If the checksum computed locally and the checksum reported by the remote host do not match. N)r^r#_get_uploaded_checksum_from_headersr2rhrrrr}rfrrgrrr)rr'rrnrs rrXMLMPUPart._validate_checksum<s    & "FF '')<)<   "#55d6I6IJL((@GG U!!(+  "99  ! ! ( ( *   ,''188''--/  -r) rr^r<r>rrr=r;rrvr7)r8r9r:r;r<rr=rrrrr?r@rUrXr[rr?rwrxs@rr9r9s)f%*!!(8T>E.""rr9c[R"[R5n[R U5nUR S5$)zGet a random boundary for a multipart request. Returns: bytes: The boundary used to separate parts of a multipart request. r)random randrangesysmaxsize_BOUNDARY_FORMATr}r) random_intboundarys r get_boundaryrhas9 !!#++.J&&z2H ??7 ##rc$[5n[R"U5RS5nURS5n[U-nU[ -U-[ -U-[ -S-U-[ -[ -U-[ -U-[-nXc4$)aConstruct a multipart request body. Args: data (bytes): The resource content (UTF-8 encoded as bytes) to be uploaded. metadata (Mapping[str, str]): The resource metadata, such as an ACL list. content_type (str): The content type of the resource, e.g. a JPEG image has content type ``image/jpeg``. Returns: Tuple[bytes, bytes]: The multipart request body and the boundary used between each part. rscontent-type: )rhrrr_MULTIPART_SEP_MULTIPART_BEGIN_CRLF)rNrkrOrp json_bytes boundary_sepros rririns&H%,,W5J&&w/L"$66L                              "  &&rcUR5nURS[R5 UR5nURU5 U$)zDetermine the total number of bytes in a stream. Args: stream (IO[bytes]): The stream (i.e. file-like object). Returns: int: The number of bytes. r)rrosSEEK_END)rcurrent_position end_positions rrrsB{{} KK2;;;;=L KK ! rc`UR5nUb&X1-Us=:aS:aO OURX#- 5nOURU5nUR5S- n[U5nUc Xa:aUS-nO)US:XaUS:wa [S5eOUS:Xa [S5e[ X5U5nX4U4$)aGet a chunk from an I/O stream. The ``stream`` may have fewer bytes remaining than ``chunk_size`` so it may not always be the case that ``end_byte == start_byte + chunk_size - 1``. Args: stream (IO[bytes]): The stream (i.e. file-like object). chunk_size (int): The size of the chunk to be read from the ``stream``. total_bytes (Optional[int]): The (expected) total number of bytes in the ``stream``. Returns: Tuple[int, bytes, str]: Triple of: * the start byte index * the content in between the start and end bytes (inclusive) * content range header for the chunk (slice) that has been read Raises: ValueError: If ``total_bytes == 0`` but ``stream.read()`` yields non-empty content. ValueError: If there is no data left to consume. This corresponds exactly to the case ``end_byte < start_byte``, which can only occur if ``end_byte == start_byte - 1``. rrz:Stream specified as empty, but produced non-empty content.z;Stream is already exhausted. There is no content remaining.)rrQrrGget_content_range)rrrrrrnum_bytes_readrs rrrs6J:#:k#MA#M++k67++j){{}q H\N  &"Q,K   Q L   Q M &jKHM  --rcUc[RX5$X:a[RU5$[RXU5$)aPConvert start, end and total into content range header. If ``total_bytes`` is not known, uses "bytes {start}-{end}/*". If we are dealing with an empty range (i.e. ``end_byte < start_byte``) then "bytes */{total}" is used. This function **ASSUMES** that if the size is not known, the caller will not also pass an empty range. Args: start_byte (int): The start (inclusive) of the byte range. end_byte (int): The end (inclusive) of the byte range. total_bytes (Optional[int]): The number of bytes in the byte range (if known). Returns: str: The content range header. )_RANGE_UNKNOWN_TEMPLATEr}_EMPTY_RANGE_TEMPLATE_CONTENT_RANGE_TEMPLATE)rrrs rrurusE&&--jCC  $++K88&--jKPPr);r< http.clientr"rrprarerc urllib.parsergooglergoogle.resumable_mediarr xml.etreerrLrzrxryrrrd_BOUNDARY_WIDTHr}rerjrlrkrjcompile IGNORECASErr_STREAM_READ_PAST_TEMPLATEr,rMrrr._UPLOAD_HEADER_NO_APPROPRIATE_CHECKSUM_MESSAGErrRr r robjectrrBrXrzrr9rhrirrrur@rrrs~ "+)!&0-&c#++/*+188IO2**9O@   *" N1M/!DF3REREjIE:IEXdEjdENMEjME`\Ej\E~XXv $&'R(6.rQr