agent-hellboy / trace-dkey

Python library to trace path of a particular key inside a nested dict

trace-dkey

Python library to trace path of a particular key inside a nested dict

Installation

For stable version

• pip install trace-dkey

For developement

• git clone https://github.com/Agent-Hellboy/trace-dkey
• cd trace-dkey
• python -m venv .venv
• source .venv/bin/activate

Example

you can use the library as python3 -m trace_dkey --file=test.json --key=name, test.json is

a json file containing name as key

>>> from trace_dkey import trace
>>> l={'a':{'b':{'c':{'d':{'e':{'f':1}}}}}}
>>> print(trace(l,'f'))
[['a', 'b', 'c', 'd', 'e', 'f']]

Now you can query it as l['a']['b']['c']['d']['e']['f']

>>> l['a']['b']['c']['d']['e']['f']
1

refer Tests_. for other examples

General Info

• The value returned by the trace function is an array of paths, where each path is an array of dictionary keys.
• Because of that, the library can be used in a practical way by taking advantage of this format.
• In the example below we use the returned path to iterate over the dictionary keys and print the key value:

from trace_dkey import trace
l={'a':{'b':{'c':{'d':{'e':{'f':1}}}}}}

paths = trace(l,'f')

for path in paths:
   dic = l
   for key in path:
      dic = dic[key]
   print(dic)

• This is addressing a wide range of question asked on stackoverflow about key inside a nested dict
• Atleast 13 duplicate questions can be found on stackoverflow
• This can be tracked on https://you.com/search?q=find%20key%20in%20nested%20dictionary%20python

Someone made a nice comparision of this lib(trace-dkey) with one of the famous lib(yamlpath) which is doing the similar thing

Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

trace-dkey's Issues

Function doesn't search for keys inside a found key

I think it's easier to explain with an example:

l = { 'a': { 'a': 1, 'b': 1 } }

trace(l,'a')

It should find both the root 'a' and the child 'a', but only root is found

Provide a command line interface which takes a json object/file and return the traced path of a particular key

Frozen dataclass can be hashable

from dataclasses import dataclass

@dataclass(frozen=True)
class Data:
    a: int 
    b: int 

data1 = Data(1,2)
print(data1)

dict = {data1: "firstdata"}

print(dict)

For now, we need a different branch to handle this scenario, and as we can assume this one is also _ast.Call object
we need to add a new branch for _ast.Call for frozen type which can be hashable

Resume resursion call only if value of a particular key is list of dict not list of string or some other types.

Here is one of the examples from the Jira API response
out = resp['fields']['labels'] = ['regression']
we are iterating over this list to fetch a key.

we need an extra check in this branch
https://github.com/Agent-Hellboy/trace-dkey/blob/main/src/trace_dkey/__init__.py#L37

Recursive function should return path instead of printing the path

trace-dkey/src/trace_dkey/__init__.py

Line 13 in 8448f16

def __trace_key(dict_key: Any, dict_value: Any, key, response: str) -> None:

This function should return the path of the key instead of printing in the mid

we can take inspiration from the following 2 problems of leetcode
https://leetcode.com/problems/count-good-nodes-in-binary-tree/
https://leetcode.com/problems/path-sum/

This is tricky as the key can be present inside 2 subdict
maybe this can be an extension to an approach of above 2 question

Add examples in example folder with response of famous opensource APIs

try to find the probable keys inside some open-source APIs to test the package.

Add unittest for the package

trace doesn't search if one of key is present in List of dict

This should work

>>> dic={'a':'b','c':{'d':[{'e':'f'}]}}
>>> trace(dic,'e')
[]

Add github workflow

Dictionary keys can be forzenset

>>> l = ["Geeks", "for", "Geeks"]
>>> s=frozenset(l) 
>>> s
frozenset({'for', 'Geeks'})
>>> dict={1:'a',2:{s:'frozenset'}}
>>> from trace_dkey import trace
>>> trace(dict,p)
[]

this should return [2,s]
but this is very tricky as frozenset are ast.Call object [<ast.Call object at 0x7fafe8919d90>]

Gather all types from python-data-model which can be hashable

reference -> https://docs.python.org/3/reference/datamodel.html