def getChangable(self): ret = {} for key, gener in self.flat_params.items(): temp = gener.x if isinstance(temp, unicode): temp = temp.encode('ascii', 'ignore') ret[key] = temp return unflatten(ret)
def reset(self, jsonStr): raw = json.loads(jsonStr) self.flat_params = flatten(raw) for key in self.flat_params: val, dtype = checkAndConvert(self.flat_params[key]) self.flat_params[key] = val self.params = unflatten(self.flat_params)
def parse_params(path, naked_params): flat_params = {} for param in naked_params: if 'SecureString' in param.values(): param['Value'] = encrypt(param['Value']) key = param['Name'] key = key.replace(f'{path}', '') value = param['Value'] try: value = int(value) except: logger.info('Value is not an int.') new_param = {key: value} flat_params = {**flat_params, **new_param} logger.info('Flat params parsed!') unflat_params = unflatten(flat_params, '.') logger.info(f'Params: {unflat_params}') params = json.dumps(unflat_params) return params
def analyse_meta(soup=None, analyse_elements=None, website=None): meta_data_dict = {} all_meta_elems = soup.select('meta') for meta_elem in all_meta_elems: meta_property = meta_elem.get('property') if meta_property: meta_data_dict[meta_property.replace(":", "__")] = meta_elem.get('content') return unflatten(meta_data_dict, separator="__")
def set(self, *args): assert len(args) > 1, 'key,..., value' key = getKey(args[:-1]) val, dtype = checkAndConvert(args[-1]) if key in self.params: self.params[key] = val self.flat_params = flatten(self.params) elif key in self.flat_params: self.flat_params[key] = val self.params = unflatten(self.flat_params)
def reset(self, jsonStr): if isinstance(jsonStr, string_types): raw = json.loads(jsonStr) else: raw = jsonStr self.flat_params = flatten(raw) for key in self.flat_params: val = checkAndConvertObject(self.flat_params[key]) self.flat_params[key] = val self.params = unflatten(self.flat_params)
def test_unflatten_no_list(self): dic = { 'a': 1, 'b_a': 2, 'b_b': 3, 'c_a_b': 5 } expected = { 'a': 1, 'b': {'a': 2, 'b': 3}, 'c': {'a': {'b': 5}} } actual = unflatten(dic) self.assertEqual(actual, expected)
def read_config(): if request.method == 'GET': try: with open(CONFIG_LOCATION, 'r') as f: config = json.load(f) except Exception as e: return str(e) flat_json = [{ 'name': k, 'value': v } for k, v in flatten_json(config).items()] sorted_flat_json = sorted(flat_json, key=lambda k: k['name']) return jsonify(sorted_flat_json) elif request.method == 'POST': result = request.form result = unflatten(result) with open(CONFIG_LOCATION, 'w') as f: json.dump(result, f, indent=4) return redirect(url_for('scoreboard'))
def read_all(): """ This function responds to a request for /api/landingZoneWANs with the complete lists of landingZoneWANs :return: json string of list of landingZoneWANs """ # Create the list of people from our data landingZoneWANs = LandingZoneWAN.query.all() landingZoneWANArr = [] for lzw in landingZoneWANs: landingZoneWANArr.append(unflatten(lzw.__dict__, delimiter)) # Serialize the data for the response eschema = ExtendedLandingZoneWANSchema(many=True) data = eschema.dump(landingZoneWANArr) app.logger.debug("landingZoneWAN data:") app.logger.debug(pformat(data)) return data
def _parse_params(path_params): from flatten_json import unflatten from yaml import safe_load, YAMLError from dvc.dependency.param import ParamsDependency ret = {} for path_param in path_params: path, _, params_str = path_param.rpartition(":") # remove empty strings from params, on condition such as `-p "file1:"` params = {} for param_str in filter(bool, params_str.split(",")): try: # interpret value strings using YAML rules key, value = param_str.split("=") params[key] = safe_load(value) except (ValueError, YAMLError): raise InvalidArgumentError( f"Invalid param/value pair '{param_str}'") if not path: path = ParamsDependency.DEFAULT_PARAMS_FILE ret[path] = unflatten(params, ".") return ret
def read_one(oid): """ This function responds to a request for /api/landingZoneWAN/{oid} with one matching landingZoneWAN from landingZoneWANs :param landingZoneWAN: id of the landingZoneWAN to find :return: landingZoneWAN matching the id """ landingZoneWAN = (LandingZoneWAN.query.filter( LandingZoneWAN.id == oid).one_or_none()) if landingZoneWAN is not None: # Serialize the data for the response landingZoneWAN_schema = ExtendedLandingZoneWANSchema(many=False) unflattened_landingZoneWAN = unflatten(landingZoneWAN.__dict__, delimiter) data = landingZoneWAN_schema.dump(unflattened_landingZoneWAN) app.logger.debug("landingZoneWAN data:") app.logger.debug(pformat(data)) return data else: abort(404, f"LandingZoneWAN with id {oid} not found".format(id=oid))
def _to_jsonld(microdata): context = 'http://schema.org' properties = 'properties_' typestr = 'type' jsonld_data = {} jsonld_data["@context"] = context for data in microdata: data = flatten_json.flatten(data) for key in data.keys(): value = data[key] if context in value: value = value.replace(context + "/", "") if (properties in key): keyn = key.replace(properties, "") jsonld_data[keyn] = value if (typestr in keyn): keyn = keyn.replace(typestr, "@" + typestr) jsonld_data[keyn] = value if (typestr is key): keyn = key.replace(typestr, "@" + typestr) jsonld_data[keyn] = value del data jsonld_data = flatten_json.unflatten(jsonld_data) return [jsonld_data]
def __str__(self): ret_dict = {} for key in self.flat_params: ret_dict[key] = str(self.flat_params[key]) ret_dict = unflatten(ret_dict) return json.dumps(ret_dict, indent=4)
def group_underscore_key(row): pprint.pprint(row) return unflatten(row, '__')
def refsolver(self, fileloc): try: json_path = fileloc except Exception as e: print('json-path-file-issue', e) makeJsoncCommon = [] makeJsoncCommon = json_path.split('/') cPathPath = '' for cPath in makeJsoncCommon[:len(makeJsoncCommon) - 1]: cPathPath = cPathPath + '/' + cPath json_common = cPathPath[1:] + '/' list = [] JDF_list = [] InnerDictJSON = dict() def find_nth(string, substring, n): if (n == 1): return string.find(substring) else: return string.find(substring, find_nth(string, substring, n - 1) + 1) def update_json(json_path): with open(json_path) as json_file: data = json.load(json_file) data['properties'].update(InnerDictJSON) return data with open(json_path) as json_file: data = json.load(json_file) d = flatten(data) for key in d: if key[len(key) - 4:len(key)] == '$ref': a = json_common + d[key][:d[key].find('#')] list = d[key][d[key].find('properties/'):].split('/') with open(a) as json_file: data1 = json.load(json_file) x = "data1" + "['" + list[0] + "']" eval_val = eval(x) for test1 in eval_val: for j in list: if j in (test1): dict1 = {j: eval_val[test1]} InnerDictJSON.update(dict1) fnl_json = update_json(json_path) FltJSON = flatten(fnl_json) def merge_json(FltJSON, InnerDictJSON): for InFltJSON in FltJSON: if InFltJSON[len(InFltJSON) - 4:len(InFltJSON)] == '$ref': str = InFltJSON refListVals = [] refListVals = FltJSON[InFltJSON].split('/') #teston feb2020 refKeyTag = refListVals[len(refListVals) - 1] if refKeyTag in InnerDictJSON: f = dict({str: InnerDictJSON[refKeyTag]}) FltJSON.update(f) return FltJSON FltJSON = merge_json(FltJSON, InnerDictJSON) x = flatten(FltJSON) def json_key_replace(x, charval, replace_with): for y in x: InFltJSON = y.replace(charval, replace_with) x[InFltJSON] = x.pop(y) return x x = json_key_replace(x, '_$ref_', '_') fnl_json = unflatten(x) build_flat = flatten(fnl_json) build_flat = json_key_replace(build_flat, '_$ref_', '_') try: fnl_json = unflatten(build_flat) except Exception as e: print('Issue Raised with unFlatten', e) try: FltJSON = flatten(fnl_json) except Exception as e: print('Issue Raised while Flatten', e) FltJSON = merge_json(FltJSON, InnerDictJSON) x = flatten(FltJSON) try: x = json_key_replace(x, '_$ref', '') x = json_key_replace(x, '_$ref_', '') x = json_key_replace(x, '$ref_', '') x = json_key_replace(x, '_0', '0') x = json_key_replace(x, '_1', '1') except Exception as e: print('issue raised with json_key_replace', e) try: fnl_json = unflatten(x) except Exception as e: e modlist = [] for diffnode in fnl_json['properties']: if not diffnode in data['properties']: modlist.append(diffnode) for fnlreplacement in modlist: fnl_json['properties'].pop(fnlreplacement) try: fnl_json = json.dumps(fnl_json) except Exception as e: fnl_json = '' print('Failed:', e) return fnl_json
def unflatten(self, flatten): return flatten_json.unflatten(flatten, separator='__')