def check_if_alias_is_already_taken(name):
print('comparing with KG database [...]')
client = KGClient(token,
nexus_endpoint="https://nexus.humanbrainproject.org/v0")
MODELS = ModelProject.list(client, size=10000)
NAMES = [project.name for project in MODELS]
if name in NAMES:
i0 = int(np.argwhere(np.array(NAMES, dtype=str) == name))
if type(MODELS[i0].authors) is list:
author_list = ''
for nn in list(MODELS[i0].authors):
author_list += nn.resolve(client).full_name + '; '
else:
author_list = MODELS[i0].authors.resolve(client).full_name
print('/!\ --> The alias "%s"' % name,
'is redundant with the following entry:')
print('''
- Description:
%s
- Author(s):
%s
''' % (MODELS[i0].resolve(client).description[:200]+' [...] '+\
MODELS[i0].resolve(client).description[-200:],
author_list))
else:
print('--> The alias "%s"' % name, 'is valid')
def test_list_kgquery(self, kg_client):
models = ModelProject.list(kg_client,
api="query",
scope="latest",
size=10,
resolved=True)
assert len(models) == 10
def test_list_kgquery_with_filter(self, kg_client):
models = ModelProject.list(kg_client,
api="query",
scope="latest",
size=10,
resolved=True,
species="Rattus norvegicus")
assert len(models) == 2
def test_list_nexus_with_filter(self, kg_client):
models = ModelProject.list(kg_client,
api="nexus",
size=10,
species="Rattus norvegicus")
assert len(models) == 6
assert len(name) > 6
bundle = FileBundle(identifier=hashlib.md5(script.code_location.encode('utf-8')).hexdigest(),
name=name,
description=model_instance.description,
url=script.code_location,
#usageNotes,
modelInstance=model_release) # check this is showing in KG editor
print(bundle)
bundle.save(client)
if __name__ == "__main__":
client = KGClient(token, nexus_endpoint="https://nexus.humanbrainproject.org/v0")
projects = ModelProject.list(client, size=10000)
single_cell_projects = [p for p in projects if p.model_of and p.model_of.label == "single cell" and "emodel" not in p.name]
single_cell_no_memodel = [p for p in single_cell_projects if "CA1_pyr" not in p.name and "CA1_int" not in p.name]
#for model_project in ModelProject.list(client, size=10000):
for model_project in single_cell_no_memodel:
#if model_project.model_of and "network" in model_project.model_of.label:
#if model_project.model_of and "single cell" not in model_project.model_of.label:
if True:
contributors = get_uniminds_person_list(model_project.authors, client)
custodians = get_uniminds_person_list(model_project.owners, client)
for model_instance in as_list(model_project.instances):
model_instance = model_instance.resolve(client)
script = model_instance.main_script.resolve(client)
release = create_or_update_model_release(model_project, model_instance, contributors, custodians, script, client)
def load_model_instances(show_ignore=False,
size=100000,
scope='inferred',
verbose=False,
api='nexus'):
client = KGClient(os.environ["HBP_token"])
MODEL_INSTANCES = []
models = ModelProject.list(client,
api=api,
scope=scope,
size=size)
for model in models:
if verbose:
print('\n##########################################')
print('------ %s ------' % model.name)
minst = template.copy()
minst['name'] = model.name
minst['owner'] = get_author_details(model.owners.resolve(client))
if type(model.authors) is list:
minst['author(s)'] = [get_author_details(auth.resolve(client)) for auth in model.authors]
else:
minst['author(s)'] = [get_author_details(model.authors.resolve(client))]
try:
minst['authors_str'] = model.authors_str(client)
except TypeError:
minst['authors_str'] = ''
for a in minst['author(s)']:
minst['authors_str'] += a['family_name']+', '+a['given_name']+';'
minst['description'] = model.description
minst['private'] = model.private
minst['collab_id'] = model.collab_id
minst['alias'] = model.alias
for key, quant in zip(['brain_region', 'species', 'cell_type', 'abstraction_level', 'model_scope'],
[model.brain_region, model.species, model.celltype, model.abstraction_level, model.model_of]):
if quant is not None:
minst[key] = (quant.label, '')
elif verbose:
print('[!!] "%s" missing for %s ' % (key, model.name))
for key, quant in zip(['organization'],
[model.organization]):
if quant is not None:
minst[key] = (quant.resolve(client).name, '')
elif verbose:
print('[!!] "%s" missing for %s ' % (key, model.name))
if type(model.instances) is list:
for modelI in model.instances:
MODEL_INSTANCES.append(minst)
# pprint.pprint(MODEL_INSTANCES[-1])
# print('')
add_version_details_to_model(MODEL_INSTANCES[-1], modelI.resolve(client), client, verbose=verbose)
elif type(model.instances) is KGProxy:
modelI = model.instances
MODEL_INSTANCES.append(minst.copy())
add_version_details_to_model(MODEL_INSTANCES[-1], modelI.resolve(client), client, verbose=verbose)
elif show_ignore:
print('Ignoring %s @ %s' % (model.name, model.date_created))
pass # we don't care about models without specific version
DATES = np.array([time.mktime(minst['date_created'].timetuple()) for minst in MODEL_INSTANCES])
return [MODEL_INSTANCES[i] for i in np.argsort(DATES)[::-1]]
async def query_models(
alias: List[str] = Query(
None,
description="A list of model aliases (short names) to search for"),
id: List[UUID] = Query(
None, description="A list of specific model IDs to search for"),
name: List[str] = Query(None,
description="Model name(s) to search for"),
brain_region: List[BrainRegion] = Query(
None,
description=
"Find models intended to represent this/these brain region(s)"),
species: List[Species] = Query(
None,
description="Find models intended to represent this/these species"
),
cell_type: List[CellType] = Query(
None, description="Find models of this/these cell type(s)"),
model_scope: ModelScope = Query(
None, description="Find models with a certain scope"),
abstraction_level: AbstractionLevel = Query(
None, description="Find models with a certain abstraction level"),
author: List[str] = Query(
None, description="Find models by author (family name)"),
owner: List[str] = Query(
None, description="Find models by owner (family name)"),
organization: List[str] = Query(
None, description="Find models by organization"),
project_id: List[str] = Query(
None,
description="Find models belonging to a specific project/projects"
),
private: bool = Query(
None, description="Limit the search to public or private models"),
summary: bool = Query(
False,
description="Return only summary information about each model"),
size: int = Query(100, description="Maximum number of responses"),
from_index: int = Query(
0, description="Index of the first response returned"),
# from header
token: HTTPAuthorizationCredentials = Depends(auth),
):
"""
Search the model catalog for specific models (identitified by their unique ID or by a short name / alias),
and/or search by attributes of the models (e.g. the cell types being modelled, the type of model, the model author).
"""
# If project_id is provided:
# - private = None: both public and private models from that project (collab), if the user is a member
# - private = True: only private models from that project, if that user is a member
# - private = False: only public models from that project
# If project_id is not provided:
# - private = None: only public models, from all projects
# - private = True: 400? error "To see private models, you must specify the project/collab"
# - private = False: only public models, from all projects
if private:
if project_id:
for collab_id in project_id:
if not await is_collab_member(collab_id, token.credentials):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="You are not a member of project #{collab_id}",
)
else:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=
"To see private models, you must specify the project/collab id",
)
# get the values of of the Enums
if brain_region:
brain_region = [item.value for item in brain_region]
if species:
species = [item.value for item in species]
if cell_type:
cell_type = [item.value for item in cell_type]
if model_scope:
model_scope = model_scope.value
if abstraction_level:
abstraction_level = abstraction_level.value
filter_query, context = build_model_project_filters(
alias,
id,
name,
brain_region,
species,
cell_type,
model_scope,
abstraction_level,
author,
owner,
organization,
project_id,
private,
)
if len(filter_query["value"]) > 0:
logger.info(
"Searching for ModelProject with the following query: {}".format(
filter_query))
# note that from_index is not currently supported by KGQuery.resolve
model_projects = KGQuery(ModelProject, {
"nexus": filter_query
}, context).resolve(kg_client, api="nexus", size=size)
else:
model_projects = ModelProject.list(kg_client,
api="nexus",
size=size,
from_index=from_index)
if summary:
cls = ScientificModelSummary
else:
cls = ScientificModel
return [
cls.from_kg_object(model_project, kg_client)
for model_project in as_list(model_projects)
]
def test_all():
ModelProject.set_strict_mode(False) # check: will this interfere with other tests?
MEModel.set_strict_mode(False)
## Get a list of possible filter terms
for cls in (Species, CellType, BrainRegion, AbstractionLevel, ModelScope):
print("\nPossible values of {}:\n - ".format(cls.__name__))
print("\n - ".join(cls.iri_map.keys()))
## Find models of hippocampus pyramidal neurons
models = ModelProject.list(client,
brain_region="hippocampus",
model_of="single cell",
species="Rattus norvegicus")
len(models)
columns = ("name", "brain_region", "celltype", "authors")
data = []
for model in models:
row = {}
for attr in columns:
value = getattr(model, attr)
if hasattr(value, "label"):
row[attr] = value.label
elif attr == "authors":
row[attr] = ", ".join("{au.given_name} {au.family_name}".format(au=obj.resolve(client))
for obj in as_list(value))
else:
row[attr] = value
data.append(row)
df = pd.DataFrame(data=data, columns=columns) #.sort_values(by=['name'], kind="mergesort")
dfStyler = df.style.set_properties(**{'text-align': 'left'})
dfStyler.set_table_styles([dict(selector='th', props=[('text-align', 'left')])])
# Exploring a single model
# take the last model from the list above, and show its versions
example_model = models[-1]
example_model.instances
# take the last version (not necessarily the most recent)
instance = as_list(example_model.instances)[-1].resolve(client)
instance
instance.timestamp.isoformat()
code = instance.main_script.resolve(client)
code.code_format
code.code_location
morph = instance.morphology.resolve(client)
morph.morphology_file
def print_model_information(index):
model = models[index]
instance = as_list(model.instances)[-1].resolve(client)
code = instance.main_script.resolve(client)
morph = instance.morphology.resolve(client)
print(instance.name, instance.timestamp.isoformat())
print(code.code_location)
print(morph.morphology_file)
print_model_information(99)
# not all models have morphologies, I'm not sure if this is expected or not.
# Here is a list of models with morphologies
for model in models:
for instance in as_list(model.instances):
instance = instance.resolve(client)
morph_file = instance.morphology.resolve(client).morphology_file
if morph_file:
print(instance.name, morph_file)