Basically what you do is correct. Looking at redmine docs you linked to, it seems that suffix after the dot in the url denotes type of posted data (.json for JSON, .xml for XML), which agrees with the response you get - Processing by AttachmentsController#upload as XML. I guess maybe there's a bug in docs and to post binary data you should try using http://redmine/uploads url instead of http://redmine/uploads.xml.

Btw, I highly recommend very good and very popular Requests library for http in Python. It's much better than what's in the standard lib (urllib2). It supports authentication as well but I skipped it for brevity here.

import requests
with open('./x.png', 'rb') as f:
    data = f.read()
res = requests.post(url='http://httpbin.org/post',
                    data=data,
                    headers={'Content-Type': 'application/octet-stream'})

# let's check if what we sent is what we intended to send...
import json
import base64

assert base64.b64decode(res.json()['data'][len('data:application/octet-stream;base64,'):]) == data

UPDATE

To find out why this works with Requests but not with urllib2 we have to examine the difference in what's being sent. To see this I'm sending traffic to http proxy (Fiddler) running on port 8888:

Using Requests

import requests

data = 'test data'
res = requests.post(url='http://localhost:8888',
                    data=data,
                    headers={'Content-Type': 'application/octet-stream'})

we see

POST http://localhost:8888/ HTTP/1.1
Host: localhost:8888
Content-Length: 9
Content-Type: application/octet-stream
Accept-Encoding: gzip, deflate, compress
Accept: */*
User-Agent: python-requests/1.0.4 CPython/2.7.3 Windows/Vista

test data

and using urllib2

import urllib2

data = 'test data'    
req = urllib2.Request('http://localhost:8888', data)
req.add_header('Content-Length', '%d' % len(data))
req.add_header('Content-Type', 'application/octet-stream')
res = urllib2.urlopen(req)

we get

POST http://localhost:8888/ HTTP/1.1
Accept-Encoding: identity
Content-Length: 9
Host: localhost:8888
Content-Type: application/octet-stream
Connection: close
User-Agent: Python-urllib/2.7

test data

I don't see any differences which would warrant different behavior you observe. Having said that it's not uncommon for http servers to inspect User-Agent header and vary behavior based on its value. Try to change headers sent by Requests one by one making them the same as those being sent by urllib2 and see when it stops working.

You are trying to upload binary files (word, jpg), serialised as JSON, and store them on the server.

To handle binary data in JSON, encode the binary data as base64 first, then call JSON.stringify.

Like this (untested):

function uploadFile(fileContent, fileName) {
    // Encode the binary data to as base64.
    const data = {
        fileContent: btoa(fileContent),
        fileName: fileName
    };
    axios.post('http://localhost:8080/api/uploadFile', JSON.stringify(data));
}

On the server side, you need to deserialise from JSON, decode the base64 and the open a file in binary mode to ensure that what you are writing to disk is the uploaded binary data. Opening the file in text mode requires that the data be encoded before writing to disk, and this encoding step will corrupt binary data.

Something like this ought to work:

class UploadFileHandler(tornado.web.RequestHandler):

    def post(self):
        requestBody = tornado.escape.json_decode(self.request.body)
        # Decode binary content from base64
        binary_data = base64.b64decode(requestBody[fileContent])
        # Open file in binary mode
        with open(requestBody["fileName"], "wb") as f:
            f.write(binary_data)

You need to make the binary blob into something that can be represented as a string (without random control characters, etc.). Typical approach there is to do some sort of encoding such as base64.

import base64
payload['content'] = base64.b64encode(fh.read())

That generates a hexadecimal string representation of the binary data.

Then on the other side:

fileData = base64.b64decode(payload['content'])

The earlier posts didn't really helped but I figured it out by referring the original doc of requests: Streaming uploads. Check doc here.

As my file was huge around 1.9 GB, so session was breaking in between the upload process, hence giving error as "Internal error".

As its huge file I streamed and upload it by providing a file-like object in my function:

def upload_code():
  jsonheaderup={'Content-Type': 'application/octet-stream'}
  with open('/root/ak-nas-2013-06-05-7-18-1-1-3-nd.pkg.gz', 'rb') as file:
    requests.post("%s/api/system/v1/updates" % (url), data=file, auth=zfsauth, verify=False, headers=jsonheaderup, timeout=None)

JSON data expects to handle Unicode strings. Binary image data (in the form of a bytes object) is not text, so when the json.dumps() function tries to process the data it throws an error.

You'll have to wrap your binary data in a text-safe encoding first, such as Base64:

import base64

json.dumps({'picture' : base64.b64encode(data).decode()})

Of course, this then assumes that the receiver expects your data to be wrapped so.

If your API endpoint has been so badly designed to expect your image bytes to be passed in as text, then the alternative is to pretend that your bytes are really text; if you first decode it as Latin-1 you can map those bytes straight to Unicode codepoints:

json.dumps({'picture' : data.decode('latin-1')})

This happens to work because the Latin-1 encoding can represent all 256 possible byte values.

With the data as a str object the json library will then proceed to treat it as text. This does mean that it can replace non-ASCII codepoints with \uhhhh escapes. Again, the receiver of the JSON payload must also expect the data to be encoded this way for this to work.

it may because you use multipart/form to upload file.try use data like code below

data = open(localFilePath, 'rb').read()
headers = {
    "Content-Type":"application/binary",
}
upload = requests.put(uploadUrl,data=data,headers=headers)

You need to decode it then split by '\n' and load each json object separately. If you store your byte string in a variable called byte_string you could do something like:

json_str = byte_string.decode('utf-8')
json_objs = json_str.split('\n')
for obj in json_objs:
    json.loads(obj)

For the particular string that you have posted here though, you will get an error on the second object because the second key in it is missing a double quote. It is name" in the string you linked.