query json che restituisce l'elemento padre e i dati figlio?

Question

Dati i seguenti JSON:

{ 
    "README.rst": { 
     "_status": { 
      "md5": "952ee56fa6ce36c752117e79cc381df8" 
     } 
    }, 
    "docs/conf.py": { 
     "_status": { 
      "md5": "6e9c7d805a1d33f0719b14fe28554ab1" 
     } 
    } 
} 

c'è un linguaggio di query che può produrre:

{ 
    "README.rst": "952ee56fa6ce36c752117e79cc381df8", 
    "docs/conf.py": "6e9c7d805a1d33f0719b14fe28554ab1", 
} 

mio miglior tentativo finora con JMESPath (http://jmespath.org/) non è molto vicino:

>>> jmespath.search('*.*.md5[]', db) 
['952ee56fa6ce36c752117e79cc381df8', '6e9c7d805a1d33f0719b14fe28554ab1'] 

Sono arrivato allo stesso punto con ObjectPath (http://objectpath.org):

>>> t = Tree(db) 
>>> list(t.execute('$..md5')) 
['952ee56fa6ce36c752117e79cc381df8', '6e9c7d805a1d33f0719b14fe28554ab1'] 

non ho potuto dare un senso a JSONiq (ne ho veramente bisogno di leggere un manuale di 105 pagina di fare questo?) Questa è la mia prima volta guardando linguaggi di query JSON ..

Answer 1

Mancato il requisito Python, ma se si è disposti a chiamare il programma esterno, questo funzionerà ancora. Si noti che per funzionare è necessario jq> = 1.5.

# If single "key" $p[0] has multiple md5 keys, this will reduce the array to one key. 
cat /tmp/test.json | \ 
jq-1.5 '[paths(has("md5")?) as $p | { ($p[0]): getpath($p)["md5"]}] | add ' 

# this will not create single object, but you'll see all key, md5 combinations 
cat /tmp/test.json | \ 
jq-1.5 '[paths(has("md5")?) as $p | { ($p[0]): getpath($p)["md5"]}] ' 

Ottenere percorsi con "md5" -key '?' = Ignorare errori (come test di scalare per chiave). Dai percorsi risultanti ($ p) filtrano e circondano il risultato con '{}' = oggetto. E poi quelli sono in un array ([] che circonda l'intera espressione), che è poi "ha aggiunto/fuse" insieme |add

https://stedolan.github.io/jq/

Answer 2

non so perché si vuole un linguaggio di query questo è abbastanza facile

def find_key(data,key="md5"): 
    for k,v in data.items(): 
     if k== key: return v 
     if isinstance(v,dict): 
      result = find_key(v,key) 
      if result:return result 

dict((k,find_key(v,"md5")) for k,v in json_result.items()) 

è ancora più facile se il valore dict ha sempre "_status" e "md5" come chiavi

dict((k,v["_status"]["md5"]) for k,v in json_result.items()) 

alternativamente I pensa che si potrebbe fare qualcosa di simile

t = Tree(db) 
>>> dict(zip(t.execute("$."),t.execute('$..md5')) 

anche se Non so che li avrebbe abbinare perfettamente ragione ...

Answer 3

Una soluzione che implementa un nuovo linguaggio di query:

def keylist(db): 
    "Return all the keys in db." 

    def _keylist(db, prefix, res): 
     if prefix is None: 
      prefix = [] 

     for key, val in db.items(): 
      if isinstance(val, dict): 
       _keylist(val, prefix + [key], res) 
      else: 
       res.append(prefix + [key]) 

    res = [] 
    _keylist(db, [], res) 
    return ['::'.join(key) for key in res] 

def get_key(db, key): 
    "Get path and value from key." 

    def _get_key(db, key, path): 
     k = key[0] 
     if len(key) == 1: 
      return path + [k, db[k]] 
     return _get_key(db[k], key[1:], path + [k]) 

    return _get_key(db, key, []) 

def search(query, db): 
    "Convert query to regex and use it to search key space." 
    keys = keylist(db) 
    query = query.replace('*', r'(?:.*?)') 
    matching = [key for key in keys if re.match(query, key)] 
    res = [get_key(db, key.split('::')) for key in matching] 
    return dict(('::'.join(r[:-1]), r[-1]) for r in res) 

che dà qualcosa che è abbastanza vicino ai requisiti:

>>> pprint.pprint(search("*::md5", db)) 
{'README.rst::_status::md5': '952ee56fa6ce36c752117e79cc381df8', 
'docs/conf.py::_status::md5': '6e9c7d805a1d33f0719b14fe28554ab1'} 

e un linguaggio di query che sembra s come un glob/re ibrido (se stiamo facendo un nuovo linguaggio, almeno farlo sembrare familiare):

>>> pprint.pprint(search("docs*::md5", db)) 
{'docs/conf.py::_status::md5': '6e9c7d805a1d33f0719b14fe28554ab1'} 

poiché i dati contiene percorsi di file che ho usato in modo casuale :: come un separatore di percorso. (Sono abbastanza sicuro che non gestisca ancora la grammatica completa di JSON, ma che dovrebbe essere per lo più un lavoro da grugnito).

Answer 4

Se il JSON è ben strutturato, vale a dire. assicurato che avrai i sottoelementi _status e md5, potresti semplicemente caricare il json e usare una comprensione di lista per sputare gli oggetti che stai cercando.

>>> import json 
>>> my_json = json.loads(json_string) 
>>> print [(key, value['_status']['md5']) for key, value in my_json.iteritems()] 
[(u'README.rst', u'952ee56fa6ce36c752117e79cc381df8'), (u'docs/conf.py', u'6e9c7d805a1d33f0719b14fe28554ab1')] 

Answer 5

Ecco il codice JSONiq che fa il lavoro:

{| 
    for $key in keys($document) 
    return { 
     $key: $document.$key._status.md5 
    } 
|} 

È possibile eseguirlo here con il motore di Zorba.

Se il manuale di 105 pagine di cui si parla è la specifica, non è consigliabile leggerlo come utente JSONiq. Preferirei consigliare di leggere tutorial o libri online, che offrono un'introduzione più gentile.

Answer 6

Do in ObjectPath:

l = op.execute("[keys($.*), $..md5]") 

si otterrà:

[ 
    [ 
    "README.rst", 
    "docs/conf.py" 
    ], 
    [ 
    "952ee56fa6ce36c752117e79cc381df8", 
    "6e9c7d805a1d33f0719b14fe28554ab1" 
    ] 
] 

poi in Python:

dict(zip(l[0],l[1])) 

per ottenere:

{ 
    'README.rst': '952ee56fa6ce36c752117e79cc381df8', 
    'docs/conf.py': '6e9c7d805a1d33f0719b14fe28554ab1' 
} 

Spero che questo aiuti. :)

PS. Sto usando i tasti OP() per mostrare come creare un'interrogazione completa che funzioni in qualsiasi parte del documento, non solo quando le chiavi sono nella radice del documento.

PS2. Potrei aggiungere una nuova funzione in modo che assomigli a: object ([keys ($. *), $ .. md5]). Sparami tweet http://twitter.com/adriankal se lo vuoi.