def generate_schema(data):
schema = genson.Schema()
schema.add_schema({})
# To get rid of nasty type errors, pingpong forth and back to JSON compatible: JSON
json_data = json.dumps(data)
dictionary = json.loads(json_data)
schema.add_object(dictionary)
# Replace MongoDB-incompatible dot with unicode FULLWIDTH FULLSTOP
schema_dict = schema.to_dict()
for key, value in schema_dict['items']['properties'].items():
if '.' in key:
new_key = key.replace('.', '\uff0e')
schema_dict['items']['properties'][new_key] = schema_dict[
'items']['properties'].pop(key)
required_ = schema_dict['items']['required']
for required_val in required_:
if '.' in required_val:
required_.append(
required_.pop(required_.index(required_val)).replace(
'.', '\uff0e'))
return schema_dict
def generateJsonObjects(num):
s = genson.Schema()
for o in range(num):
s.add_schema({str(o): generateJsonObject()})
return s.to_json()
def json_to_schema(self, data):
schema = genson.Schema()
schema.add_object(data)
schema = schema.to_json()
if isinstance(schema, str):
schema = json.loads(schema)
return schema
def create_json_schema(response_json_file_path):
json_obj = json.loads(
codecs.open(response_json_file_path, 'r', 'utf-8').read())
schema = genson.Schema()
schema.add_object(json_obj)
schema_file_path = os.path.join(os.path.dirname(response_json_file_path),
'schema.json')
schema_file = codecs.open(schema_file_path, 'w', 'utf-8')
schema_file.write(schema.to_json(ensure_ascii=False, indent=4))
schema_file.close()
def __init__(self, yaml_spec_fn):
super(YamlCommandContent, self).__init__(yaml_spec_fn.__doc__)
schema = yaml_spec_fn()
if schema is not None:
if type(schema) is list:
schema_generator = genson.Schema()
for schema_example in schema:
schema_generator.add_object(schema_example)
schema = schema_generator.to_dict()
self._schema = schema
def schema(data, typ):
""" Build schema from data
"""
_ = typ
yaml = Td4aYaml()
obj_data = yaml.load(data['p1'])
json_schema = genson.Schema()
json_schema.add_object(obj_data)
schema_dict = json_schema.to_dict()
schema_yaml = yaml.load(yaml.dump(schema_dict))
sorted_schema_yaml = sort_commented_map(commented_map=schema_yaml)
sorted_schema_string = yaml.dump(sorted_schema_yaml)
return sorted_schema_string
def to_schema(fname, *ds):
s = genson.Schema()
s.add_schema({
"type":
"object",
"properties": {},
"title": (lambda fname: fname[:fname.find(".")])(path.basename(fname)),
})
s.schema_uri = "http://json-schema.org/draft-04/schema"
for d in ds:
s.add_object(d)
with open(path.join(schemas_dir, fname.replace(".yml", ".schema.json")),
"wt") as f:
f.write(s.to_json(indent=4))
def convert_to_jsonschema(args):
stream = file(args.json_source)
ymal_data = yaml.load(stream)
logger.info(ymal_data)
s = genson.Schema()
s.add_object(ymal_data)
# indent forces pretty print
json_schema = s.to_json(indent=4, sort_keys=False)
logger.info(json_schema)
with open(args.json_schema_file_path, 'w') as json_schema_file:
json_schema_file.write(json_schema)
def timeline():
t = Twython('92UbSi1YbvPI5umlJVV6xwL62',
'EMM846L8yfj3hP5T14mdxHKDII1rb9AV7whUUjwVy4X4ZTcx0c',
'2257672447-BSkO8JVaFWzrPebefP3bCrY09AAh11Tq1yaX66c',
'BrgI4HvNpqs1tg7u1q0JBYuBH5uePGHW5i1GjRrhZxo8U')
tl = t.get_home_timeline()
json.dumps(tl)
s = genson.Schema()
s.add_object(tl)
tweets = []
for i in range(0, len(tl)):
# pprint(tl[i]['text'])
tweets.append(tl[i]['text'])
tweets_dict = {'tweets': tweets}
return tweets_dict
def _generate_schema_from_example_and_description(input, description):
'''
With an example input, a schema is automatically generated that conforms
to the example in json-schema.org. The description given by the users
is then added to the schema.
'''
s = _genson.Schema()
s.add_object(input)
input_schema = s.to_dict()
if description is not None:
if 'properties' in input_schema:
# Case for input = {'x':1}, input_description='not a dict'
if not isinstance(description, dict):
msg = f'{input} and {description} do not match'
logger.error(msg)
raise Exception(msg)
for key in description:
# Case for input = {'x':1},
# input_description={'x':'x value', 'y':'y value'}
if key not in input_schema['properties']:
msg = f'{key} not found in {input}'
logger.error(msg)
raise Exception(msg)
else:
input_schema['properties'][key][
'description'] = description[key]
else:
if isinstance(description, dict):
raise Exception(f'{input} and {description} do not match')
else:
input_schema['description'] = description
try:
# This should not fail unless there are bugs with either genson or
# jsonschema.
_validate(input, input_schema)
except Exception as e:
logger.error(f'Internal error validating schema: {str(e)}')
raise
return input_schema
def parse_body(self, keep_list_item):
self.decoded_body = util.decode_body(self.headers, self.body)
# noinspection PyBroadException
try:
obj = json.loads(self.decoded_body)
except:
self.simplified_body = self.decoded_body
return
# 简化数据，只保留部分数据
util.simplify(obj, keep_list_item)
self.simplified_body = json.dumps(obj,
ensure_ascii=False,
sort_keys=True,
indent=2)
# 保存数据 Schema 以供比较
self.schema = genson.Schema()
self.schema.add_object(obj)
def generate_models(self, files, generate_schema: bool = False, cmake: bool = False):
loader = JmgLoader()
for file_path in (f for fileGlob in files for f in glob.glob(fileGlob)):
if generate_schema:
#
# Generate the a JSON Schema file from the given JSON file
#
schema = genson.Schema()
with open(file_path) as f:
json_sample = json.load(f)
schema.add_object(json_sample)
schema_base_name = os.path.basename(file_path)
schema_root_name, schema_ext = os.path.splitext(schema_base_name)
schema_file_path = os.path.join(self.outdir, schema_root_name + '.schema' + schema_ext)
with open(schema_file_path, 'w') as s_f:
s_f.write(schema.to_json())
else:
schema_file_path = file_path
if self.root_name:
scope = [self.root_name]
else:
base_name = os.path.basename(schema_file_path)
base_uri = os.path.splitext(base_name)[0]
base_uri = base_uri.replace('.schema', '')
scope = [base_uri]
with open(schema_file_path) as jsonFile:
# root_schema = json.load(jsonFile)
# base_uri = 'file://' + os.path.split(os.path.realpath(f))[0]
base_uri = 'file://' + os.path.realpath(schema_file_path)
root_schema = jsonref.load(jsonFile, base_uri=base_uri, jsonschema=True, loader=loader)
if self.validate:
# TODO: Add exception handling
try:
Draft4Validator.check_schema(root_schema)
except SchemaError as e:
print(e)
assert isinstance(root_schema, dict)
if JsonSchema2Model.SCHEMA_URI not in root_schema:
root_schema[JsonSchema2Model.SCHEMA_URI] = schema_file_path
self.create_model(root_schema, scope)
if not cmake:
self.render_models()
self.copy_static_files()
if self.include_dependencies:
self.copy_dependencies()
else:
self.print_for_cmake()
def infer_schema(json_objects):
s = genson.Schema()
s.add_schema({"type": "object", "properties": {}})
for o in json_objects:
s.add_object(o)
return s.to_dict()
if definitions:
print('The Definition - {}'.format(definitions[0].text.strip()))
else:
print('Definition not found on web:(\n')
# This connects to my twitter account and brings the tweets
t = Twython('92UbSi1YbvPI5umlJVV6xwL62',
'EMM846L8yfj3hP5T14mdxHKDII1rb9AV7whUUjwVy4X4ZTcx0c',
'2257672447-BSkO8JVaFWzrPebefP3bCrY09AAh11Tq1yaX66c',
'BrgI4HvNpqs1tg7u1q0JBYuBH5uePGHW5i1GjRrhZxo8U')
tl = t.get_home_timeline()
json.dumps(tl)
s = genson.Schema()
s.add_object(tl)
tweets = []
def timeline():
for i in range(0, len(tl)):
# pprint(tl[i]['text'])
tweets.append(tl[i]['text'])
tweets_dict = {'tweets': tweets}
return tweets_dict
# This function is to load all the dictionary word and
# this function will return all the words.
def generateJsonObject():
s = genson.Schema()
s.add_schema(generateObject())
return s.to_json()
