How to decode dataTables Editor form in python flask?

Question

I have a flask application which is receiving a request from dataTables Editor. Upon receipt at the server, request.form looks like (e.g.)

ImmutableMultiDict([('data[59282][gender]', u'M'), ('data[59282][hometown]', u''), 
('data[59282][disposition]', u''), ('data[59282][id]', u'59282'),
('data[59282][resultname]', u'Joe Doe'), ('data[59282][confirm]', 'true'), 
('data[59282][age]', u'27'), ('data[59282][place]', u'3'), ('action', u'remove'), 
('data[59282][runnerid]', u''), ('data[59282][time]', u'29:49'),
('data[59282][club]', u'')])

I am thinking to use something similar to this really ugly code to decode it. Is there a better way?

from collections import defaultdict

# request.form comes in multidict [('data[id][field]',value), ...]
# so we need to exec this string to turn into python data structure
data = defaultdict(lambda: {})   # default is empty dict

# need to define text for each field to be received in data[id][field]
age = 'age'
club = 'club'
confirm = 'confirm'
disposition = 'disposition'
gender = 'gender'
hometown = 'hometown'
id = 'id'
place = 'place'
resultname = 'resultname'
runnerid = 'runnerid'
time = 'time'

# fill in data[id][field] = value
for formkey in request.form.keys():
    exec '{} = {}'.format(d,repr(request.form[formkey]))

Answer 1

I decided on a way that is more secure than using exec:

from collections import defaultdict

def get_request_data(form):
    '''
    return dict list with data from request.form

    :param form: MultiDict from `request.form`
    :rtype: {id1: {field1:val1, ...}, ...} [fieldn and valn are strings]
    '''

    # request.form comes in multidict [('data[id][field]',value), ...]

    # fill in id field automatically
    data = defaultdict(lambda: {})

    # fill in data[id][field] = value
    for formkey in form.keys():
        if formkey == 'action': continue
        datapart,idpart,fieldpart = formkey.split('[')
        if datapart != 'data': raise ParameterError, "invalid input in request: {}".format(formkey)

        idvalue = int(idpart[0:-1])
        fieldname = fieldpart[0:-1]

        data[idvalue][fieldname] = form[formkey]

    # return decoded result
    return data

Answer 2

This question has an accepted answer and is a bit old but since the DataTable module seems being pretty popular among jQuery community still, I believe this approach may be useful for someone else. I've just wrote a simple parsing function based on regular expression and dpath module, though it appears not to be quite reliable module. The snippet may be not very straightforward due to an exception-relied fragment, but it was only one way to prevent dpath from trying to resolve strings as integer indices I found.

import re, dpath.util

rxsKey = r'(?P<key>[^\W\[\]]+)'
rxsEntry = r'(?P<primaryKey>[^\W]+)(?P<secondaryKeys>(\[' \
         + rxsKey \
         + r'\])*)\W*'

rxKey = re.compile(rxsKey)
rxEntry = re.compile(rxsEntry)

def form2dict( frmDct ):
    res = {}
    for k, v in frmDct.iteritems():
        m = rxEntry.match( k )
        if not m: continue
        mdct = m.groupdict()
        if not 'secondaryKeys' in mdct.keys():
            res[mdct['primaryKey']] = v
        else:
            fullPath = [mdct['primaryKey']]
            for sk in re.finditer( rxKey, mdct['secondaryKeys'] ):
                k = sk.groupdict()['key']
                try:
                    dpath.util.get(res, fullPath)
                except KeyError:
                    dpath.util.new(res, fullPath, [] if k.isdigit() else {})
                fullPath.append(int(k) if k.isdigit() else k)
            dpath.util.new(res, fullPath, v)
    return res

The practical usage is based on native flask request.form.to_dict() method:

    # ... somewhere in a view code
    pars = form2dict(request.form.to_dict())

The output structure includes both, dictionary and lists, as one could expect. E.g.:

# A little test:
rs = jQDT_form2dict( {
        'columns[2][search][regex]' : False,
        'columns[2][search][value]' : None,
        'columns[2][search][regex]' : False,
    } )

generates:

{
    "columns": [
        null, 
        null, 
        {
            "search": {
                "regex": false, 
                "value": null
            }
        }
    ]
}

Update: to handle lists as dictionaries (in more efficient way) one may simplify this snippet with following block at else part of if clause:

    # ...
    else:
        fullPathStr = mdct['primaryKey']
        for sk in re.finditer( rxKey, mdct['secondaryKeys'] ):
            fullPathStr += '/' + sk.groupdict()['key']
        dpath.util.new(res, fullPathStr, v)