Basically, if you specify a files parameter (a dictionary), then requests will send a multipart/form-data POST instead of a application/x-www-form-urlencoded POST. You are not limited to using actual files in that dictionary, however:

>>> import requests
>>> response = requests.post('http://httpbin.org/post', files=dict(foo='bar'))
>>> response.status_code
200

and httpbin.org lets you know what headers you posted with; in response.json() we have:

>>> from pprint import pprint
>>> pprint(response.json()['headers'])
{'Accept': '*/*',
 'Accept-Encoding': 'gzip, deflate',
 'Connection': 'close',
 'Content-Length': '141',
 'Content-Type': 'multipart/form-data; '
                 'boundary=c7cbfdd911b4e720f1dd8f479c50bc7f',
 'Host': 'httpbin.org',
 'User-Agent': 'python-requests/2.21.0'}

And just to be explicit: you should not set the Content-Type header when you use the files parameter, leave this to requests because it needs to specify a (unique) boundary value in the header that matches the value used in the request body.

Better still, you can further control the filename, content type and additional headers for each part by using a tuple instead of a single string or bytes object. The tuple is expected to contain between 2 and 4 elements; the filename, the content, optionally a content type, and an optional dictionary of further headers.

I'd use the tuple form with None as the filename, so that the filename="..." parameter is dropped from the request for those parts:

>>> files = {'foo': 'bar'}
>>> print(requests.Request('POST', 'http://httpbin.org/post', files=files).prepare().body.decode('utf8'))
--bb3f05a247b43eede27a124ef8b968c5
Content-Disposition: form-data; name="foo"; filename="foo"

bar
--bb3f05a247b43eede27a124ef8b968c5--
>>> files = {'foo': (None, 'bar')}
>>> print(requests.Request('POST', 'http://httpbin.org/post', files=files).prepare().body.decode('utf8'))
--d5ca8c90a869c5ae31f70fa3ddb23c76
Content-Disposition: form-data; name="foo"

bar
--d5ca8c90a869c5ae31f70fa3ddb23c76--

files can also be a list of two-value tuples, if you need ordering and/or multiple fields with the same name:

requests.post(
    'http://requestb.in/xucj9exu',
    files=(
        ('foo', (None, 'bar')),
        ('foo', (None, 'baz')),
        ('spam', (None, 'eggs')),
    )
)

If you specify both files and data, then it depends on the value of data what will be used to create the POST body. If data is a string, only it willl be used; otherwise both data and files are used, with the elements in data listed first.

There is also the excellent requests-toolbelt project, which includes advanced Multipart support. It takes field definitions in the same format as the files parameter, but unlike requests, it defaults to not setting a filename parameter. In addition, it can stream the request from open file objects, where requests will first construct the request body in memory:

from requests_toolbelt.multipart.encoder import MultipartEncoder

mp_encoder = MultipartEncoder(
    fields={
        'foo': 'bar',
        # plain file object, no filename or mime type produces a
        # Content-Disposition header with just the part name
        'spam': ('spam.txt', open('spam.txt', 'rb'), 'text/plain'),
    }
)
r = requests.post(
    'http://httpbin.org/post',
    data=mp_encoder,  # The MultipartEncoder is posted as data, don't use files=...!
    # The MultipartEncoder provides the content-type header with the boundary:
    headers={'Content-Type': mp_encoder.content_type}
)

Fields follow the same conventions; use a tuple with between 2 and 4 elements to add a filename, part mime-type or extra headers. Unlike the files parameter, no attempt is made to find a default filename value if you don't use a tuple.

The docs have an example http://requests.readthedocs.org/en/latest/user/quickstart/#post-a-multipart-encoded-file

You should really start there for simple use cases.

This answer also explains using files and data together.

https://stackoverflow.com/a/12385661/1182891

Here is a working example for people who want cut-n-paste code. httpbin returns a json data structure describing the request you made do it. In this case you can see that files contains the file data posted and form contains the form vars. headers shows that it was indeed a multipart/form-data request.

>>> import requests
>>> from pprint import pprint
>>> url = 'http://httpbin.org/post'
>>> files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')}
>>> response = requests.post(url, data={
...   'description' :'Some desc',
...   'release_notes_url':'Someurl.pdf'
...   }, files=files)
>>> pprint(response.json())
{u'args': {},
 u'data': u'',
 u'files': {u'file': u'some,data,to,send\nanother,row,to,send\n'},
 u'form': {u'description': u'Some desc', u'release_notes_url': u'Someurl.pdf'},
 u'headers': {u'Accept': u'*/*',
              u'Accept-Encoding': u'gzip, deflate',
              u'Content-Length': u'394',
              u'Content-Type': u'multipart/form-data; boundary=ebf9f03029db4c2799ae16b5428b06bd',
              u'Host': u'httpbin.org',
              u'User-Agent': u'python-requests/2.10.0'},
 u'json': None,
 u'origin': u'73.0.41.38',
 u'url': u'http://httpbin.org/post'}

Enjoy!

There is a nice tool which helps you to easily convert CURL to Python code. You can have a look:

https://curlconverter.com/

Also, the CURL that you've attached will be converted to something like this.

import requests

headers = {
    'accept': 'application/json',
    # requests won't add a boundary if this header is set when you pass files=
    # 'Content-Type': 'multipart/form-data',
}

files = {
    'strictQuotes': (None, ''),
    'escape': (None, '"'),
    'continueOnError': (None, ''),
    'separator': (None, ';'),
    'deleteFile': (None, ''),
    'simulation': (None, ''),
    'fileName': (None, 'synchronization_file'),
    'headerRow': (None, ''),
    'ignoreLeadingWhitespace': (None, ''),
    'sendNotification': (None, ''),
    'fileId': (None, ''),
    'template': (None, ''),
    'saveResult': (None, ''),
    'batchSize': (None, '1000'),
    'file': open('testSourceFile.csv;type=text/csv', 'rb'),
    'quote': (None, '"'),
}

response = requests.post('https://genericurl.com/rest/endpoint', headers=headers, files=files)

payload = { 'username':'xxxxx',
            'passwd':'xxxx'}
session = requests.Session()
req = session.post('https://exemple.com/0',data=payload)

payload ={'check_type_diff':'0',
          'category':'19',
          'company_ad':'0'}


req = session.post('https://exemple.com/0', data=payload )
print req.content

Note: You should use post('URL',files=files) if you have file content. The multipart data just works as a normal data, just the formatting and the method is not the same.

Example: If you have a file and some multipart data, your code will be like this:

files = {"file":(filename1,open(location+'/'+filename,"rb"),'application-type')}
payload ={'file-name':'Filename',
          'category':'19'}


req = session.post('https://exemple.com/0', data=payload, file=files)
print req.content

You don't even need to add the line "file" into the payload, the requests will put the request together.