a !f@s,dZddlmZddlmmZddlmm Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddl m!Z!dZ"dZ#dZ$dZ%Gddde&Z'Gddde'Z(Gddde'Z)dS)z)Upload and download support for apitools.N) http_client) _to_bytes)BufferedStream)CommunicationError) HttpError)TransferInvalidError)TransferRetryError)get_http)make_api_request)Request)RESUME_INCOMPLETE) StreamSlice)acceptable_mime_typeiPsimple resumableic@seZdZdZdZdedddfddZdd Zed d Z ed d Z eddZ e j ddZ eddZ e j ddZ eddZeddZddZeddZddZddZd d!ZdS)" _TransferaGeneric bits common to Uploads and Downloads. :type stream: file-like object :param stream: stream to/from which data is downloaded/uploaded. :type close_stream: boolean :param close_stream: should this instance close the stream when deleted :type chunksize: integer :param chunksize: the size of chunks used to download/upload a file. :type auto_transfer: boolean :param auto_transfer: should this instance automatically begin transfering data when initialized :type http: :class:`httplib2.Http` (or workalike) :param http: Http instance used to perform requests. :type num_retries: integer :param num_retries: how many retries should the transfer attempt NFTcCs4d|_||_||_||_d|_||_||_||_dSN) _bytes_http _close_stream_http_stream_url num_retries auto_transfer chunksize)selfstream close_streamrrhttprr Z/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/streaming/transfer.py__init__Ksz_Transfer.__init__cCst|Sr)strrr r r!__repr__Zsz_Transfer.__repr__cCs|jS)zShould this instance close the stream when deleted. :rtype: boolean :returns: Boolean indicated if the stream should be closed. )rr$r r r!r]sz_Transfer.close_streamcCs|jS)zHttp instance used to perform requests. :rtype: :class:`httplib2.Http` (or workalike) :returns: The HTTP object used for requests. )rr$r r r!rfsz_Transfer.httpcCs |jp |jS)zHttp instance used to perform binary requests. Defaults to :attr:`http`. :rtype: :class:`httplib2.Http` (or workalike) :returns: The HTTP object used for binary requests. )rrr$r r r! bytes_httpos z_Transfer.bytes_httpcCs ||_dS)zUpdate Http instance used to perform binary requests. :type value: :class:`httplib2.Http` (or workalike) :param value: new instance N)rrvaluer r r!r&zscCs|jS)zHow many retries should the transfer attempt :rtype: integer :returns: The number of retries allowed. ) _num_retriesr$r r r!rsz_Transfer.num_retriescCs.t|tjstd|dkr$td||_dS)zZUpdate how many retries should the transfer attempt :type value: integer znum_retries: pass an integerrz*Cannot have negative value for num_retriesN) isinstancesix integer_types ValueErrorr)r'r r r!rs cCs|jS)zStream to/from which data is downloaded/uploaded. :rtype: file-like object :returns: The stream that sends/receives data. )rr$r r r!rsz_Transfer.streamcCs|jS)zURL to / from which data is downloaded/uploaded. :rtype: string :returns: The URL where data is sent/received. )rr$r r r!urlsz _Transfer.urlcCs(||jdur|pt|_||_dS)aInitialize this download by setting :attr:`http` and :attr`url`. Allow the user to be able to pre-initialize :attr:`http` by setting the value in the constructor; in that case, we ignore the provided http. :type http: :class:`httplib2.Http` (or a worklike) or None. :param http: the Http instance to use to make requests. :type url: string :param url: The url for this transfer. N)_ensure_uninitializedrr rr)rrr.r r r! _initializes   z_Transfer._initializecCs|jduo|jduS)zHas the instance been initialized :rtype: boolean :returns: Boolean indicating if the current transfer has been initialized. N)r.rr$r r r! initializedsz_Transfer.initializedcCs|jstdt|jdS)zHelper: assert that the instance is initialized. :raises: :exc:`gcloud.streaming.exceptions.TransferInvalidError` if the instance is not initialized. zCannot use uninitialized %sNr1rtype__name__r$r r r!_ensure_initializeds z_Transfer._ensure_initializedcCs|jrtdt|jdS)zHelper: assert that the instance is not initialized. :raises: :exc:`gcloud.streaming.exceptions.TransferInvalidError` if the instance is already initialized. zCannot re-initialize %sNr2r$r r r!r/s z_Transfer._ensure_uninitializedcCs|jr|jdSr)rrcloser$r r r!__del__sz_Transfer.__del__)r4 __module__ __qualname____doc__r)_DEFAULT_CHUNKSIZEr"r%propertyrrr&setterrrr.r0r1r5r/r7r r r r!r2s:            rcseZdZdZeejejejej fZ fddZ e d'ddZ e d(d d Zed d Zed dZeddZddZddZddZddZd)ddZed*ddZd+ddZdd Zd!d"Zd,d#d$Zd-d%d&ZZS).Downloada&Represent a single download. :type stream: file-like object :param stream: stream to/from which data is downloaded/uploaded. :type kwds: dict :param kwds: keyword arguments: all except ``total_size`` are passed through to :meth:`_Transfer.__init__()`. c s@|dd}tt|j|fi|d|_d|_||_d|_dS)N total_sizer)popsuperr>r"_initial_response _progress _total_size _encoding)rrkwdsr? __class__r r!r"s  zDownload.__init__FTcKsDtj|}tj|r(|s(td||t|dfd|d|S)aOCreate a new download object from a filename. :type filename: string :param filename: path/filename for the target file :type overwrite: boolean :param overwrite: should an existing file be overwritten :type auto_transfer: boolean :param auto_transfer: should the transfer be started immediately :type kwds: dict :param kwds: keyword arguments: passed through to :meth:`_Transfer.__init__()`. :rtype: :class:`Download` :returns: The download initiated from the file passed. z*File %s exists and overwrite not specifiedwbT)rr)ospath expanduserexistsr-open)clsfilename overwriterrFrKr r r! from_files zDownload.from_fileNcKs||f||d|S)aWCreate a new Download object from a stream. :type stream: writable file-like object :param stream: the target file :type total_size: integer or None :param total_size: total size of the file to be downloaded :type auto_transfer: boolean :param auto_transfer: should the transfer be started immediately :type kwds: dict :param kwds: keyword arguments: passed through to :meth:`_Transfer.__init__()`. :rtype: :class:`Download` :returns: The download initiated from the stream passed. )rr?r )rOrrr?rFr r r! from_streamszDownload.from_streamcCs|jS)z~Number of bytes have been downloaded. :rtype: integer >= 0 :returns: The number of downloaded bytes. rCr$r r r!progress,szDownload.progresscCs|jS)zTotal number of bytes to be downloaded. :rtype: integer or None :returns: The total number of bytes to download. rDr$r r r!r?5szDownload.total_sizecCs|jS)z'Content-Encoding' used to transfer the file :rtype: string or None :returns: The encoding of the downloaded content. )rEr$r r r!encoding>szDownload.encodingcCs"|js dSd|j|j|jfSdS)NzDownload (uninitialized)z1Download with %d/%s bytes transferred from url %sr1rUr?r.r$r r r!r%Gs  zDownload.__repr__cCs$d|jd<d|jdf|jd<dS)a[Update http_request/url_builder with download-appropriate values. :type http_request: :class:`gcloud.streaming.http_wrapper.Request` :param http_request: the request to be updated :type url_builder: instance with settable 'query_params' attribute. :param url_builder: transfer policy object to be updated mediaZaltz bytes=0-%dRangeN) query_paramsrheaders)r http_request url_builderr r r!configure_requestNs zDownload.configure_requestcCsBd|vr.|dd\}}}|dkr.t||_|jdur>d|_dS)z~Update 'total_size' based on data from a response. :type info: mapping :param info: response headers z content-range/*Nr) rpartitionintrDr?)rinfo_totalr r r! _set_totalZs   zDownload._set_totalcCs||j}|jrt|d}||d|t|jp6||}|j|jvrRt |||_ | |j |j d|j}||||jr|jdddS)aInitialize this download. If the instance has :attr:`auto_transfer` enabled, begins the download immediately. :type http_request: :class:`gcloud.streaming.http_wrapper.Request` :param http_request: the request to use to initialize this download. :type http: :class:`httplib2.Http` (or workalike) :param http: Http instance for this request. rzcontent-locationT use_chunksN)r/r.r_compute_end_byte_set_range_headerr r& status_code_ACCEPTABLE_STATUSESr from_responserBrhreget request_urlr0 stream_file)rr^rr.end_byteresponser r r!initialize_downloadks       zDownload.initialize_downloadcCs|dur\|dkrtdn||jkr,tdt||jd}||krTtd||f||fS|dkrttd||j}||jdfSdS)aValidate / fix up byte range. :type start: integer :param start: start byte of the range: if negative, used as an offset from the end. :type end: integer :param end: end byte of the range. :rtype: tuple, (start, end) :returns: the normalized start, end pair. :raises: :exc:`gcloud.streaming.exceptions.TransferInvalidError` for invalid combinations of start, end. Nrz/Cannot have end index with negative start indexz/Cannot have start index greater than total sizerZz(Range requested with end[%s] < start[%s])rr?minmax)rstartendr r r!_normalize_start_ends$  zDownload._normalize_start_endcCsF|dkrd||jd<n*|dur0d||jd<nd||f|jd<dS)aUpdate the 'Range' header in a request to match a byte range. :type request: :class:`gcloud.streaming.http_wrapper.Request` :param request: the request to update :type start: integer :param start: start byte of the range: if negative, used as an offset from the end. :type end: integer :param end: end byte of the range. rzbytes=%drangeNz bytes=%d-z bytes=%d-%d)r])requestrxryr r r!rls zDownload._set_range_headercCsl|}|dkr|js|S|r@||jd}|durs<           -" 2r>cs"eZdZdZedZd6fdd Zed7dd Zed8d d Z e d d Z e ddZ e ddZ e ddZejddZe ddZejddZddZddZddZddZd d!Zd"d#Zd$d%Zed&d'Zd(d)Zed*d+Zd9d,d-Zd:d.d/Zd0d1Zd2d3Zd4d5Z Z!S);UploadaORepresent a single Upload. :type stream: file-like object :param stream: stream to/from which data is downloaded/uploaded. :type mime_type: string: :param mime_type: MIME type of the upload. :type total_size: integer or None :param total_size: Total upload size for the stream. :type http: :class:`httplib2.Http` (or workalike) :param http: Http instance used to perform requests. :type close_stream: boolean :param close_stream: should this instance close the stream when deleted :type auto_transfer: boolean :param auto_transfer: should this instance automatically begin transfering data when initialized :type kwds: dict :param kwds: keyword arguments: all except ``total_size`` are passed through to :meth:`_Transfer.__init__()`. )r mime_typer?r.NFTc sNtt|j|f|||d|d|_d|_d|_||_d|_d|_||_ dS)N)rrrFr) rArr"_final_response_server_chunk_granularity _complete _mime_typerC _strategyrD)rrrr?rrrrFrGr r!r"s zUpload.__init__cKs^tj|}|s2t|\}}|dur2td|t|j}|t|d|f|d|d|S)aUCreate a new Upload object from a filename. :type filename: string :param filename: path/filename to the file being uploaded :type mime_type: string :param mime_type: MIMEtype of the file being uploaded :type auto_transfer: boolean or None :param auto_transfer: should the transfer be started immediately :type kwds: dict :param kwds: keyword arguments: passed through to :meth:`_Transfer.__init__()`. :rtype: :class:`Upload` :returns: The upload initiated from the file passed. Nz Could not guess mime type for %srbTr?rr) rJrKrL mimetypes guess_typer-statst_sizerN)rOrPrrrFrKrfsizer r r!rRs  zUpload.from_filecKs*|durtd|||f|d|d|S)aCreate a new Upload object from a stream. :type stream: writable file-like object :param stream: the target file :type mime_type: string :param mime_type: MIMEtype of the file being uploaded :type total_size: integer or None :param total_size: Size of the file being uploaded :type auto_transfer: boolean or None :param auto_transfer: should the transfer be started immediately :type kwds: dict :param kwds: keyword arguments: passed through to :meth:`_Transfer.__init__()`. :rtype: :class:`Upload` :returns: The upload initiated from the stream passed. Nz!No mime_type specified for streamFr)r-)rOrrr?rrFr r r!rSs zUpload.from_streamcCs|jS)zHas the entire stream been uploaded. :rtype: boolean :returns: Boolean indicated if the upload is complete. )rr$r r r!completeszUpload.completecCs|jS)ztMIMEtype of the file being uploaded. :rtype: string :returns: The mime-type of the upload. )rr$r r r!rszUpload.mime_typecCs|jS)zeBytes uploaded so far :rtype: integer :returns: The amount uploaded so far. rTr$r r r!rUszUpload.progresscCs|jS)zwUpload strategy to use :rtype: string or None :returns: The strategy used to upload the data. )rr$r r r!strategyszUpload.strategycCs"|ttfvrtd|||_dS)zUpdate upload strategy to use :type value: string (one of :data:`SIMPLE_UPLOAD` or :data:`RESUMABLE_UPLOAD`) :raises: :exc:`ValueError` if value is not one of the two allowed strings. zOInvalid value "%s" for upload strategy, must be one of "simple" or "resumable".N) SIMPLE_UPLOADRESUMABLE_UPLOADr-rr'r r r!rs cCs|jS)zTotal size of the stream to be uploaded. :rtype: integer or None :returns: The total size to be uploaded. rVr$r r r!r?szUpload.total_sizecCs|||_dS)z}Update total size of the stream to be uploaded. :type value: integer or None :param value: the size N)r/rDr'r r r!r?scCs&|js dSd|j|jpd|jfSdS)NzUpload (uninitialized)z.Upload with %d/%s bytes transferred for url %sz???rXr$r r r!r%s zUpload.__repr__cCs^|jdurt|_|jdurdSt}|jdur:|jtkr:t}|jrJ|jsJt}|jsTt}||_dS)aDetermine and set the default upload strategy for this upload. We generally prefer simple or multipart, unless we're forced to use resumable. This happens when any of (1) the upload is too large, (2) the simple endpoint doesn't support multipart requests and we have metadata, or (3) there is no simple upload endpoint. :type upload_config: instance w/ ``max_size`` and ``accept`` attributes :param upload_config: Configuration for the upload endpoint. :type http_request: :class:`gcloud.streaming.http_wrapper.Request` :param http_request: The associated http request. N) resumable_pathrrr?RESUMABLE_UPLOAD_THRESHOLDrbodyZsimple_multipart simple_path)r upload_configr^rr r r!_set_default_strategy!s    zUpload._set_default_strategycCs|jr,|jr,|j|jkr,td|j|jft|j|jsNtd|j|jf||||jtkr|j |_ |j rd|j d<| |qd|j d<||n|j|_ d|j d<||dS)aConfigure the request and url for this upload. :type upload_config: instance w/ ``max_size`` and ``accept`` attributes :param upload_config: transfer policy object to be queried :type http_request: :class:`gcloud.streaming.http_wrapper.Request` :param http_request: the request to be updated :type url_builder: instance with settable 'relative_path' and 'query_params' attributes. :param url_builder: transfer policy object to be updated :raises: :exc:`ValueError` if the requested upload is too big, or does not have an acceptable MIME type. z*Upload too big: %s larger than max size %sz7MIME type %s does not match any accepted MIME ranges %s multipartZ uploadTyperYrN)r?max_sizer-racceptrrrrr relative_pathrr\_configure_multipart_request_configure_media_requestr_configure_resumable_request)rrr^r_r r r!r`>s2         zUpload.configure_requestcCs"|j|jd<|j|_d|_dS)z6Helper for 'configure_request': set up simple request. content-type N)rr]rreadr loggable_bodyrr^r r r!ris  zUpload._configure_media_requestc Cstd}t|dddtj|jdd}||j| |tj|j d}d|d<||j | |t }t jrtj}ntj}||d d }|j|d d ||_|}d ||jd<t|}|j|} | d d\} } } d| dg| d <|| |_dS)z9Helper for 'configure_request': set up multipart request.relatedZ_write_headerscSsdSrr r$r r r!tz5Upload._configure_multipart_request..rrabinaryzContent-Transfer-EncodingF) mangle_from_)unixfromz multipart/related; boundary="%s"s s --N)mime_multipartZ MIMEMultipartsetattrmime_nonmultipartZMIMENonMultipartr]split set_payloadrattachrrrr+BytesIOPY3email_generatorBytesGenerator Generatorflattengetvalue get_boundaryr partitionjoinr) rr^Zmsg_rootmsgrZgenerator_class generatormultipart_boundaryZboundary_bytesZbody_componentsr]rfr r r!ros4       z#Upload._configure_multipart_requestcCs*|j|jd<|jdur&t|j|jd<dS)z9Helper for 'configure_request': set up resumable request.zX-Upload-Content-TypeNzX-Upload-Content-Length)rr]r?r#rr r r!rs   z#Upload._configure_resumable_requestcCs|jtkrdS|t|jdddid}t|j|d|jd}||}|j t j t j fvr~d|_ |j|_|j|j||_nD|j tkr|durd|_n||d |_|j|jn t|dS) zKRefresh the state of a resumable upload via query to the back-end. NPUT Content-Rangez bytes */*)r. http_methodr]r)Z redirectionsrTrZ)rrr5r r.r rr_get_range_headerrmrrCREATEDrr?rCrseekrUrr _last_byterro)rZrefresh_requestZrefresh_response range_headerr r r!refresh_upload_states2   zUpload.refresh_upload_statecCs|jd|jdS)aReturn a 'Range' header from a response. :type response: :class:`gcloud.streaming.http_wrapper.Response` :param response: response to be queried :rtype: string :returns: The header used to determine the bytes range. r[r{)rerp)rtr r r!rszUpload._get_range_headercCs|jdurtd|jtkr dS|t|||jd}|jtjkrNt ||j d}|durjt |}||_|j d}||||jr|jddS|SdS)aFInitialize this upload from the given http_request. :type http_request: :class:`gcloud.streaming.http_wrapper.Request` :param http_request: the request to be used :type http: :class:`httplib2.Http` (or workalike) :param http: Http instance for this request. :raises: :exc:`ValueError` if the instance has not been configured with a strategy. :rtype: :class:`~gcloud.streaming.http_wrapper.Response` :returns: The response if the upload is resumable and auto transfer is not used. Nz7No upload strategy set; did you call configure_request?r~zX-Goog-Upload-Chunk-GranularitylocationTri)rr-rr/r rrmrrrrorerprdrr0rrr)rr^r http_responseZ granularityr.r r r!initialize_uploads*        zUpload.initialize_uploadcCs|d\}}}t|S)zParse the last byte from a 'Range' header. :type range_header: string :param range_header: 'Range' header value per RFC 2616/7233 :rtype: int :returns: The last byte from a range header. -)rrd)rrfryr r r!r s zUpload._last_bytecCs2|jdurdS|p|j}||jr.td|jdS)aGValidate chunksize against server-specified granularity. Helper for :meth:`stream_file`. :type chunksize: integer or None :param chunksize: the chunk size to be tested. :raises: :exc:`ValueError` if ``chunksize`` is not a multiple of the server-specified granulariy. Nz0Server requires chunksize to be a multiple of %d)rrr-)rrr r r!_validate_chunksizes   zUpload._validate_chunksizecCs(|jtkrtd|j}|r"|jn|j}|r8||j||j s||j }|j t jt jfvrnd|_q||jd|_|jd|j kr@td|jq@|j r$t|j dr$t|j dr|j r$|j }|j dtj|j }|j |||kr$td t|t||S) a=Upload the stream. :type use_chunks: boolean :param use_chunks: If False, send the stream in a single request. Otherwise, send it in chunks. :rtype: :class:`gcloud.streaming.http_wrapper.Response` :returns: The response for the final request made. z"Cannot stream non-resumable uploadTr{rZz?Failed to transfer all bytes in chunk, upload paused at byte %drseekablerz7Upload complete with %s additional bytes left in stream)rrr-r _send_chunk_send_media_bodyrrr5rrtellrmrrrrrrerCrUrhasattrrrrJSEEK_ENDrrd)rrjrtZ send_funcZ current_posend_posr r r!rr*sD      zUpload.stream_filecCsnt|j||jd}|jtjtjtfvr8|t ||jtkrj| | |}|d|krj|j ||S)aPeform API upload request. Helper for _send_media_body & _send_chunk: :type request: :class:`gcloud.streaming.http_wrapper.Request` :param request: the request to upload :type end: integer :param end: end byte of the to be uploaded :rtype: :class:`gcloud.streaming.http_wrapper.Response` :returns: the response :raises: :exc:`gcloud.streaming.exceptions.HttpError` if the status code from the response indicates an error. r~rZ)r r&rrmrrrr rrrorrrr)rr|ryrtZ last_byter r r!_send_media_requestTs      zUpload._send_media_requestcCs||jdurtdt|j|j|}t|jd|d}|j|jd<||jkr^d|j}nd||jd|jf}||jd <| ||jS) a)Send the entire stream in a single request. Helper for :meth:`stream_file`: :type start: integer :param start: start byte of the range. :rtype: :class:`gcloud.streaming.http_wrapper.Response` :returns: The response from the media upload request. Nz*Total size must be known for SendMediaBodyrr.rr Content-Type bytes */%sbytes %s-%s/%srZr) r5r?rr rr r.rr]r)rrx body_streamr| range_stringr r r!rss       zUpload._send_media_bodycCs||jdu}|jdurLt|j||j}|j}|jr>||_||j}n"t ||j|j}t |j||}t |j d|d}|j |jd<|rd|_|jdurd||df}n(||krd|j}nd ||d|jf}||jd <|||S) aSend a chunk of the stream. Helper for :meth:`stream_file`: :type start: integer :param start: start byte of the range. :rtype: :class:`gcloud.streaming.http_wrapper.Response` :returns: The response from the chunked upload request. Nrrrrz bytes %s-%s/*rZrrr)r5r?rrrZstream_end_positionZstream_exhaustedrDrrvr r r.rr]rr)rrxZ no_log_bodyrryr|rr r r!rs.        zUpload._send_chunk)NNFT)NT)NT)N)T)"r4r8r9r:rZ_REQUIRED_SERIALIZATION_KEYSr"rrRrSr<rrrUrr=r?r%rr`rrrrrrrrrrrrrrrr r rGr!rlsR         +', (  *r)*r:email.generatorrrZemail.mime.multipartmimerrZemail.mime.nonmultipartZ nonmultipartrrrJr+Z six.movesrZgcloud._helpersrZ gcloud.streaming.buffered_streamrZgcloud.streaming.exceptionsrrrrZgcloud.streaming.http_wrapperr r r r Zgcloud.streaming.stream_slicer Zgcloud.streaming.utilrrrrr;objectrr>rr r r r!s<              0