TSfّ<dZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl m Zddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZGdd e Z!Gd d e!Z"Gd d e!Z#Gdde!ejHZ$dZ%dZ&dZ'dZ(dZ)y)zVirtual 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)_async_resumable_media)_helpers)_upload)common)_CONTENT_TYPE_HEADER_CONTENT_RANGE_TEMPLATE_RANGE_UNKNOWN_TEMPLATE_EMPTY_RANGE_TEMPLATE_BOUNDARY_FORMAT_MULTIPART_SEP_CRLF_MULTIPART_BEGIN_RELATED_HEADER_BYTES_RANGE_RE_STREAM_ERROR_TEMPLATE_POST_PUT!_UPLOAD_CHECKSUM_MISMATCH_MESSAGE0_UPLOAD_METADATA_NO_APPROPRIATE_CHECKSUM_MESSAGEc^eZdZdZd dZedZdZedZ edZ edZ y) UploadBaseaBase 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. Nch||_|i}||_d|_tj|_y)NF) upload_url_headers _finishedr RetryStrategy_retry_strategy)selfrheaderss dC:\Users\user\Documents\project_loop\venv\Lib\site-packages\google/_async_resumable_media/_upload.py__init__zUploadBase.__init__Fs2$ ?G %335c|jS)z2bool: Flag indicating if the upload has completed.)rrs r finishedzUploadBase.finishedNs~~r"cd|_tj|tjj f|j y)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_responsezUploadBase._process_responseSs.$$$X /@$BWBWXr"ctd)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 r r+zUploadBase._get_status_codeh""CDDr"ctd)zAccess the headers from an HTTP response. Args: response (object): The HTTP response object. Raises: NotImplementedError: Always, since virtual. r0r1r3s r _get_headerszUploadBase._get_headerstr4r"ctd)zAccess the response body from an HTTP response. Args: response (object): The HTTP response object. Raises: NotImplementedError: Always, since virtual. r0r1r3s r _get_bodyzUploadBase._get_bodyr4r"N) __name__ __module__ __qualname____doc__r!propertyr%r. staticmethodr+r6r8r"r rr8sh 6Y* E E E E E Er"rceZdZdZdZddZy) 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. c|jr tdt|tst dt |||j t<t|j||j fS)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. 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 TypeErrortyperrrr)rdata content_types r _prepare_requestzSimpleUpload._prepare_requestsY< ==?@ @$&tt| ||||_y)Nr)superrSr!_checksum_type)rrrchecksum __class__s r r!zMultipartUpload.__init__s ot-j'-J&r"c|jr tdt|tst dt |t j|j}|X|j|t j|j}t j|j}|||<t|||\}}t|zdz} | |jt <t"|j$||jfS)ajPrepare 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/ rDrE")r%rFrGrHrIrJ sync_helpers_get_checksum_objectrWupdateprepare_checksum_digestdigest_get_metadata_keyconstruct_multipart_requestrrrrr) rrKmetadatarLchecksum_objectactual_checksum metadata_keycontentmultipart_boundarymultipart_content_types r rMz MultipartUpload._prepare_requestsB ==?@ @$&tEr"rSceZdZdZdfd ZedZedZedZedZ edZ ddZ d Z dd Z d Zd Zd ZdZddZdZdZdZxZS)ResumableUploadaInitiate 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 the :meth:`initiate` request, e.g. headers for encrypted data. These **will not** be sent with :meth:`transmit_next_chunk` or :meth:`recover` requests. 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`. c>tt| |||tjzdk7r+t dj tjdz ||_d|_d|_ d|_ d|_ ||_ d|_ d|_d|_d|_y)NrUrz{} KB must divide chunk sizeiF)rVrpr!rUPLOAD_CHUNK_SIZErFformat _chunk_size_stream _content_type_bytes_uploaded_bytes_checksummedrW_checksum_object _total_bytes_resumable_url_invalid)rr chunk_sizerXrrYs r r!zResumableUpload.__init___s ot-j'-J .@@ @A E.55*<#?!#CD # 4sB,E.E/B#EcK|jytj|j}|jd{}|j |}|9t j |tj||j|tj|jj}||k7rCt j|tj|jj||y7ƭw)aQCheck 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)rWr\rargetrrrrsr6r_ryr`DataCorruptionrupper)rr-rfrcremote_checksumlocal_checksums r rz"ResumableUpload._validate_checksums    & #55d6I6IJ !(",,|4  "((@GG U!!(+  &==  ! ! ( ( *  _ ,''188''--/  -)sAD D CD ctd)aTransmit 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, aiohttp.ClientTimeout]]): 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 an `aiohttp.ClientTimeout` object. Raises: NotImplementedError: Always, since virtual. r0r1)rrOrPs r transmit_next_chunkz#ResumableUpload.transmit_next_chunkrkr"c||js tdtjdi}t|j d|fS)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. Raises: ValueError: If the current upload is not in an invalid state. .. _sans-I/O: https://sans-io.readthedocs.io/ z3Upload is not in invalid state, no need to recover.z bytes */*N)rrFrrrr)rrs r _prepare_recover_requestz(ResumableUpload._prepare_recover_requests<2||RS S00+>T''w66r"ctj|tjjf|j |j |}tj|vre|tj}tj|}|tj|d|dt|jddz|_nd|_|jj!|jd|_y)aProcess 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+r6rrrrrrrrwruseekr|)rr-rrrs r _process_recover_responsez)ResumableUpload._process_recover_responses& $$  [[ + + -  ! ! ##H-  G +!("7"78K#))+6E},,/@  $'u{{:'>#?!#CD $%D  $../ r"ctd)a!Recover 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. r0r1)rrOs r recoverzResumableUpload.recover!s"""CDDr"rl)NT)NTNr9)r:r;r<r=r!r>rr}rrrrrrrMrrrrrrrrmrns@r rprp@s<&  ##$$ ! !NR>8@ @1Ef7:r9Dv>E,7>)VEr"rpctjtj}t j |}|j dS)zGet a random boundary for a multipart request. Returns: bytes: The boundary used to separate parts of a multipart request. r)random randrangesysmaxsizer rsr) random_intboundarys r get_boundaryr5s9 !!#++.J&&z2H ??7 ##r"c$t}tj|jd}|jd}t|z}|t z|zt z|zt zdz|zt zt z|zt z|ztz}||fS)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: )rrrrr rr )rKrcrLrh json_bytes boundary_seprgs r rbrbBs&H%,,W5J&&w/L"$66L                              " & &&r"c|j}|jdtj|j}|j||S)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 r rrksB{{} KK2;;;;=L KK ! r"cX|j}|&||z|cxk\rdkDrnn|j||z }n|j|}|jdz }t|}| ||kr+|dz}n%|dk(r|dk7rtd|dk(r tdt |||}|||fS)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.)rreadlenrFget_content_range)rr}rrrrnum_bytes_readrs r rrs6J: #:k#MA#M++kJ67++j){{}q H\N J &"Q,K   Q L  Q M &j(KHM w --r"c|tj||S||krtj|Stj|||S)aConvert 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. )r rsr r)rrrs r rrsK&&--j(CC J $++K88&--j(KPPr")*r= http.clientr(rrrrgooglergoogle._async_resumable_mediargoogle.resumable_mediar\r sync_uploadrgoogle.resumable_media._uploadrrr r r r r rrrrrrrrobjectrrBrSrprrbrrrr@r"r rs )2;9)&REREjGE:GETfEjfERrEj+"="=rEj $&'R(6.rQr"