@ fّLdZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl m Zddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZGdd e Z!Gd d e!Z"Gd d e!Z#Gdde!ej$Z$dZ%dZ&dZ'dZ(dZ)dS)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_MESSAGEcxeZdZdZd dZedZdZedZ edZ edZ dS) 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|_dS)NF) upload_url_headers _finishedr RetryStrategy_retry_strategy)selfrheaderss t/home/panchajanya/Development/work/volatility3/lib/python3.11/site-packages/google/_async_resumable_media/_upload.py__init__zUploadBase.__init__Fs8$ ?G %355c|jS)z2bool: Flag indicating if the upload has completed.)rrs r finishedzUploadBase.finishedNs ~r"cjd|_tj|tjjf|jdS)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_responseSs0$$X /@$BWXXXXXr"c td)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""CDDDr"c td)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"c td)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 rr8s  6666XYYY* E E\ E E E\ E E E\ E E Er"rc eZdZdZdZddZdS) 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|jrtdt|tst dt |||jt<t|j ||jfS)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_requestsh< = A?@@ @$&& J8>8>tEEEEEEEEr"rSceZdZdZdfd ZedZedZedZedZ edZ dd Z d Z dd Z d ZdZdZdZddZdZdZdZxZS)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`. Ncltt||||tjzdkr/t dtjdz ||_d|_d|_ d|_ d|_ ||_ d|_ d|_d|_d|_dS)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'-JJJ .@ @A E E.55*'>#?#?!#CD r"cK|jdStj|j}|d{V}||}|;t j|tj|| |tj |j }||kr@t j |tj|j||dS)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   & F#5d6IJJ !((((((",,|44  "(@G UU!!(++  &=  ! ( ( * *   _ , ,'18'--//  - ,r"c td)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"cj|jstdtjdi}t|jd|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| TRSS S0+>T'w66r"ctj|tjjf|j||}tj|vrj|tj}tj |}|tj |d|dt| ddz|_nd|_|j|jd|_dS)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 + +!("78K#)+66E},/@  $'u{{:'>'>#?#?!#CD $%D  $./// r"c td)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"""CDDDr"rl)NT)NTNr9)r:r;r<r=r!r>rr}rrrrrrrMrrrrrrrrmrns@r rprp@s<&X  X ##X#$$X$ ! !X !NR>8>8>8>8@   @1E1E1E1Ef7:7:7:r9D9D9Dv>EEEE,777>)))VEEEEEEEr"rpctjtj}t 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_boundaryr5s: !#+..J&z22H ??7 # ##r"cJt}tj|d}|d}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%%,,W55J&&w//L"$66L                              " & &&r"c|}|dtj|}|||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 rrksP{{}} KK2;;;==L KK !!! r"c|}|,||z|cxkrdkrnn|||z }n||}|dz }t|}| ||kr|dz}n1|dkr|dkrtdn|dkrtdt |||}|||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``. Nrrz: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#M#M#M#MA#M#M#M#M#M++kJ677++j)){{}}q H\\N J & &"Q,K    Q  L   Q  M &j(KHHM 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 rrsN&&-j(CCC J  $+K888&-j(KPPPr")*r= http.clientr(rrrrgooglergoogle._async_resumable_mediargoogle.resumable_mediar\r sync_uploadrgoogle.resumable_media._uploadrrr r r r r rrrrrrrrobjectrrBrSrprrbrrrr@r"r rs ))))))222222;;;;;;999999))))))&REREREREREREREREjGEGEGEGEGE:GEGEGETfEfEfEfEfEjfEfEfERrErErErErEj+"=rErErEj $ $ $&'&'&'R(6.6.6.rQQQQQr"