3
�P\$Q � @ s� d Z ddlZddlZddlZddlmZ ddlZddlmZ G dd� de �Z
G dd � d e �Z d
d � Z
G d d
� d
e �Zdd� Zdd� Zdd� Zejdd� �Zdd� Zdd� ZG dd� de �ZG d d � d ej�ZG d d � d e �ZG d d!� d!e �ZdS )"z�
requests_toolbelt.multipart.encoder
===================================
This holds all of the implementation details of the MultipartEncoder
� N)�uuid4� )�fieldsc @ s e Zd ZdZdS )�FileNotSupportedErrorzFile not supported error.N)�__name__�
__module__� __qualname__�__doc__� r
r
� /usr/lib/python3.6/encoder.pyr s r c @ s� e Zd ZdZd%dd�Zedd� �Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zed d � �Zd d!� Zd'd#d$�ZdS )(�MultipartEncodera�
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
N�utf-8c C s� |p
t � j| _dj| j�| _|| _djt| j| j�td| j�g�| _|| _ d| _
g | _ t g �| _
d | _d | _t|d�| _| j� | j� d S )Nz--{0}� z
F)�encoding)r �hex�boundary_value�format�boundaryr �join� encode_with�_encoded_boundaryr �finished�parts�iter� _iter_parts�
_current_part�_len�
CustomBytesIO�_buffer�_prepare_parts�_write_boundary)�selfr r r r
r
r �__init__W s
zMultipartEncoder.__init__c C s | j p | j� S )ai Length 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_length)r! r
r
r �len� s zMultipartEncoder.lenc C s dj | j�S )Nz<MultipartEncoder: {0!r}>)r r )r! r
r
r �__repr__� s zMultipartEncoder.__repr__c s2 t | j�� t� fdd�| jD ��� d | _| jS )z�
This uses the parts to calculate the length of the body.
This returns the calculated length so __len__ can be lazy.
c 3 s | ]}� t |� d V qdS )� N)� total_len)�.0�p)� boundary_lenr
r � <genexpr>� s z5MultipartEncoder._calculate_length.<locals>.<genexpr>r& )r$ r �sumr r )r! r
)r* r r# � s
"z"MultipartEncoder._calculate_lengthc C s |t | j� }|dkr|S dS )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 )r' r )r! Z read_size�amountr
r
r �_calculate_load_amount� s z'MultipartEncoder._calculate_load_amountc C s� | j j� | jp| j� }x�|dks*|dkr�d}|r^|j� r^|| jd�7 }|| j� 7 }| j� }|sv|| j� 7 }d| _P ||j | j |�7 }|dkr||8 }qW dS )z0Load ``amount`` number of bytes into the buffer.� r s
TN���r0 )
r �smart_truncater �
_next_part�bytes_left_to_write�_writer �_write_closing_boundaryr �write_to)r! r- �part�writtenr
r
r �_load� s
zMultipartEncoder._loadc C s2 yt | j� }| _W n tk
r, d }Y nX |S )N)�nextr r �
StopIteration)r! r) r
r
r r2 � s
zMultipartEncoder._next_partc c s� | j }t| j d�r t| j j� �}x�|D ]�\}}d }d }d }t|ttf�r�t|�dkr^|\}}q�t|�dkrv|\}}}q�|\}}}}n|}t j||||d�}|j|d� |V q&W d S )N�itemsr � )�name�data�filename�headers)� content_type) r �hasattr�listr< �
isinstance�tupler$ Z RequestFieldZmake_multipart) r! �_fields�k�v� file_nameZ file_typeZ file_headersZ file_pointer�fieldr
r
r � _iter_fields� s&
z MultipartEncoder._iter_fieldsc s. | j � � fdd�| j� D �| _t| j�| _dS )z�This 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.
c s g | ]}t j|� ��qS r
)�Part�
from_field)r( �f)�encr
r �
<listcomp>� s z3MultipartEncoder._prepare_parts.<locals>.<listcomp>N)r rL r r r )r! r
)rP r r � s z MultipartEncoder._prepare_partsc C s | j j|�S )z�Write 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! Zbytes_to_writer
r
r r4 � s zMultipartEncoder._writec C s | j | j�S )z,Write the boundary to the end of the buffer.)r4 r )r! r
r
r r s z MultipartEncoder._write_boundaryc
C s4 t | j�� | jjdd� | jjd� W dQ R X dS )z?Write the bytes necessary to finish a multipart/form-data body.r s --
N���)�resetr �seek�write)r! r
r
r r5 s z(MultipartEncoder._write_closing_boundaryc C s | j t|| j��S )z/Write the current part's headers to the buffer.)r4 r r )r! rA r
r
r �_write_headers
s z MultipartEncoder._write_headersc C s t dj| j��S )Nz!multipart/form-data; boundary={0})�strr r )r! r
r
r rB s z MultipartEncoder.content_typec C s | j � S )a� Return 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
)�read)r! r
r
r � to_string s zMultipartEncoder.to_stringr/ c C sJ | j r| jj|�S |}|dkr4|dk r4| jt|��}| j|� | jj|�S )z�Read 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
r/ Nr0 )r r rY r. �intr9 )r! �sizeZ
bytes_to_loadr
r
r rY + s
zMultipartEncoder.read)Nr
r0 )r0 )r r r r r" �propertyr$ r% r# r. r9 r2 rL r r4 r r5 rW rB rZ rY r
r
r
r r s" =
+
r c C s | S )Nr
)Zmonitorr
r
r �IDENTITY> s r^ c @ sF e Zd ZdZddd�Zeddd��Zedd � �Zd
d � Z dd
d�Z
dS )�MultipartEncoderMonitora
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 C s$ || _ |p t| _d| _| j j| _d S )Nr )�encoderr^ �callback�
bytes_readr$ )r! r` ra r
r
r r" u s
z MultipartEncoderMonitor.__init__�utf-8c C s t |||�}| ||�S )N)r )�clsr r r ra r` r
r
r � from_fields� s z#MultipartEncoderMonitor.from_fieldsc C s | j jS )N)r` rB )r! r
r
r rB � s z$MultipartEncoderMonitor.content_typec C s | j � S )N)rY )r! r
r
r rZ � s z!MultipartEncoderMonitor.to_stringr/ c C s, | j j|�}| jt|�7 _| j| � |S )N)r` rY rb r$ ra )r! r\ �stringr
r
r rY � s
z MultipartEncoderMonitor.read)N)Nrc Nr0 )r0 ) r r r r r" � classmethodre r] rB rZ rY r
r
r
r r_ B s 1
r_ c C s | dkpt | t�s | j|�S | S )a6 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
N)rE �bytes�encode)rf r r
r
r r � s
r c C s t | d�r| S t| |�S )z4Coerce the data to an object with a ``read`` method.rY )rC r )r? r r
r
r �
readable_data� s
rj c C sv t | d�rt| �S t | d�r"| jS t | d�r\y | j� }W n tjk
rN Y nX tj|�jS t | d�rrt| j� �S d S )N�__len__r$ �fileno�getvalue) rC r$ rl �io�UnsupportedOperation�os�fstat�st_sizerm )�orl r
r
r r' � s
r' c c s* | j � }| jdd� dV | j|d� dS )a Keep 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.
r r N)�tellrU )�bufferZoriginal_positionr
r
r rT � s rT c C sL t | t�sHt| d�r"t| j� |�S t| d�r4t| �S t| d�sHt| |�S | S )z5Ensure that every object's __len__ behaves uniformly.rm rl rY )rE r rC rm � FileWrapper)r? r r
r
r � coerce_data� s
rw c C s t | d�rt| j� �S t| �S )Nr< )rC rD r< )r r
r
r �to_list� s
rx c @ s0 e Zd Zdd� Zedd� �Zdd� Zdd� Zd S )
rM c C s, || _ || _d| _t| j �t| j� | _d S )NT)rA �body�headers_unreadr$ r' )r! rA ry r
r
r r" � s z
Part.__init__c C s$ t |j� |�}t|j|�}| ||�S )z8Create a part from a Request Field generated by urllib3.)r Zrender_headersrw r? )rd rK r rA ry r
r
r rN � s zPart.from_fieldc C s* d}| j r|t| j�7 }|t| j� dkS )z�Determine if there are bytes left to write.
:returns: bool -- ``True`` if there are bytes left to write, otherwise
``False``
r )rz r$ rA r' ry )r! Zto_readr
r
r r3 � s zPart.bytes_left_to_writec C sr d}| j r ||j| j�7 }d| _ xLt| j�dkrl|dks@||k rl|}|dkrT|| }||j| jj|��7 }q"W |S )a� Write 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
r Fr/ r0 r0 )rz rR rA r' ry rY )r! ru r\ r8 Zamount_to_readr
r
r r6 � s
z
Part.write_toN)r r r r" rg rN r3 r6 r
r
r
r rM � s rM c sB e Zd Zd
� fdd� Zdd� Zedd� �Zd d
� Zd d � Z� Z S )r N�utf-8c s t ||�}tt| �j|� d S )N)r �superr r" )r! ru r )� __class__r
r r" s
zCustomBytesIO.__init__c C s, | j � }| jdd� | j � }| j|d� |S )Nr r )rt rU )r! Z current_pos�lengthr
r
r �_get_end s
zCustomBytesIO._get_endc C s | j � }|| j� S )N)r rt )r! r~ r
r
r r$ ! s zCustomBytesIO.lenc C s" t | �� | j|�}W d Q R X |S )N)rT rV )r! rh r8 r
r
r rR & s
zCustomBytesIO.appendc C sR t | �}| j� | }||krN| j� }| jdd� | j� | j|� | jdd� d S )Nr )r' r rY rU �truncaterV )r! Z
to_be_readZ already_readZ old_bytesr
r
r r1 + s
z CustomBytesIO.smart_truncate)Nr{ )
r r r r" r r] r$ rR r1 �
__classcell__r
r
)r} r r s
r c @ s* e Zd Zdd� Zedd� �Zd
dd�ZdS ) rv c C s
|| _ d S )N)�fd)r! Z file_objectr
r
r r" 8 s zFileWrapper.__init__c C s t | j�| jj� S )N)r' r� rt )r! r
r
r r$ ; s zFileWrapper.lenr/ c C s | j j|�S )N)r� rY )r! r~ r
r
r rY ? s zFileWrapper.readNr0 )r0 )r r r r" r] r$ rY r
r
r
r rv 7 s rv c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS )
�FileFromURLWrappera� File 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}
)
Nc C s4 |p
t j� | _| j|�}t|jd �| _|j| _d S )Nzcontent-length) �requestsZSession�session�_request_for_filer[ rA r$ �raw�raw_data)r! �file_urlr� Zrequested_filer
r
r r" q s
zFileFromURLWrapper.__init__c C s\ | j j|dd�}|jjdd�}|dkr<dj|d�}t|��n |j� sXdj|d�}t|��|S )z&Make call for file under provided URL.T)�streamzcontent-lengthNzhData from provided URL {url} is not supported. Lack of content-length Header in requested file response.)ZurlzZData from provided URL {url} is not supported. content-length header value is not a digit.)r� �getrA r r �isdigit)r! r� ZresponseZcontent_lengthZ error_msgr
r
r r� w s
z$FileFromURLWrapper._request_for_filec C s@ |dkr |n| j }| jj|�p d}| j |r4t |�nd8 _ |S )zRead file in chunks.r r )r$ r� rY )r! Z
chunk_size�chunkr
r
r rY � s zFileFromURLWrapper.read)N)r r r r r" r� rY r
r
r
r r� C s ,
r� )r �
contextlibrn rp Zuuidr r� Z_compatr � Exceptionr �objectr r^ r_ r rj r' �contextmanagerrT rw rx rM �BytesIOr rv r� r
r
r
r �<module> s, (U
2"