def json(self, schema, key=None, cls=None, *args, **kwargs):
'''
will validate the returned json using jsonschema
'''
data = self._json_data(key)
if data is None:
print('No data :-(')
sys.exit()
try:
schema_validate(schema, data, *args, **kwargs)
except ValidationError:
print('\n >> Validation Error <<')
print(data)
print('\n Goodbye :-)')
sys.exit()
except SchemaError as e:
print('\n ## You provided a bad schema :-( ##\n')
print(schema,'\n')
print(e)
print('\n Goodbye :-)')
sys.exit()
return self
def get_cohort_counts():
cohort_counts = None
try:
request_data = request.get_json()
schema_validate(request_data, COHORT_FILTER_SCHEMA)
if 'filters' not in request_data:
cohort_counts = {
'message': 'No filters were provided; ensure that the request body contains a \'filters\' property.'
}
else:
cohort_counts = get_sample_case_list_bq(None, request_data['filters'])
if cohort_counts:
for prog in cohort_counts:
if cohort_counts[prog]['case_count'] <= 0:
cohort_counts[prog]['message'] = "No cases or samples found which meet the filter criteria for this program."
cohort_counts[prog]['provided_filters'] = request_data['filters'][prog]
except BadRequest as e:
logger.warn("[WARNING] Received bad request - couldn't load JSON.")
cohort_counts = {
'message': 'The JSON provided in this request appears to be improperly formatted.',
}
except ValidationError as e:
logger.warn('[WARNING] Filters rejected for improper formatting: {}'.format(e))
cohort_counts = {
'message': 'Filters were improperly formatted.'
}
except Exception as e:
logger.exception(e)
return cohort_counts
def post_query(user, cohort_id):
try:
request_data = request.get_json()
if 'fields' not in request_data:
return dict(
message = 'No queryFields provided; ensure that the request body contains a \'queryFields\' component.',
code = 400)
schema_validate(request_data, QUERY_FIELDS)
data = {"request_data": request_data}
query_info = perform_query(request,
func=requests.post,
url="{}/cohorts/api/{}/query/".format(settings.BASE_URL,cohort_id),
data=data,
user=user)
except BadRequest as e:
logger.warning("[WARNING] Received bad request - couldn't load JSON.")
query_info = dict(
message='The JSON provided in this request appears to be improperly formatted.',
code = 400)
except ValidationError as e:
logger.warning('[WARNING] Filters rejected for improper formatting: {}'.format(e))
query_info = dict(
message= 'Filters were improperly formatted.',
code = 400)
return query_info
def validate(object_dict, schema_rel_path):
""" Validate that a dictionary satisfies a json schema
Args:
object_dict: A dictionaray representing some object
schema_rel_path: The path the schema that the object should satisfy
Returns:
None
Raises:
ValidationError.
"""
schema, err = _load_schema(schema_rel_path)
if not err:
# only perform the validation against
# a non-null dictionary
if object_dict:
try:
schema_validate(object_dict, schema)
except ExtValidationError as e:
# provide some context before re-raising exception
raise ExtValidationError(_pp_failures(e, schema))
else:
raise ExtValidationError(err)
def post_query_preview(user):
try:
request_data = request.get_json()
if 'cohort_def' not in request_data:
return dict(
message = 'No cohort_def provided; ensure that the request body contains a \'cohort_dev\' component.',
code = 400)
if 'filters' not in request_data['cohort_def']:
return dict(
message = 'No filters were provided; ensure that the cohort_def contains a \'filterSet\' component.',
code = 400)
if 'queryFields' not in request_data:
return dict(
message = 'No queryFields provided; ensure that the request body contains a \'queryFields\' component.',
code = 400)
schema_validate(request_data, QUERY_PREVIEW_BODY)
if 'name' not in request_data["cohort_def"] or request_data["cohort_def"]['name'] == "":
return dict(
message = 'A name was not provided for this cohort. The cohort was not made.',
code = 400
)
blacklist = re.compile(BLACKLIST_RE, re.UNICODE)
match = blacklist.search(str(request_data["cohort_def"]['name']))
if not match and 'description' in request_data["cohort_def"]:
match = blacklist.search(str(request_data["cohort_def"]['description']))
if match:
return dict(
message = "Your cohort's name or description contains invalid characters; " +
"please edit them and resubmit. [Saw {}]".format(str(match)),
code = 400
)
data = {"request_data": request_data}
query_info = perform_query(request,
func=requests.post,
url="{}/cohorts/api/preview/query/".format(settings.BASE_URL),
data=data,
user=user)
except BadRequest as e:
logger.warning("[WARNING] Received bad request - couldn't load JSON.")
query_info = dict(
message='The JSON provided in this request appears to be improperly formatted.',
code = 400)
except ValidationError as e:
logger.warning('[WARNING] Filters rejected for improper formatting: {}'.format(e))
query_info = dict(
message= 'Filters were improperly formatted.',
code = 400)
return query_info
def from_dict(cls, data):
"""
Throws:
ValidationError if the data object does not match the required schema.
"""
schema_validate(data, cls.SCHEMA)
return cls(data['service_account_blacklist'])
def from_dict(cls, data):
"""
Throws:
ValidationError if the data object does not match the required schema.
"""
schema_validate(data, cls.SCHEMA)
return cls(data['google_org_whitelist'])
def from_dict(value: Dict) -> "MarginParameterConfiguration":
""" Create a verify configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_MARGIN_PARAMETER)
nominal = value.get("nominal")
return MarginParameterConfiguration(nominal)
def from_dict(value: Dict) -> "YieldAnalysisConfiguration":
""" Create a yield analysis configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_YIELD)
num_samples = value["num_samples"]
return YieldAnalysisConfiguration(num_samples)
def from_dict(value: Dict) -> "YieldParameterConfiguration":
""" Create a yield parameter configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_YIELD_PARAMETER)
nominal = value.get("nominal")
variance = value["variance"]
return YieldParameterConfiguration(variance, nominal)
def validate(yml: str) -> bool:
try:
schema_validate(load(yml, Loader=FullLoader),
load(ZOO_JSON_SCHEMA, FullLoader))
except ValidationError as err:
log.info("repos.sync_zoo_yml.validation_error", error=err)
return False
else:
return True
def create_cohort(user):
cohort_info = None
try:
request_data = request.get_json()
if 'filters' not in request_data:
return dict(
message = 'No filters were provided; ensure that the request body contains a \'filters\' property.',
code = 400)
schema_validate(request_data['filters'], COHORT_FILTERS_SCHEMA)
if 'name' not in request_data:
return dict(
message = 'A name was not provided for this cohort. The cohort was not made.',
code = 400
)
blacklist = re.compile(BLACKLIST_RE, re.UNICODE)
match = blacklist.search(str(request_data['name']))
if not match and 'description' in request_data:
match = blacklist.search(str(request_data['description']))
if match:
return dict(
message = "Your cohort's name or description contains invalid characters; " +
"please edit them and resubmit. [Saw {}]".format(str(match)),
code = 400
)
path_params = {'email': user}
try:
auth = get_auth()
data = {"request_data": request_data}
response = requests.post("{}/{}/".format(settings.BASE_URL, 'cohorts/api/save_cohort'),
params=path_params, json=data, headers=auth)
cohort_info = response.json()
except Exception as e:
logger.exception(e)
except BadRequest as e:
logger.warning("[WARNING] Received bad request - couldn't load JSON.")
cohort_info = {
'message': 'The JSON provided in this request appears to be improperly formatted.',
'code': 400
}
except ValidationError as e:
logger.warning("[WARNING] Cohort information rejected for improper formatting: {}".format(e))
cohort_info = {
'message': 'Cohort information was improperly formatted - cohort not created.',
'code': 400
}
return cohort_info
def from_dict(value: Dict) -> "OptimizerParameterConfiguration":
""" Create a optimize parameter configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_OPTIMIZE_PARAMETER)
nominal = value["nominal"]
min_ = value.get("min")
max_ = value.get("max")
return OptimizerParameterConfiguration(nominal, min_, max_)
def get_cohort_preview_manifest(user):
try:
# if 'next_page' in request.args and request.args['next_page'] not in ["", None]:
# data = {"request_data": None}
# else:
if True:
request_data = request.get_json()
if 'filters' not in request_data:
return dict(
message = 'No filters were provided; ensure that the request body contains a \'filters\' property.',
code = 400)
schema_validate(request_data['filters'], COHORT_FILTERS_SCHEMA)
if 'name' not in request_data:
return dict(
message = 'A name was not provided for this cohort. The cohort was not made.',
code = 400
)
blacklist = re.compile(BLACKLIST_RE, re.UNICODE)
match = blacklist.search(str(request_data['name']))
if not match and 'description' in request_data:
match = blacklist.search(str(request_data['description']))
if match:
return dict(
message = "Your cohort's name or description contains invalid characters; " +
"please edit them and resubmit. [Saw {}]".format(str(match)),
code = 400
)
data = {"request_data": request_data}
manifest_info = get_manifest(request,
func=requests.post,
url="{}/cohorts/api/preview/manifest/".format(settings.BASE_URL),
data=data,
user=user)
except BadRequest as e:
logger.warning("[WARNING] Received bad request - couldn't load JSON.")
manifest_info = dict(
message='The JSON provided in this request appears to be improperly formatted.',
code = 400)
except ValidationError as e:
logger.warning('[WARNING] Filters rejected for improper formatting: {}'.format(e))
manifest_info = dict(
message= 'Filters were improperly formatted.',
code = 400)
return manifest_info
def from_dict(cls: Any, data: JsonDict, validate=True) -> Any:
"""Returns a dataclass instance with all nested classes converted from the dict given"""
decoded_data = {}
if validate:
schema_validate(data, cls.json_schema())
for field, field_type in cls.__annotations__.items():
mapped_field = cls.field_mapping().get(field, field)
decoded_data[field] = cls._decode_field(field, field_type,
data.get(mapped_field),
validate)
return cls(**decoded_data)
def create_cohort(user):
cohort_info = None
try:
request_data = request.get_json()
schema_validate(request_data, COHORT_FILTER_SCHEMA)
if 'name' not in request_data:
cohort_info = {
'message': 'A name was not provided for this cohort. The cohort was not made.',
}
return cohort_info
if 'filters' not in request_data:
cohort_info = {
'message': 'Filters were not provided; at least one filter must be provided for a cohort to be valid.' +
' The cohort was not made.',
}
return cohort_info
blacklist = re.compile(BLACKLIST_RE, re.UNICODE)
match = blacklist.search(str(request_data['name']))
if not match and 'desc' in request_data:
match = blacklist.search(str(request_data['desc']))
if match:
cohort_info = {
'message': 'Your cohort\'s name or description contains invalid characters; please edit them and resubmit. ' +
'[Saw {}]'.format(str(match)),
}
else:
result = make_cohort(user, **request_data)
if 'message' in result:
cohort_info = result
else:
cohort_info = get_cohort_info(result['cohort_id'])
except BadRequest as e:
logger.warn("[WARNING] Received bad request - couldn't load JSON.")
cohort_info = {
'message': 'The JSON provided in this request appears to be improperly formatted.',
}
except ValidationError as e:
logger.warn("[WARNING] Cohort information rejected for improper formatting: {}".format(e))
cohort_info = {
'message': 'Cohort information was improperly formatted - cohort not edited.',
}
return cohort_info
def test_detector(user_client, rf):
# Put an entry in the schedule that we can refer to
rjson = post_schedule(user_client, TEST_SCHEDULE_ENTRY)
entry_name = rjson['name']
task_id = rjson['next_task_id']
# use mock_acquire set up in conftest.py
by_name['mock_acquire'](entry_name, task_id)
acquistion = Acquisition.objects.get(task_id=task_id)
sigmf_metadata = acquistion.sigmf_metadata
assert sigmf_validate(sigmf_metadata)
schema_validate(sigmf_metadata, schema)
def from_dict(value: Dict) -> "MarginAnalysisConfiguration":
""" Create a marginal analysis configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_MARGIN)
max_search = value.get("max_search", 1.9)
min_search = value.get("min_search", 0.1)
scan_steps = value.get("scan_steps", 4)
binary_search_steps = value.get("binary_search_steps", 3)
return MarginAnalysisConfiguration(max_search, min_search, scan_steps,
binary_search_steps)
def from_dict(value: Dict) -> "VerifyConfiguration":
""" Create a verify configuration from a dict """
schema_validate(instance=value, schema=SCHEMA_VERIFY)
method = value["method"]
file_path = value["file"]
circuit_path = value["circuit"]
threshold = value.get("threshold", 0.05)
wrspice_compatiblity = value.get("wrspice_compatibility", False)
return VerifyConfiguration(method, file_path, circuit_path, threshold,
wrspice_compatiblity)
def from_dict(cls, param):
"""
Throws:
ValidationError if the data object does not match the required schema.
"""
schema_validate(param, cls.SCHEMA)
supported_genomic_builds = param['supported_genomic_builds']
data_table_list = [
GNABTableConfig.from_dict(item) for item in param['tables']
]
return cls(supported_genomic_builds, data_table_list)
def edit_cohort(cohort_id, user, delete=False):
match = None
try:
if delete:
cohort = Cohort.objects.get(id=cohort_id)
cohort.active = False
cohort.save()
cohort_info = {
'notes': 'Cohort {} (\'{}\') has been deleted.'.format(cohort_id, cohort.name),
'data': {'filters': cohort.get_current_filters(unformatted=True)},
}
else:
request_data = request.get_json()
if len(request_data.keys()):
schema_validate(request_data, COHORT_FILTER_SCHEMA)
if 'name' in request_data:
blacklist = re.compile(BLACKLIST_RE, re.UNICODE)
match = blacklist.search(str(request_data['name']))
if match:
cohort_info = {
'message': 'Your cohort\'s name or description contains invalid characters; please edit them and resubmit. ' +
'[Saw {}]'.format(str(match)),
}
else:
result = make_cohort(user, source_id=cohort_id, **request_data)
if 'message' in result:
cohort_info = result
else:
cohort_info = get_cohort_info(result['cohort_id'])
except BadRequest as e:
logger.warn("[WARNING] Received bad request - couldn't load JSON.")
cohort_info = {
'message': 'The JSON provided in this request appears to be improperly formatted.',
}
except ObjectDoesNotExist as e:
logger.error("[ERROR] During {} for cohort ID {}:".format(request.method,str(cohort_id)))
logger.error("Couldn't find a cohort with that ID!")
except ValidationError as e:
logger.warn("[WARNING] Cohort information rejected for improper formatting: {}".format(e))
cohort_info = {
'message': 'Cohort information was improperly formatted - cohort not edited.',
}
return cohort_info
def from_dict(cls, value: Dict) -> "OptimizeConfiguration":
""" Create a optimize configuration """
schema_validate(value, SCHEMA_OPTIMIZE)
method: str = value["method"]
search_radius: float = value.get("search_radius", 0.05)
converge: float = value.get("converge", 0.01)
max_iterations: float = value.get("max_iterations", 1000)
output: Optional[str] = value.get("output", None)
return cls(method, search_radius, converge, max_iterations, output)
def wrapper(*args, **kwargs):
instance = args[0]
if isinstance(self.schema_or_schema_parameter_name, str):
schema = getattr(instance,
self.schema_or_schema_parameter_name)
else:
schema = self.schema_or_schema_parameter_name
try:
schema_validate(self.object(), schema)
return f(*args, **kwargs)
except ValidationError as e:
raise ValidationException(e.message, e.instance)
def _check_basic(self, key, schema, identifier):
""" Verify schema and no data duplicated
"""
issues = []
ids = set()
for d in self.data:
data = d.get(key, {})
try:
schema_validate({key: data}, yaml.load(schema))
except Exception, e:
issues.append(e.message)
duplicated = set(data.keys()) & ids
if duplicated:
issues.append("%s IDs [%s,] are duplicated" %
(identifier, ",".join(duplicated)))
ids.update(set(data.keys()))
def to_dict(self,
omit_none: bool = True,
validate: bool = False) -> JsonDict:
"""Converts the dataclass instance to a JSON encodable dict, with optional JSON schema validation.
If omit_none (default True) is specified, any items with value None are removed
"""
data = {}
for f in fields(self):
value = self._encode_field(getattr(self, f.name), omit_none)
if omit_none and value is None:
continue
data[self.field_mapping().get(f.name, f.name)] = value
if validate:
schema_validate(data, self.json_schema())
return data
def test_cose_schema(config_env: Dict):
if EXPECTED_SCHEMA_VALIDATION not in config_env[EXPECTED_RESULTS].keys():
skip(f'Test not requested: {EXPECTED_SCHEMA_VALIDATION}')
if COSE not in config_env.keys():
skip(f'Test dataset does not contain {COSE}')
if config_env[EXPECTED_RESULTS][EXPECTED_SCHEMA_VALIDATION]:
dgc = _dgc(config_env)
cose_payload = loads(dgc.payload)
assert PAYLOAD_HCERT in cose_payload.keys()
assert len(cose_payload[PAYLOAD_HCERT]) == 1
assert 1 in cose_payload[PAYLOAD_HCERT].keys()
hcert = cose_payload[PAYLOAD_HCERT][1]
schema_validate(hcert, _get_hcert_schema())
assert len(
set(hcert.keys()) & {'v', 'r', 't'}
) == 1, 'DGC adheres to schema but contains multiple certificates'
def _check_basic(self, key, schema, identifier):
""" Verify schema and no data duplicated
"""
issues = []
ids = set()
for d in self.data:
data = d.get(key, {})
try:
schema_validate({key: data},
yaml.load(schema))
except Exception as e:
issues.append(e.message)
duplicated = set(data.keys()) & ids
if duplicated:
issues.append("%s IDs [%s,] are duplicated" % (
identifier, ",".join(duplicated)))
ids.update(set(data.keys()))
return ids, issues
def validate(path=None, fail_first=False, no_warnings=False):
"""
Main validator routine
Iterate over all JSON files, check that they can be loaded, and then run jsonschema.
Handle fail fast option both during loading and validating.
"""
# get the absolute expanded path and always use this
path = os.path.abspath(os.path.expanduser(path))
errors = list()
to_check = _get_json_files(path)
schemata = _get_schemata(path)
ok = 0
for json_file in sorted(to_check):
schema_name, schema = _get_correct_schema(json_file, schemata)
with open(json_file, "r", encoding="utf-8") as f:
try:
data = json.load(f)
except Exception as err:
errors.append((err, json_file, True))
if fail_first:
break
continue
try:
schema_validate(instance=data, schema=schema)
_custom_validate(json_file, data, path)
except (ValidationError, OSError) as err:
errors.append((err, json_file, False))
if fail_first:
break
continue
ok += 1
_print_errors(errors)
msg = "\nAll done. {} errors found".format(len(errors))
if len(to_check) > 1:
msg += ". {} files OK.\n".format(ok)
else:
msg += " in {}".format(to_check[0])
print(msg)
if len(errors):
sys.exit(1)
else:
sys.exit(0)
def test_cose_schema(config_env: Dict):
if CONFIG_ERROR in config_env.keys():
fail(f'Config Error: {config_env[CONFIG_ERROR]}')
if EXPECTED_SCHEMA_VALIDATION not in config_env[EXPECTED_RESULTS].keys():
skip(f'Test not requested: {EXPECTED_SCHEMA_VALIDATION}')
if COSE not in config_env.keys():
skip(f'Test dataset does not contain {COSE}')
if config_env[EXPECTED_RESULTS][EXPECTED_SCHEMA_VALIDATION]:
dgc = _dgc(config_env)
cose_payload = loads(dgc.payload, object_hook=_object_hook_e)
assert PAYLOAD_HCERT in cose_payload.keys()
assert len(cose_payload[PAYLOAD_HCERT]) == 1
assert 1 in cose_payload[PAYLOAD_HCERT].keys()
hcert = cose_payload[PAYLOAD_HCERT][1]
schema_validate(hcert, _get_hcert_schema())
# assert len(set(hcert.keys()) & {'v', 'r', 't'}) == 1,
# 'DGC adheres to schema but contains multiple certificates'
assert len([key for key in hcert.keys() if key in ['v', 'r', 't']]) == 1, \
'DGC adheres to schema but contains multiple certificates'
def validate(path=None, fail_first=False, no_warnings=False):
"""
Main validator routine
Iterate over all JSON files, check that they can be loaded, and then run jsonschema.
Handle fail fast option both during loading and validating.
"""
errors = list()
to_check = _get_json_files(path)
schemata = _get_schemata()
ok = 0
for json_file in sorted(to_check):
schema = _get_correct_schema(json_file, schemata)
with open(json_file, "r") as f:
try:
data = json.load(f)
except json.JSONDecodeError as err:
errors.append((err, json_file, True))
if fail_first:
break
continue
try:
schema_validate(instance=data, schema=schema)
except ValidationError as err:
errors.append((err, json_file, False))
if fail_first:
break
continue
ok += 1
_print_errors(errors)
msg = "\nAll done. {} errors found".format(len(errors))
if len(to_check) > 1:
msg += ". {} files OK.\n".format(ok)
else:
msg += " in {}".format(to_check[0])
print(msg)
def validate(data, schema):
schema_validate(
instance=data,
schema=schema,
format_checker=draft7_format_checker,
)
def schema_validate(cls, obj, json_schema):
schema_validate(obj, json_schema, format_checker=cls._json_format_checker)
def validate(model_name, instance):
base_url = os.path.abspath('resources') + '/schemas/'
resolver = RefResolver('file://{base_url}'.format(base_url=base_url), None)
schema = load_schema(model_name)
schema_validate(instance=instance, schema=schema, resolver=resolver)
def compilespec( spec_file ) :
#---
spec_dir = os.path.dirname( spec_file )
meta_dir = os.path.join( spec_dir, 'meta' )
preview_dir = os.path.join( spec_dir, 'preview' )
html_file = os.path.join( preview_dir, os.path.basename( spec_file ).replace( '.md', '.html' ) )
#---
spec_time = os.path.getmtime(spec_file)
try :
html_time = os.path.getmtime(html_file)
except OSError:
spec_time = 1
html_time = 0
if spec_time < html_time :
print( "- Skipping " + spec_file + "\n" )
return
#---
input_file = codecs.open( spec_file, mode="r", encoding="utf-8" )
#---
text = []
json_text = []
parsing_iface = False
parsing_schema = False
schema_re = re.compile( '^`Schema\\(([a-z0-9\-_]+)\\){`$' )
curr_line = 1
in_header = True
spec_ver = ''
end_of_spec_seen = False
for l in input_file:
try:
if in_header :
pair = l.split( ':', 2 )
if len( pair ) == 2 :
tag, value = pair
value = value.strip()
if tag == 'Version' :
spec_ver = value.replace('DV','')
elif tag in ('Copyright','Authors','Date') :
pass
elif re.match( 'FTN[0-9]+', l ) :
pass
else :
die(str(curr_line) + " Unknown header field")
if l == '\n' :
in_header = False
if not spec_ver :
die( str(curr_line) + " Missing spec Version" )
#---
if end_of_spec_seen and l != '\n':
die( str(curr_line) + " Text after end of spec" )
#---
m = schema_re.match( l )
if m is not None:
if parsing_iface or parsing_schema :
print( "Current Schema: " + str( parsing_schema ) + "\n" )
die( str(curr_line) + ': Unable to parse Schema in scope of another Schema or Iface\n' )
parsing_schema = m.group(1)
text.append('<p class="futoin-schema">Schema: ' + parsing_schema + '</p>\n')
elif l == '`}Schema`\n' :
schema_obj = json.loads(
''.join( json_text ),
object_pairs_hook = lambda pairs: collections.OrderedDict( pairs )
)
Draft4Validator.check_schema(schema_obj)
schema = json.dumps(schema_obj, indent=2, separators=(',', ': ') )
schema_file = os.path.join( meta_dir, parsing_schema + '-' + spec_ver + '-schema.json' )
with codecs.open( schema_file,
"w",
encoding="utf-8",
errors="xmlcharrefreplace"
) as f:
f.write( schema )
# mjr ver
spec_major_ver = spec_ver.split('.')
spec_major_ver = spec_major_ver[0]
schema_mjr_file = os.path.join( meta_dir, parsing_schema + '-' + spec_major_ver + '-schema.json' )
try:
os.unlink( schema_mjr_file )
except OSError:
pass
os.symlink( os.path.basename( schema_file ), schema_mjr_file )
# no ver
schema_file_nover = os.path.join( meta_dir, parsing_schema + '-schema.json' )
try:
os.unlink( schema_file_nover )
except OSError:
pass
os.symlink( os.path.basename( schema_mjr_file ), schema_file_nover )
parsing_schema = False
json_text = []
elif l == '`Iface{`\n' :
if parsing_iface or parsing_schema :
die( str(curr_line) + ': Unable to parse Iface in scope of Schema or another Iface\n' )
parsing_iface = True
elif l == '`}Iface`\n' :
if not parsing_iface:
die( str(curr_line) + ': Unexpected end of Iface' )
iface = json.loads(
''.join( json_text ),
object_pairs_hook = lambda pairs: collections.OrderedDict( pairs )
)
iface_name = iface['iface']
iface["version"] = spec_ver
if 'imports' in iface:
iface['imports'] = [ v.replace('{ver}', spec_ver) for v in iface['imports'] ]
if 'inherit' in iface:
iface['inherit'] = iface['inherit'].replace('{ver}', spec_ver)
# validate schema
schema_file = os.path.join(meta_dir, 'futoin-interface-' + iface['ftn3rev'] + '-schema.json')
with open(schema_file, 'r') as sf:
schema = json.load(sf)
schema_validate(iface, schema)
# version file
iface_ver_file = os.path.join( meta_dir, iface_name + '-' + iface['version'] + '-iface.json' )
with codecs.open( iface_ver_file,
"w",
encoding="utf-8",
errors="xmlcharrefreplace"
) as f:
f.write( json.dumps( iface, indent=2, separators=(',', ': ') ) )
# mjr symlink
iface_major_ver = iface['version'].split('.')
iface_major_ver = iface_major_ver[0]
iface_mjr_file = os.path.join( meta_dir, iface_name + '-' + iface_major_ver + '-iface.json' )
try:
os.unlink( iface_mjr_file )
except OSError:
pass
os.symlink( os.path.basename( iface_ver_file ), iface_mjr_file )
# no ver symlink
iface_file_nover = os.path.join( meta_dir, iface_name + '-iface.json' )
try:
os.unlink( iface_file_nover )
except OSError:
pass
os.symlink( os.path.basename( iface_mjr_file ), iface_file_nover )
parsing_iface = False
json_text = []
else :
if l == '=END OF SPEC=\n' :
end_of_spec_seen = True
if parsing_iface or parsing_schema :
json_text.append( l )
l = l.replace( '.md', '.html' )
text.append( l )
curr_line += 1
except Exception as e :
if len( json_text ) :
i = 1
for jl in json_text :
sys.stderr.write( "%s: %s" % ( i, jl ) )
i += 1
die( "At line %s: Exception: %s\n" % ( curr_line, e ) )
#---
if not end_of_spec_seen:
die( "Missing '=END OF SPEC='" )
#---
html_ver_file = html_file.replace( '.html', '-' + spec_ver + '.html' )
spec_major_ver = spec_ver.split('.')
spec_major_ver = spec_major_ver[0]
html_mjrver_file = html_file.replace( '.html', '-' + spec_major_ver + '.html' )
if False :
raw_file = codecs.open( html_file + '.raw', "w",
encoding="utf-8",
errors="xmlcharrefreplace"
)
raw_file.write( ''.join( text ) )
raw_file.close()
output_file = codecs.open( html_ver_file, "w",
encoding="utf-8",
errors="xmlcharrefreplace"
)
# mjr.mnr symlink
try :
os.unlink( html_mjrver_file )
except OSError:
pass
os.symlink( os.path.basename( html_ver_file ), html_mjrver_file )
# mjr symlink
try :
os.unlink( html_file )
except OSError:
pass
os.symlink( os.path.basename( html_mjrver_file ), html_file )
# update html
output_file.write( '<!DOCTYPE html>\n' )
output_file.write( '<html>\n<head>\n' )
output_file.write( '<title>' + os.path.basename( spec_file ) + '</title>\n' )
output_file.write( '<link rel="stylesheet" type="text/css" href="../../css/specs.css">\n' )
output_file.write( '</head><body>\n' )
output_file.write( markdown.markdown( ''.join( text ), output_format='html5' ) )
output_file.write( '\n</body></html>' )
output_file.close()
input_file.close()
#---
print( "Compiled " + spec_file + "\n" )
