$h!Q6SrSSKrSSKrSSKrSSKJr SSKrSSKJr "SS\ 5r "SS \ 5r S r "S S \ 5rS rSrSr\R$S5rSrSr"SS\ 5r"SS\R.5r"SS\ 5r"SS\ 5rg)z requests_toolbelt.multipart.encoder =================================== This holds all of the implementation details of the MultipartEncoder N)uuid4fieldsc\rSrSrSrSrg)FileNotSupportedErrorzFile not supported error.N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__r [/var/www/html/shao/venv/lib/python3.13/site-packages/requests_toolbelt/multipart/encoder.pyrrs#rrc\rSrSrSrSSjr\S5rSrSr Sr S r S r S r S rS rSrSrSr\S5rSrSSjrSrg)MultipartEncoderaY The ``MultipartEncoder`` object is a generic interface to the engine that will create a ``multipart/form-data`` body for you. The basic usage is: .. code-block:: python import requests from requests_toolbelt import MultipartEncoder encoder = MultipartEncoder({'field': 'value', 'other_field': 'other_value'}) r = requests.post('https://httpbin.org/post', data=encoder, headers={'Content-Type': encoder.content_type}) If you do not need to take advantage of streaming the post body, you can also do: .. code-block:: python r = requests.post('https://httpbin.org/post', data=encoder.to_string(), headers={'Content-Type': encoder.content_type}) If you want the encoder to use a specific order, you can use an OrderedDict or more simply, a list of tuples: .. code-block:: python encoder = MultipartEncoder([('field', 'value'), ('other_field', 'other_value')]) .. versionchanged:: 0.4.0 You can also provide tuples as part values as you would provide them to requests' ``files`` parameter. .. code-block:: python encoder = MultipartEncoder({ 'field': ('file_name', b'{"a": "b"}', 'application/json', {'X-My-Header': 'my-value'}) ]) .. warning:: This object will end up directly in :mod:`httplib`. Currently, :mod:`httplib` has a hard-coded read size of **8192 bytes**. This means that it will loop until the file has been read and your upload could take a while. This is **not** a bug in requests. A feature is being considered for this object to allow you, the user, to specify what size should be returned on a read. If you have opinions on this, please weigh in on `this issue`_. .. _this issue: https://github.com/requests/toolbelt/issues/75 NcU=(d [5RUlSRUR5UlX0lSR [URUR 5[SUR 5/5UlXl SUl /Ul [/5Ul SUlSUl[!US9UlUR%5 UR'5 g)Nz--{}rz F)encoding)rhexboundary_valueformatboundaryrjoin encode_with_encoded_boundaryrfinishedpartsiter _iter_parts _current_part_len CustomBytesIO_buffer_prepare_parts_write_boundary)selfrrrs r__init__MultipartEncoder.__init__Ws&5%'++ d&9&9: ! "%  t}} 5  .+"     8" %h7   rcHUR=(d UR5$)aLength of the multipart/form-data body. requests will first attempt to get the length of the body by calling ``len(body)`` and then by checking for the ``len`` attribute. On 32-bit systems, the ``__len__`` method cannot return anything larger than an integer (in C) can hold. If the total size of the body is even slightly larger than 4GB users will see an OverflowError. This manifested itself in `bug #80`_. As such, we now calculate the length lazily as a property. .. _bug #80: https://github.com/requests/toolbelt/issues/80 )r$_calculate_lengthr)s rlenMultipartEncoder.lens$yy4D2244rc8SRUR5$)Nz)rrr.s r__repr__MultipartEncoder.__repr__s)00==rc^[UR5m[U4SjUR55T-S-UlUR$)zv This uses the parts to calculate the length of the body. This returns the calculated length so __len__ can be lazy. c3D># UHnT[U5-S-v M g7f)N) total_len).0p boundary_lens r 5MultipartEncoder._calculate_length..s"7A!\IaL (1 ,zs r6)r/rsumr r$)r)r:s @rr-"MultipartEncoder._calculate_lengthsL 4==) 7;zz ! yyrcFU[UR5- nUS:aU$S$)a^This calculates how many bytes need to be added to the buffer. When a consumer read's ``x`` from the buffer, there are two cases to satisfy: 1. Enough data in the buffer to return the requested amount 2. Not enough data This function uses the amount of unread bytes in the buffer and determines how much the Encoder has to load before it can return the requested amount of bytes. :param int read_size: the number of bytes the consumer requests :returns: int -- the number of bytes that must be loaded into the buffer before the read can be satisfied. This will be strictly non-negative r)r7r&)r) read_sizeamounts r_calculate_load_amount'MultipartEncoder._calculate_load_amounts($Yt||44!v**rcURR5 UR=(d UR5nUS:XdUS:aSnU(aJUR 5(d5X0R S5- nX0R 5- nUR5nU(dX0R5- nSUlgX2RURU5- nUS:waX-nUS:XaMUS:aMgg)z0Load ``amount`` number of bytes into the buffer.rs TN) r&smart_truncater# _next_partbytes_left_to_write_writer(_write_closing_boundaryrwrite_to)r)rApartwrittens r_loadMultipartEncoder._loads ##%!!6T__%6lfqjGD4466;;w////11(7799 $  }}T\\6: :G|!lfqjrcd[UR5=olU$![a SnU$f=fN)nextr"r# StopIteration)r)r9s rrGMultipartEncoder._next_parts? %)$*:*:%; ;A" A s  //c## URn[URS5(a#[URR55nUHup#SnSnSn[ U[[ 45(a/[ U5S:XaUupGO[ U5S:XaUupGnOUupGpVOUn[R"X'UUS9nURUS9 Uv M g7f)Nitemsr)namedatafilenameheaders) content_type) rhasattrlistrV isinstancetupler/ RequestFieldmake_multipart) r)_fieldskv file_name file_type file_headers file_pointerfields r _iter_fieldsMultipartEncoder._iter_fieldss++ 4;; ( (4;;,,./GDAIIL!dE]++q6Q;./+I|Vq[9:6IYGHDIY  ''Q1:0<>E  i 8K%sCCcURnUR5Vs/sHn[RX!5PM snUl[ UR5Ulgs snf)zThis uses the fields provided by the user and creates Part objects. It populates the `parts` attribute and uses that to create a generator for iteration. N)rrkPart from_fieldr r!r")r)encfs rr'MultipartEncoder._prepare_partssN mm7;7H7H7JK7J!dooa-7JK  +LsA c8URRU5$)zWrite the bytes to the end of the buffer. :param bytes bytes_to_write: byte-string (or bytearray) to append to the buffer :returns: int -- the number of bytes written )r&append)r)bytes_to_writes rrIMultipartEncoder._writes||"">22rc8URUR5$)z,Write the boundary to the end of the buffer.)rIrr.s rr( MultipartEncoder._write_boundarys{{41122rc[UR5 URRSS5 URRS5 SSS5 g!,(df  g=f)z?Write the bytes necessary to finish a multipart/form-data body.rs-- N)resetr&seekwriter.s rrJ(MultipartEncoder._write_closing_boundarysL 4<< LL  b! $ LL  y )!! s 8A A%cJUR[XR55$)z/Write the current part's headers to the buffer.)rIrr)r)r[s r_write_headersMultipartEncoder._write_headers s{{;w >??rcJ[SRUR55$)Nz multipart/form-data; boundary={})strrrr.s rr\MultipartEncoder.content_types# . 5 5d6I6I J rc"UR5$)aReturn the entirety of the data in the encoder. .. note:: This simply reads all of the data it can. If you have started streaming or reading data from the encoder, this method will only return whatever data is left in the encoder. .. note:: This method affects the internal state of the encoder. Calling this method will exhaust the encoder. :returns: the multipart message :rtype: bytes readr.s r to_stringMultipartEncoder.to_strings$yy{rcUR(aURRU5$UnUS:waUbUR[ U55nUR U5 URRU5$)zRead data from the streaming encoder. :param int size: (optional), If provided, ``read`` will return exactly that many bytes. If it is not provided, it will return the remaining bytes. :returns: bytes rE)rr&rrBintrN)r)size bytes_to_loads rrMultipartEncoder.read+sg ==<<$$T* * B =#< 77D BM =!||  &&r) r&r#rr"r$rrrrrr Nutf-8rE)r r r rrr*propertyr/r2r-rBrNrGrkr'rIr(rJrr\rrrr rrrrsx;z)V55&> +*"*0,33@ ('rrcU$rQr )monitors rIDENTITYr>s NrcZ\rSrSrSrS Sjr\S Sj5r\S5r Sr S Sjr S r g) MultipartEncoderMonitoriBa An object used to monitor the progress of a :class:`MultipartEncoder`. The :class:`MultipartEncoder` should only be responsible for preparing and streaming the data. For anyone who wishes to monitor it, they shouldn't be using that instance to manage that as well. Using this class, they can monitor an encoder and register a callback. The callback receives the instance of the monitor. To use this monitor, you construct your :class:`MultipartEncoder` as you normally would. .. code-block:: python from requests_toolbelt import (MultipartEncoder, MultipartEncoderMonitor) import requests def callback(monitor): # Do something with this information pass m = MultipartEncoder(fields={'field0': 'value0'}) monitor = MultipartEncoderMonitor(m, callback) headers = {'Content-Type': monitor.content_type} r = requests.post('https://httpbin.org/post', data=monitor, headers=headers) Alternatively, if your use case is very simple, you can use the following pattern. .. code-block:: python from requests_toolbelt import MultipartEncoderMonitor import requests def callback(monitor): # Do something with this information pass monitor = MultipartEncoderMonitor.from_fields( fields={'field0': 'value0'}, callback ) headers = {'Content-Type': montior.content_type} r = requests.post('https://httpbin.org/post', data=monitor, headers=headers) Nc|XlU=(d [UlSUlURRUlgNr)encoderrcallback bytes_readr/)r)rrs rr* MultipartEncoderMonitor.__init__us1 !,H <<##rc*[XU5nU"XT5$rQ)r)clsrrrrrs r from_fields#MultipartEncoderMonitor.from_fieldss#6X>7%%rc.URR$rQ)rr\r.s rr\$MultipartEncoderMonitor.content_types||(((rc"UR5$rQrr.s rr!MultipartEncoderMonitor.to_stringsyy{rcURRU5nU=R[U5- slUR U5 U$rQ)rrrr/r)r)rstrings rrMultipartEncoderMonitor.reads9""4( 3v;& d r)rrrr/rQ)NrNr) r r r rrr* classmethodrrr\rrrr rrrrBsE/b $9@!&& ))rrcXUb&[U[5(dURU5$U$)a"Encoding ``string`` with ``encoding`` if necessary. :param str string: If string is a bytes object, it will not encode it. Otherwise, this function will encode it with the provided encoding. :param str encoding: The encoding with which to encode string. :returns: encoded bytes object )r_bytesencode)rrs rrrs) Nj77}}X&& Mrc>[US5(aU$[X5$)z4Coerce the data to an object with a ``read`` method.r)r]r%rYrs r readable_datarstV  ((rc[US5(a [U5$[US5(a UR$[US5(a1UR5n[R"U5R $[US5(a[UR55$g![ Ra NAf=f)N__len__r/filenogetvalue) r]r/rosfstatst_sizeioUnsupportedOperationr)ors rr7r7sq)1v q%uu q( ,XXZF88F#++ +q*1::<   &&   s B''B>=B>c#|# UR5nURSS5 Sv URUS5 g7f)zKeep track of the buffer's current position and write to the end. This is a context manager meant to be used when adding data to the buffer. It eliminates the need for every function to be concerned with the position of the cursor in the buffer. rrNtellr|)bufferoriginal_positions rr{r{s3  KK1  KK!1%s:<c[U[5(dc[US5(a[UR5U5$[US5(a [ U5$[US5(d [X5$U$)z5Ensure that every object's __len__ behaves uniformly.rrr)r_r%r]r FileWrapperrs r coerce_datarsd dM * * 4 $ $ (; ; 4 " "t$ $tV$$ 0 0 Krcn[US5(a[UR"55$[U5$)NrV)r]r^rVrs rto_listrs*vwFLLN## <rc6\rSrSrSr\S5rSrSrSr g)rnicXlX lSUl[UR5[ UR5-Ulg)NT)r[bodyheaders_unreadr/r7)r)r[rs rr* Part.__init__s2  "t||$y';;rcr[UR5U5n[URU5nU"X45$)z8Create a part from a Request Field generated by urllib3.)rrender_headersrrY)rrjrr[rs rroPart.from_fields4e224h?5::x07!!rcSnUR(aU[UR5- nU[UR5-S:$)zDetermine if there are bytes left to write. :returns: bool -- ``True`` if there are bytes left to write, otherwise ``False`` r)rr/r[r7r)r)to_reads rrHPart.bytes_left_to_writes>     s4<<( (G)DII..!33rc|SnUR(a$X1RUR5- nSUl[UR5S:akUS:XdX2:a`UnUS:waX#- nX1RURR U55- n[UR5S:aUS:XaMYX2:aM`U$)aZWrite the requested amount of bytes to the buffer provided. The number of bytes written may exceed size on the first read since we load the headers ambitiously. :param CustomBytesIO buffer: buffer we want to write bytes to :param int size: number of bytes requested to be written to the buffer :returns: int -- number of bytes actually written rFrE)rrtr[r7rr)r)rrrMamount_to_reads rrK Part.write_tos    }}T\\2 2G"'D  "Q&DBJ'.!Nrz!% }}TYY^^N%CD DG  "Q&DBJ'. r)rr[rr/N) r r r rr*rrorHrKrr rrrnrns%< "" 4rrncN^\rSrSrSU4SjjrSr\S5rSrSr Sr U=r $) r%icB>[X5n[[U]U5 grQ)rsuperr%r*)r)rr __class__s rr*CustomBytesIO.__init__sV. mT+F3rcUR5nURSS5 UR5nURUS5 U$)Nrrr)r) current_poslengths r_get_endCustomBytesIO._get_ends8iik  !Q +q! rcFUR5nXR5- $rQ)rrr)rs rr/CustomBytesIO.len!s ##rct[U5 URU5nSSS5 U$!,(df  W$=frQ)r{r})r)rrMs rrtCustomBytesIO.append&s. 4[jj'G[s( 7c[U5nUR5U- nX!:aVUR5nURSS5 UR 5 UR U5 URSS5 ggr)r7rrr|truncater})r) to_be_read already_read old_bytess rrFCustomBytesIO.smart_truncate+s`t_ }}3  % I IIaO MMO JJy ! IIaO &rr r) r r r rr*rrr/rtrFr __classcell__)rs@rr%r%s04$$  rr%c4\rSrSrSr\S5rSSjrSrg)ri7cXlgrQfd)r) file_objects rr*FileWrapper.__init__8srcb[UR5URR5- $rQ)r7rrr.s rr/FileWrapper.len;s !DGGLLN22rc8URRU5$rQ)rrrs rrFileWrapper.read?sww||F##rrNr) r r r rr*rr/rrr rrrr7s 33$rrc.\rSrSrSrSSjrSrSrSrg) FileFromURLWrapperiCaFile from URL wrapper. The :class:`FileFromURLWrapper` object gives you the ability to stream file from provided URL in chunks by :class:`MultipartEncoder`. Provide a stateless solution for streaming file from one server to another. You can use the :class:`FileFromURLWrapper` without a session or with a session as demonstated by the examples below: .. code-block:: python # no session import requests from requests_toolbelt import MultipartEncoder, FileFromURLWrapper url = 'https://httpbin.org/image/png' streaming_encoder = MultipartEncoder( fields={ 'file': FileFromURLWrapper(url) } ) r = requests.post( 'https://httpbin.org/post', data=streaming_encoder, headers={'Content-Type': streaming_encoder.content_type} ) .. code-block:: python # using a session import requests from requests_toolbelt import MultipartEncoder, FileFromURLWrapper session = requests.Session() url = 'https://httpbin.org/image/png' streaming_encoder = MultipartEncoder( fields={ 'file': FileFromURLWrapper(url, session=session) } ) r = session.post( 'https://httpbin.org/post', data=streaming_encoder, headers={'Content-Type': streaming_encoder.content_type} ) NcU=(d [R"5UlURU5n[ UR S5UlURUlg)Ncontent-length) requestsSessionsession_request_for_filerr[r/rawraw_data)r)file_urlrrequested_files rr*FileFromURLWrapper.__init__qsL4("2"2"4 //9~--.>?@&** rc URRUSS9nURRSS5nUcSRUS9n[ U5eUR 5(dSRUS9n[ U5eU$)z&Make call for file under provided URL.T)streamrNzhData from provided URL {url} is not supported. Lack of content-length Header in requested file response.)urlzZData from provided URL {url} is not supported. content-length header value is not a digit.)rgetr[rrisdigit)r)rresponsecontent_length error_msgs rr$FileFromURLWrapper._request_for_filews<<##HT#:!))--.>E  !DDJF EKE"  ( 2 2''))00680D ( 2 2rcUS:aUO URnURRU5=(d SnU=RU(a [U5OS-slU$)zRead file in chunks.rr)r/rr)r) chunk_sizechunks rrFileFromURLWrapper.readsG#-?Z  "":.5# %CJQ. r)r/rrrQ) r r r rrr*rrrr rrrrCs+Z+ &rr)r contextlibrruuidrr_compatr Exceptionrobjectrrrrrr7contextmanagerr{rrrnBytesIOr%rrr rrrs $I$c'vc'L RfRj )!(  & &  /6/dBJJD $& $LLr