def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
assert 'Person' in model.to_dict(), model.to_dict()
assert 'Thing' in model.to_dict(), model.to_dict()
def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
assert 'Person' in model.to_dict(), model.to_dict()
assert 'Thing' in model.to_dict(), model.to_dict()
props = list(model.properties)
assert len(props), props
assert thing.get('name') in props, props
def _metadata_locale(locale):
# This is cached in part because latency on this endpoint is
# particularly relevant to the first render being shown to a
# user.
auth = {}
if settings.PASSWORD_LOGIN:
auth["password_login_uri"] = url_for("sessions_api.password_login")
auth["registration_uri"] = url_for("roles_api.create_code")
if settings.OAUTH:
auth["oauth_uri"] = url_for("sessions_api.oauth_init")
locales = settings.UI_LANGUAGES
locales = {loc: Locale(loc).get_language_name(loc) for loc in locales}
return {
"status": "ok",
"maintenance": request.authz.in_maintenance,
"app": {
"title": settings.APP_TITLE,
"version": __version__,
"banner": settings.APP_BANNER,
"ui_uri": settings.APP_UI_URL,
"logo": settings.APP_LOGO,
"favicon": settings.APP_FAVICON,
"locale": locale,
"locales": locales,
},
"categories": Collection.CATEGORIES,
"frequencies": Collection.FREQUENCIES,
"pages": load_pages(locale),
"model": model.to_dict(),
"token": None,
"auth": auth,
}
def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
assert 'Person' in model.to_dict(), model.to_dict()
assert 'Thing' in model.to_dict(), model.to_dict()
with assert_raises(KeyError):
model['Banana']
assert model.get_qname('Thing:name') == thing.get('name')
props = list(model.properties)
assert len(props), props
assert thing.get('name') in props, props
def export_metadata():
"""Export the global index for all datasets."""
datasets = []
for dataset in Dataset.all():
datasets.append(dataset_to_index(dataset))
with engine_read() as conn:
issues = list(all_issues(conn))
schemata = all_schemata(conn)
issues_path = settings.DATASET_PATH.joinpath("issues.json")
log.info("Writing global issues list", path=issues_path)
with open(issues_path, "wb") as fh:
data = {"issues": issues}
write_json(data, fh)
index_path = settings.DATASET_PATH.joinpath("index.json")
log.info("Writing global index", datasets=len(datasets), path=index_path)
with open(index_path, "wb") as fh:
meta = {
"datasets": datasets,
"run_time": settings.RUN_TIME,
"dataset_url": settings.DATASET_URL,
"issues_url": urljoin(settings.DATASET_URL, "issues.json"),
"statements_url": urljoin(settings.DATASET_URL, "statements.csv"),
"model": model.to_dict(),
"schemata": schemata,
"matcher": explain_matcher(),
"app": "opensanctions",
"version": settings.VERSION,
}
write_json(meta, fh)
async def index():
"""Get system information: the list of available dataset names, the size of
the search index in memory, and the followthemoney model specification which
describes the types of entities and properties in use by the API."""
try:
index = get_index()
return {
"datasets": [ds.name for ds in get_datasets()],
"model": model.to_dict(),
"terms": len(index.terms),
"tokens": len(index.inverted),
}
finally:
db.session.close()
def _metadata_locale(locale):
# This is cached in part because latency on this endpoint is
# particularly relevant to the first render being shown to a
# user.
auth = {"logout": settings.APP_UI_URL}
if settings.PASSWORD_LOGIN:
auth["password_login_uri"] = url_for("sessions_api.password_login")
if settings.PASSWORD_LOGIN and not settings.MAINTENANCE:
auth["registration_uri"] = url_for("roles_api.create_code")
if settings.OAUTH:
auth["oauth_uri"] = url_for("sessions_api.oauth_init")
metadata = oauth.provider.load_server_metadata()
auth["logout"] = metadata.get("end_session_endpoint", auth["logout"])
locales = settings.UI_LANGUAGES
locales = {loc: Locale(loc).get_language_name(loc) for loc in locales}
# This is dumb but we agreed it with ARIJ
# https://github.com/alephdata/aleph/issues/1432
app_logo = settings.APP_LOGO
if locale.startswith("ar"):
app_logo = settings.APP_LOGO_AR or app_logo
return {
"status": "ok",
"maintenance": settings.MAINTENANCE,
"app": {
"title": settings.APP_TITLE,
"version": __version__,
"banner": settings.APP_BANNER,
"ui_uri": settings.APP_UI_URL,
"logo": app_logo,
"favicon": settings.APP_FAVICON,
"locale": locale,
"locales": locales,
},
"categories": Collection.CATEGORIES,
"frequencies": Collection.FREQUENCIES,
"pages": load_pages(locale),
"model": model.to_dict(),
"token": None,
"auth": auth,
}
def _metadata_locale(locale):
# This is cached in part because latency on this endpoint is
# particularly relevant to the first render being shown to a
# user.
auth = {}
if settings.PASSWORD_LOGIN:
auth['password_login_uri'] = url_for('sessions_api.password_login')
auth['registration_uri'] = url_for('roles_api.create_code')
if settings.OAUTH:
auth['oauth_uri'] = url_for('sessions_api.oauth_init')
locales = settings.UI_LANGUAGES
locales = {l: Locale(l).get_language_name(l) for l in locales}
data = {
'status': 'ok',
'maintenance': request.authz.in_maintenance,
'app': {
'title': settings.APP_TITLE,
'description': settings.APP_DESCRIPTION,
'version': __version__,
'banner': settings.APP_BANNER,
'ui_uri': settings.APP_UI_URL,
'samples': settings.SAMPLE_SEARCHES,
'logo': settings.APP_LOGO,
'favicon': settings.APP_FAVICON,
'locale': locale,
'locales': locales
},
'categories': Collection.CATEGORIES,
'frequencies': Collection.FREQUENCIES,
'pages': load_pages(locale),
'model': model.to_dict(),
'token': None,
'auth': auth
}
if settings.SINGLE_USER:
role = Role.load_cli_user()
authz = Authz.from_role(role)
data['token'] = authz.to_token(role=role)
return jsonify(data)
def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
data = model.to_dict()
assert 'schemata' in data, data
assert len(data['schemata']) == len(model.schemata)
assert 'Thing' in data['schemata']
assert 'types' in data, data
assert len(data['types']) == len(list(registry.types))
assert 'name' in data['types']
assert 'entity' in data['types']
with assert_raises(KeyError):
model['Banana']
assert model.get_qname('Thing:name') == thing.get('name')
props = list(model.properties)
assert len(props), props
assert thing.get('name') in props, props
def test_model_basics(self):
assert model.schemata["Thing"], model.schemata
thing = model.schemata["Thing"]
assert thing == model.get(thing)
assert thing in list(model), list(model)
data = model.to_dict()
assert "schemata" in data, data
assert len(data["schemata"]) == len(model.schemata)
assert "Thing" in data["schemata"]
assert "types" in data, data
assert len(data["types"]) == len(list(registry.types))
assert "name" in data["types"]
assert "entity" in data["types"]
with assert_raises(KeyError):
model["Banana"]
assert model.get_qname("Thing:name") == thing.get("name")
props = list(model.properties)
assert len(props), props
assert thing.get("name") in props, props
def dump_model(outfile):
outfile.write(json.dumps(model.to_dict(), indent=2))
def dump_model(outfile):
outfile.write(json.dumps(model.to_dict(), indent=2, sort_keys=True))
def dump_model(outfile: TextIO) -> None:
outfile.write(json.dumps(model.to_dict(), indent=2, sort_keys=True))
