1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
import json
from nested_lookup import (
get_occurrence_of_key,
nested_delete,
nested_lookup,
nested_update,
)
from config_file.exceptions import ParsingError
from config_file.parsers.base_parser import BaseParser
from config_file.parsers.parse_value import parse_value
from config_file.utils import split_on_dot
class JsonParser(BaseParser):
"""
The JsonParser allows use of json files with ConfigFile. The syntax it
supports is a bit more flexible than the IniParser.
By default, the dot syntax is used. However, if you'd like to get/set/delete all
of a particular key, you can specify so with an optional parameter.
Example:
json = {
"key1": {
"key2": "foo",
"key1": "bar"
},
"foo": "bar"
}
parser = JsonParser(json.dumps(json))
parser.get('key1')
>>> { "key2": "foo", "key1": "bar" }
parser.get('key1.key2')
>>> "foo"
parser.get('key1', all=True)
>>> [{ "key2": "foo", "key1": "bar" }, "bar"]
"""
def __init__(self, file_contents: str):
"""Reads in the file contents into the parser."""
super().__init__(file_contents)
def parse(self, file_contents: str):
try:
return json.loads(file_contents)
except json.decoder.JSONDecodeError as error:
raise ParsingError(error)
def get(self, key: str, parse_types: bool = False, all: bool = False):
"""
Retrieve values using a dot syntax.
:param key: The key to retrieve. e.g. 'foo.bar.boo'
:param parse_types: Whether you'd like the type parsed into its native one.
:param all: Specify whether you'd like to recursively receive
all values that match the given key. Returned as a list.
e.g. 'foo' would retrieve all values that have the key 'foo', anywhere
in the json.
:return: the value of the given key
"""
if all:
result = nested_lookup(key, self.parsed_content)
elif "." in key:
split_keys = split_on_dot(key)
result = self.parsed_content
# Used so we can more precisely specify what key is causing the error.
key_for_error = None
try:
for key in split_keys:
key_for_error = key
result = result[key]
except TypeError:
raise ParsingError(
f"Cannot get {key} because {key_for_error} is not subscriptable."
)
else:
result = self.parsed_content[key]
return parse_value(result) if parse_types else result
def set(self, key: str, value, all: bool = False):
if all:
nested_update(self.parsed_content, key, value, in_place=True)
elif "." in key:
indexes = split_on_dot(key)
indexes_length = len(indexes)
ref = self.parsed_content
for index, key in enumerate(indexes):
if index == indexes_length - 1:
ref[key] = value
break
ref = ref[key]
else:
self.parsed_content[key] = value
return True
def delete(self, key, all: bool = False):
if all:
nested_delete(self.parsed_content, key, in_place=True)
elif "." in key:
indexes = split_on_dot(key)
indexes_length = len(indexes)
ref = self.parsed_content
for index, key in enumerate(indexes):
if index == indexes_length - 1:
del ref[key]
break
ref = ref[key]
else:
del self.parsed_content[key]
return True
def stringify(self) -> str:
return json.dumps(self.parsed_content)
def has(self, search_key: str) -> bool:
return get_occurrence_of_key(self.parsed_content, key=search_key) > 0
|