d = dir(o)

if 'items' in d:

p = dict([(deunicode(x),deunicode(y)) for (x,y) in o.items()])

elif '__dict__' in d:

p = o.copy()

p.__dict__ = dict([(deunicode(x),deunicode(y))

for (x,y) in o.__dict__.items()])

elif '__iter__' in d:

p = [deunicode(x) for x in o]

elif o.__class__==unicode:

p = o.encode('ascii','replace')

else:

p = o

new_maps = []

locStr = { mpr.LOC_UNDEFINED: 'undefined',

mpr.LOC_SRC: 'src',

mpr.LOC_DST: 'dst' }

regexx = re.compile('x([0-9]+)')

regexy = re.compile('y([0-9]+)')

for m in db.device(device).maps():

this_map = m.properties.copy()

this_map['sources'] = []

this_map['destinations'] = []

if 'expression' in this_map:

# To get proper expression nomenclature

# dest[0] = src[0] NOT y = x

this_map['expression'] = m.expression.replace('y', 'dst[0]').replace('x', 'src[0]')

if 'process_loc' in this_map:

this_map['process_loc'] = locStr[m.process_loc]

if 'is_local' in this_map:

del this_map['is_local']

if 'status' in this_map:

del this_map['status']

if 'version' in this_map:

del this_map['version']

if 'num_inputs' in this_map:

del this_map['num_inputs']

if 'num_outputs' in this_map:

del this_map['num_outputs']

for i in range(m.num_signals(mpr.LOC_SRC)):

src = m.signal(mpr.LOC_SRC, i)

slot_props = {}

slot_props['name'] = src.device().name + '/' + src.name

this_map['sources'].append(slot_props)

for i in range(m.num_signals(mpr.LOC_DST)):

dst = m.signal(mpr.LOC_DST)

slot_props = {}

slot_props['name'] = dst.device().name + '/' + dst.name

this_map['destinations'].append(slot_props)

new_maps.append(this_map);

contents = {"fileversion": "2.2", "mapping": { "maps": new_maps } }

f = json.loads(mapping_json)

f = deunicode(f)

#The version we're currently working with

version = '';

if 'fileversion' in f:

version = f['fileversion']

elif 'mapping' in f and 'fileversion' in f['mapping']:

version = f['mapping']['fileversion']

if 'mapping' in f:

f = f['mapping']

else:

print('malformed file')

locIdx = { 'undefined': mpr.LOC_UNDEFINED,

'source': mpr.LOC_SRC,

'destination': mpr.LOC_DST }

src_dev = db.device(src_dev_names[0])

if not src_dev:

print("error loading file: couldn't find device ", src_dev_names[0], " in graph")

return

dst_dev = db.device(dst_dev_names[0])

if not dst_dev:

print("error loading file: couldn't find device ", dst_dev_names[0], " in graph")

return

if version == '2.1':

print("converting version 2.1 mapping file...")

# we need to modify a few things for compatibility

f['maps'] = []

for connection in f['connections']:

if not connection.has_key('mode'):

continue;

map = {}

src = { 'name': connection['source'][0].split('/', 1)[1] }

dst = { 'name': connection['destination'][0].split('/', 1)[1] }

if connection.has_key('mute'):

map['muted'] = connection['mute']

if connection.has_key('expression'):

map['expression'] = str(connection['expression']

.replace('s[', 'src[')

.replace('d[', 'dst['))

if connection.has_key('srcMin'):

src['minimum'] = connection['srcMin']

if connection.has_key('srcMax'):

src['maximum'] = connection['srcMax']

if connection.has_key('destMin'):

dst['minimum'] = connection['destMin']

if connection.has_key('destMax'):

dst['maximum'] = connection['destMax']

mode = connection['mode']

if mode == 'reverse':

map['expression'] = 'y=x'

map['sources'] = [ dst ]

map['destinations'] = [ src ]

else:

if mode == 'calibrate':

map['expression'] = 'y=linear(x,?,?,-,-)'

map['sources'] = [ src ]

map['destinations'] = [ dst ]

f['maps'].append(map)

del f['connections']

# "upgrade" version to 2.2

version = '2.2'

# This is a version 2.2 save file

if version == '2.2':

print("loading version 2.2 mapping file...")

# todo: we need to enable users to explictly define device matching

# for now we will just choose the first device...

for map_props in f['maps']:

sigs_found = True

# The name of the source signals without device name

src_sigs = []

for slot_props in map_props['sources']:

name = slot_props['name']

name = name.split('/', 1)[1]

sig = src_dev.signal(name)

if not sig:

sigs_found = False

continue

src_sigs.append(sig)

if not sigs_found:

continue

# And the destination signals

dst_sigs = []

for slot_props in map_props['destinations']:

name = slot_props['name']

name = name.split('/', 1)[1]

sig = dst_dev.signal(name)

if not sig:

sigs_found = False

continue

dst_sigs.append(sig)

if not sigs_found:

continue

map = mpr.map(src_sigs[0], dst_sigs[0])

if not map:

print("error creating map")

continue

# set slot properties first

index = 0

for slot_props in map_props['sources']:

slot = map.signal(mpr.LOC_SRC, index)

for prop in slot_props:

if prop == 'name':

# do nothing

pass

elif prop == 'minimum':

t = type(slot_props['minimum'])

if t is int or t is float:

slot.minimum = float(slot_props['minimum'])

else:

if t is str:

slot_props['minimum'] = slot_props['minimum'].replace(',',' ').split()

numargs = len(slot_props['minimum'])

for i in range(numargs):

slot_props['minimum'][i] = float(slot_props['minimum'][i])

if numargs == 1:

slot_props['minimum'] = slot_props['minimum'][0]

slot.minimum = slot_props['minimum']

elif prop == 'maximum':

t = type(slot_props['maximum'])

if t is int or t is float:

slot.maximum = float(slot_props['maximum'])

else:

if t is str:

slot_props['maximum'] = slot_props['maximum'].replace(',',' ').split()

numargs = len(slot_props['maximum'])

for i in range(numargs):

slot_props['maximum'][i] = float(slot_props['maximum'][i])

if numargs == 1:

slot_props['maximum'] = slot_props['maximum'][0]

slot.maximum = slot_props['maximum']

else:

slot.set_property(prop, slot_props[prop])

index += 1

index = 0

for slot_props in map_props['destinations']:

slot = map.signal(mpr.LOC_DST, index)

for prop in slot_props:

if prop == 'name':

# do nothing

pass

elif prop == 'minimum':

t = type(slot_props['minimum'])

if t is int or t is float:

slot.minimum = float(slot_props['minimum'])

else:

if t is str:

slot_props['minimum'] = slot_props['minimum'].replace(',',' ').split()

numargs = len(slot_props['minimum'])

for i in range(numargs):

slot_props['minimum'][i] = float(slot_props['minimum'][i])

if numargs == 1:

slot_props['minimum'] = slot_props['minimum'][0]

slot.minimum = slot_props['minimum']

elif prop == 'maximum':

t = type(slot_props['maximum'])

if t is int or t is float:

slot.maximum = float(slot_props['maximum'])

else:

if t is str:

slot_props['maximum'] = slot_props['maximum'].replace(',',' ').split()

numargs = len(slot_props['maximum'])

for i in range(numargs):

slot_props['maximum'][i] = float(slot_props['maximum'][i])

if numargs == 1:

slot_props['maximum'] = slot_props['maximum'][0]

slot.maximum = slot_props['maximum']

else:

slot.set_property(prop, slot_props[prop])

index += 1

# set map properties

for prop in map_props:

if prop == 'sources' or prop == 'destinations':

# do nothing

pass

elif prop == 'expression':

expression = map_props['expression']

expression = re.sub(r'src\[(\d*)\]', 'x\g<1>', expression)

expression = re.sub(r'dst\[(\d*)\]', 'y\g<1>', expression)

expression = re.sub(r'(x|y)0', '\g<1>', expression)

map.expression = expression

elif prop == 'muted':

map.muted = map_props['muted']

elif prop == 'mode':

# do nothing

print('skipping mode property')

else:

map.properties[prop] = map_props[prop]

map.push()

else:

print('Unknown file version')

# TODO: Strictly speaking we should wait until links are

# acknowledged before continuing with a connection. An

# asynchronous approach would be necessary for this, by