You're escaping the inner double quote " in your string. It should be:

b"{\"Machine Name\":\""+hostname+"\"}", None, True)

In python you can also use single quotes ' for strings - and you don't need to escape double quotes inside single quoted strings

b'{"Machine Name":"'+hostname+'"}', None, True)

There are two better ways of doing this though. The first is string formatting which inserts a variable into a string:

b'{"Machine Name":"%s"}' % hostname # python 2.x (old way)
b'{{"Machine Name":"{0}"}}'.format(hostname) # python >= 2.6 (new way - note the double braces at the ends)

The next is with the Python JSON module by converting a python dict to a JSON string

>>> hostname = "machineA.host.com"
>>> data = {'Machine Name': hostname}
>>> json.dumps(data)
'{"Machine Name": "machineA.host.com"}'

This is probably the preferred method as it will handle escaping weird characters in your hostname and other fields, ensuring that you have valid JSON at the end.

Is there a reason you're using a bytestring

The reason your string isn't working is because you used double quotes " for the string instead of single quotes '. Since json format requires double quotes, you only should be using double quotes inside the string itself and then use the single quotes to denote the start/end of a string. (That way you don't need to keep using those \" unnecessarily.
Also, .format() can help with putting variables inside strings to make them easier.

This should fix your json string:

targetTemp = 17

payload = '{\n    "nodes": [{\n        "attributes": {\n            "targetHeatTemperature": {\n                "targetValue": {},\n            }\n        }\n    }]\n}'.format(targetTemp)

However, using the json module makes things a lot easier because it allows you to pass in a python dictionary which can be converted from/to a json string.

Example using the json package:

import json

targetTemp = 17

payload = {
    "nodes": [{
        "attributes": {
            "targetHeatTemperature": {
                "targetValue": targetTemp
            }
        }
    }]
}

payload_json = json.dumps(payload)  # Convert dict to json string

You just need to produce a python representation (lists + dicts etc.) of the structure you want and then use the json library to dump it to a file.

So in your case,

import json

# Get these from input
filename = "test.json"
width = 3
height = 5
placeholder = 1255255255

obj = {
    "width": width,
    "height": height,
    "column": [{row: placeholder for row in range(height)} for col in range(width)]
}

with open(filename, "w") as out_file:
    json.dump(obj, out_file)

You should append it to a list:

import json
line_items=[]
for q in ItemDetails:
    myItemName = q[0]
    myQuantity = q[1]
    myUnitAmount = float(q[2])
    myItemCode = str(q[3])

    myjson3 = {
                'ItemCode': myItemCode,
                'Description': myItemName,
                'UnitAmount': myUnitAmount * myDiscount,
                'Quantity': myQuantity,
                'AccountCode': myAccountCode,
                'TaxType': myTaxType
            }
    line_items.append(myjson3)
print(json.dumps(line_items))

Create a normal python dictionary, then convert it to JSON.

raw_data = {
    CONST_DB_NAME: getDbNameValue()
}

# ...

json_data = json.dumps(raw_data)
# Use json_data in your PUT request.

I think you're making this much more complicated than it needs to be.

with open('document.json') as f:
    d = json.load(f)

time_minutes_coords = d['boxes']['time_minutes']['coord']
time_seconds_coords = d['boxes']['time_seconds']['coord']
score_home_coords = d['boxes']['score_home']['coord']

If you actually want to create named variables in the local scope from the keys in your json file, you can use the locals() dictionary (but this is a terrible idea, it's far better just to reference them from the json dictionary).

# Flatten the dictionary keys.
# This turns ['boxes']['time_minutes']['coord'] 
# into "boxes_time_minutes_coord"
def flatten_dict(d, k_pre=None, delim='_', fd=None):
    if fd is None:
        fd = {}
    for k, v in d.iteritems():
        if k_pre is not None:
            k = '{0}{1}{2}'.format(k_pre, delim, k)
        if isinstance(v, dict):
            flatten_dict(v, k, delim, fd)
        else:
            fd[k] = v
    return fd

fd = flatten_dict(d)
locals().update(fd)

print boxes_time_minutes_coord

Lots of caveats, like the possibility of overwriting some other variable in your local scope, or the possibility that two dictionary keys could be identical after flattening unless you choose a delimiter that doesn't appear in any of the dictionary keys. Or that this won't work if your keys contain invalid characters for variable names (like spaces for example).

You build the object before encoding it to a JSON string:

import json

data = {}
data['key'] = 'value'
json_data = json.dumps(data)

JSON is a serialization format, textual data representing a structure. It is not, itself, that structure.