diff --git a/.gitignore b/.gitignore index 4c71bd97..ff2945d5 100644 --- a/.gitignore +++ b/.gitignore @@ -16,6 +16,9 @@ software/ SOURCES.txt *.svg *.DS_Store +nexus_temp/ +.tmp/ +figures/ *~ *.pyc @@ -136,6 +139,7 @@ celerybeat-schedule venv/ ENV/ myvenv/ +myvenv_cli/ # Spyder project settings .spyderproject diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml deleted file mode 100644 index 62d99630..00000000 --- a/.gitlab-ci.yml +++ /dev/null @@ -1,31 +0,0 @@ -include: - - project: cells/ci - file: /ci/lib/common.yml - -workflow: - # run for the default branch and all types of merge request pipelines, but not for tags - rules: - - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH - - if: $CI_EXTERNAL_PULL_REQUEST_IID - -tests: - stage: test - tags: - - bb5_map - variables: - PIP_PACKAGES: tox - before_script: - - !reference [.define-functions] - - !reference [.bb5, clean-env] - - !reference [.bb5, load-python-39] - - !reference [.bb5, load-python-310] - - !reference [.bb5, load-extra-modules] - - !reference [.run-pre-build-command] - - !reference [.setup-venv] - - !reference [.gitlab-access] - script: - - pip install $PIP_PACKAGES - - pip install . # Install the package itself - - git clone git@bbpgitlab.epfl.ch:cells/bluepyemodelnexus.git - - cd bluepyemodelnexus - - tox -e lint diff --git a/COPYING b/COPYING index 5e3f3b9c..0e350035 100644 --- a/COPYING +++ b/COPYING @@ -187,7 +187,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2023 Blue Brain Project / EPFL + Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/LICENSE.txt b/LICENSE.txt index d6e5570f..e48245e9 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -4,7 +4,7 @@ The examples are under the CC-BY-NC-SA license, as specified by the LICENSE.txt file. -Copyright 2023 Blue Brain Project / EPFL +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/README.rst b/README.rst index 049ceaf6..168ed332 100644 --- a/README.rst +++ b/README.rst @@ -56,6 +56,7 @@ BluePyEModel can be pip installed with the following command: If you do not wish to install all dependencies, specific dependencies can be selected by indicating which ones to install between brackets in place of 'all' (If you want multiple dependencies, they have to be separated by commas). The available dependencies are: * luigi +* nexus * all To get started with the E-Model building pipeline @@ -75,7 +76,7 @@ The pipeline is divided in 6 steps: * ``plotting``: reads the models and runs the optimisation protocols and/or validation protocols on them. Then, plots the resulting traces along the e-feature scores and parameter distributions. * ``exporting``: read the parameter of the best models and export them in files that can be used either in NEURON or for circuit building. -These six steps are to be run in order as for example validation cannot be run if no models have been stored. Steps "validation", "plotting" and "exporting" are optional. Step "extraction" can also be optional in the case where the file containing the protocols and optimisation targets is created by hand or if it is obtained from an older project. +These six steps are to be run in order as for example validation cannot be run if no models have been stored. Steps ``validation``, ``plotting`` and ``exporting`` are optional. Step ``extraction`` can also be optional in the case where the file containing the protocols and optimisation targets is created by hand or if it is obtained from an older project. Schematics of BluePyEModel classes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -91,7 +92,7 @@ This work was supported by funding to the Blue Brain Project, a research center Copyright ~~~~~~~~~ -Copyright (c) 2023 Blue Brain Project/EPFL +Copyright (c) 2023-2024 Blue Brain Project/EPFL This work is licensed under `Apache 2.0 `_ diff --git a/bluepyemodel/__init__.py b/bluepyemodel/__init__.py index 1a678938..f5db67a6 100644 --- a/bluepyemodel/__init__.py +++ b/bluepyemodel/__init__.py @@ -1,7 +1,7 @@ """Main module of BluePyEModel.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/access_point/__init__.py b/bluepyemodel/access_point/__init__.py index c5a92039..44f16802 100644 --- a/bluepyemodel/access_point/__init__.py +++ b/bluepyemodel/access_point/__init__.py @@ -1,7 +1,7 @@ """E-model access_point module""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -70,12 +70,10 @@ def get_access_point(access_point, emodel, **kwargs): brain_region = brain_region.replace("__", " ") if brain_region else None if access_point == "nexus": - try: - from bluepyemodelnexus.nexus import NexusAccessPoint - except ImportError as exc: - raise ImportError( - "The internal bluepyemodelnexus package is required to use the Nexus access point." - ) from exc + from bluepyemodel.access_point.nexus import NexusAccessPoint + + if not kwargs.get("project"): + raise ValueError("Nexus project name is required for Nexus access point.") return NexusAccessPoint( emodel=emodel, @@ -88,7 +86,7 @@ def get_access_point(access_point, emodel, **kwargs): synapse_class=kwargs.get("synapse_class", None), project=kwargs.get("project", None), organisation=kwargs.get("organisation", "bbp"), - endpoint=kwargs.get("endpoint", "https://bbp.epfl.ch/nexus/v1"), + endpoint=kwargs.get("endpoint", "https://staging.nexus.ocp.bbp.epfl.ch/v1"), forge_path=kwargs.get("forge_path", None), forge_ontology_path=kwargs.get("forge_ontology_path", None), access_token=kwargs.get("access_token", None), diff --git a/bluepyemodel/access_point/access_point.py b/bluepyemodel/access_point/access_point.py index 554b816f..1c879138 100644 --- a/bluepyemodel/access_point/access_point.py +++ b/bluepyemodel/access_point/access_point.py @@ -1,7 +1,7 @@ """DataAccessPoint class.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/access_point/forge_access_point.py b/bluepyemodel/access_point/forge_access_point.py new file mode 100644 index 00000000..68a65c90 --- /dev/null +++ b/bluepyemodel/access_point/forge_access_point.py @@ -0,0 +1,1174 @@ +"""NexusForgeAccessPoint class.""" + +import getpass +import json +import logging +import pathlib +from datetime import datetime +from datetime import timedelta +from datetime import timezone + +import jwt +from entity_management.state import refresh_token +from kgforge.core import KnowledgeGraphForge +from kgforge.core import Resource +from kgforge.core.commons.strategies import ResolvingStrategy +from kgforge.specializations.resources import Dataset + +from bluepyemodel.efeatures_extraction.targets_configuration import TargetsConfiguration +from bluepyemodel.emodel_pipeline.emodel import EModel +from bluepyemodel.emodel_pipeline.emodel_script import EModelScript +from bluepyemodel.emodel_pipeline.emodel_settings import EModelPipelineSettings +from bluepyemodel.emodel_pipeline.emodel_workflow import EModelWorkflow +from bluepyemodel.emodel_pipeline.memodel import MEModel +from bluepyemodel.evaluation.fitness_calculator_configuration import FitnessCalculatorConfiguration +from bluepyemodel.model.distribution_configuration import DistributionConfiguration +from bluepyemodel.model.neuron_model_configuration import NeuronModelConfiguration +from bluepyemodel.tools.utils import yesno + +logger = logging.getLogger("__main__") + + +# pylint: disable=bare-except,consider-iterating-dictionary + +CLASS_TO_NEXUS_TYPE = { + "TargetsConfiguration": "ExtractionTargetsConfiguration", + "EModelPipelineSettings": "EModelPipelineSettings", + "FitnessCalculatorConfiguration": "FitnessCalculatorConfiguration", + "NeuronModelConfiguration": "EModelConfiguration", + "EModel": "EModel", + "DistributionConfiguration": "EModelChannelDistribution", + "EModelWorkflow": "EModelWorkflow", + "EModelScript": "EModelScript", + "MEModel": "MEModel", +} + +CLASS_TO_RESOURCE_NAME = { + "TargetsConfiguration": "ETC", + "EModelPipelineSettings": "EMPS", + "FitnessCalculatorConfiguration": "FCC", + "NeuronModelConfiguration": "EMC", + "EModel": "EM", + "DistributionConfiguration": "EMCD", + "EModelWorkflow": "EMW", + "EModelScript": "EMS", + "MEModel": "MEM", +} + +NEXUS_TYPE_TO_CLASS = { + "ExtractionTargetsConfiguration": TargetsConfiguration, + "EModelPipelineSettings": EModelPipelineSettings, + "FitnessCalculatorConfiguration": FitnessCalculatorConfiguration, + "EModelConfiguration": NeuronModelConfiguration, + "EModel": EModel, + "EModelChannelDistribution": DistributionConfiguration, + "EModelWorkflow": EModelWorkflow, + "EModelScript": EModelScript, + "MEModel": MEModel, +} + +NEXUS_ENTRIES = [ + "objectOfStudy", + "contribution", + "type", + "id", + "distribution", + "@type", + "annotation", + "name", +] + +NEXUS_PROJECTS_TRACES = [ + {"project": "lnmce", "organisation": "bbp"}, + {"project": "thalamus", "organisation": "public"}, + {"project": "mmb-point-neuron-framework-model", "organisation": "bbp"}, +] + + +class AccessPointException(Exception): + """For Exceptions related to the NexusForgeAccessPoint""" + + +class NexusForgeAccessPoint: + """Access point to Nexus Knowledge Graph using Nexus Forge""" + + forges = {} + + def __init__( + self, + project="emodel_pipeline", + organisation="demo", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + limit=5000, + debug=False, + cross_bucket=True, + access_token=None, + search_endpoint="sparql", + ): + self.limit = limit + self.debug = debug + self.cross_bucket = cross_bucket + self.search_endpoint = search_endpoint + + self.endpoint = endpoint + self.bucket = organisation + "/" + project + self.forge_path = forge_path + + # reuse token to avoid redundant user prompts + self.access_token = access_token + + if not self.access_token: + self.access_token = self.get_access_token() + decoded_token = jwt.decode(self.access_token, options={"verify_signature": False}) + self.agent = self.forge.reshape( + self.forge.from_json(decoded_token), + keep=["name", "email", "sub", "preferred_username"], + ) + username = decoded_token["preferred_username"] + self.agent.id = f"https://bbp.epfl.ch/nexus/v1/realms/bbp/users/{username}" + self.agent.type = ["Person", "Agent"] + + self._available_etypes = None + self._available_mtypes = None + self._available_ttypes = None + self._atlas_release = None + + def refresh_token(self, offset=300): + """refresh token if token is expired or will be soon. Returns new expiring time. + + Args: + offset (int): offset to apply to the expiring time in s. + """ + # Check if the access token has expired + decoded_token = jwt.decode(self.access_token, options={"verify_signature": False}) + token_exp_timestamp = decoded_token["exp"] + # Get the current UTC time as a timezone-aware datetime object + utc_now = datetime.now(timezone.utc) + current_timestamp = int(utc_now.timestamp()) + if current_timestamp > token_exp_timestamp - offset: + logger.info("Nexus access token has expired, refreshing token...") + self.access_token = self.get_access_token() + decoded_token = jwt.decode(self.access_token, options={"verify_signature": False}) + token_exp_timestamp = decoded_token["exp"] + + return token_exp_timestamp + + @property + def forge(self): + key = f"{self.endpoint}|{self.bucket}|{self.forge_path}" + if key in self.__class__.forges: + expiry, forge = self.__class__.forges[key] + if expiry > datetime.now(timezone.utc): + return forge + + token_exp_timestamp = self.refresh_token() + forge = KnowledgeGraphForge( + self.forge_path, + bucket=self.bucket, + endpoint=self.endpoint, + token=self.access_token, + ) + + self.__class__.forges[key] = ( + datetime.fromtimestamp(token_exp_timestamp, timezone.utc) - timedelta(minutes=15), + forge, + ) + return forge + + @property + def available_etypes(self): + """List of ids of available etypes in this forge graph""" + if self._available_etypes is None: + self._available_etypes = self.get_available_etypes() + return self._available_etypes + + @property + def available_mtypes(self): + """List of ids of available mtypes in this forge graph""" + if self._available_mtypes is None: + self._available_mtypes = self.get_available_mtypes() + return self._available_mtypes + + @property + def available_ttypes(self): + """List of ids of available ttypes in this forge graph""" + if self._available_ttypes is None: + self._available_ttypes = self.get_available_ttypes() + return self._available_ttypes + + @property + def atlas_release(self): + """Hard-coded atlas release fields for metadata""" + # pylint: disable=protected-access + atlas_def = { + "id": "https://bbp.epfl.ch/neurosciencegraph/data/4906ab85-694f-469d-962f-c0174e901885", + "type": ["BrainAtlasRelease", "AtlasRelease"], + } + + if self._atlas_release is None: + self.refresh_token() + atlas_access_point = atlas_forge_access_point( + access_token=self.access_token, forge_path=self.forge_path + ) + atlas_resource = atlas_access_point.retrieve(atlas_def["id"]) + atlas_def["_rev"] = atlas_resource._store_metadata["_rev"] + self._atlas_release = atlas_def + return self._atlas_release + + def get_available_etypes(self): + """Returns a list of nexus ids of all the etype resources using sparql""" + query = """ + SELECT ?e_type_id + + WHERE {{ + ?e_type_id label ?e_type ; + subClassOf* EType ; + }} + """ + # should we use self.limit here? + resources = self.forge.sparql(query, limit=self.limit) + if resources is None: + return [] + return [r.e_type_id for r in resources] + + def get_available_mtypes(self): + """Returns a list of nexus ids of all the mtype resources using sparql""" + query = """ + SELECT ?m_type_id + + WHERE {{ + ?m_type_id label ?m_type ; + subClassOf* MType ; + }} + """ + # should we use self.limit here? + resources = self.forge.sparql(query, limit=self.limit) + if resources is None: + return [] + return [r.m_type_id for r in resources] + + def get_available_ttypes(self): + """Returns a list of nexus ids of all the ttype resources using sparql""" + query = """ + SELECT ?t_type_id + + WHERE {{ + ?t_type_id label ?t_type ; + subClassOf* BrainCellTranscriptomeType ; + }} + """ + # should we use self.limit here? + resources = self.forge.sparql(query, limit=self.limit) + if resources is None: + return [] + return [r.t_type_id for r in resources] + + @staticmethod + def get_access_token(): + """Define access token either from bbp-workflow or provided by the user""" + + try: + access_token = refresh_token() + except: # noqa: E722 + logger.info("Please get your Nexus access token from https://bbp.epfl.ch/nexus/web/.") + access_token = getpass.getpass() + if access_token is None: + logger.info("Please get your Nexus access token from https://bbp.epfl.ch/nexus/web/.") + access_token = getpass.getpass() + + return access_token + + @staticmethod + def connect_forge(bucket, endpoint, access_token, forge_path=None): + """Creation of a forge session""" + + if not forge_path: + forge_path = ( + "https://raw.githubusercontent.com/BlueBrain/nexus-forge/" + + "master/examples/notebooks/use-cases/prod-forge-nexus.yml" + ) + + forge = KnowledgeGraphForge( + forge_path, bucket=bucket, endpoint=endpoint, token=access_token + ) + + return forge + + def add_contribution(self, resource): + """Add the contributing agent to the resource""" + + if self.agent: + if isinstance(resource, Dataset): + resource.add_contribution(self.agent, versioned=False) + elif isinstance(resource, Resource): + resource.contribution = Resource(type="Contribution", agent=self.agent) + + return resource + + def resolve(self, text, scope="ontology", strategy="all", limit=1): + """Resolves a string to find the matching ontology""" + + if strategy == "all": + resolving_strategy = ResolvingStrategy.ALL_MATCHES + elif strategy == "best": + resolving_strategy = ResolvingStrategy.BEST_MATCH + elif strategy == "exact": + resolving_strategy = ResolvingStrategy.EXACT_MATCH + else: + raise ValueError( + f"Resolving strategy {strategy} does not exist. " + "Strategy should be 'all', 'best' or 'exact'" + ) + + return self.forge.resolve(text, scope=scope, strategy=resolving_strategy, limit=limit) + + def register( + self, + resource_description, + filters_existence=None, + legacy_filters_existence=None, + replace=False, + distributions=None, + images=None, + ): + """Register a resource from its dictionary description. + + Args: + resource_description (dict): contains resource type, name and metadata + filters_existence (dict): contains resource type, name and metadata, + can be used to search for existence of resource on nexus + legacy_filters_existence (dict): same as filters_existence, + but with legacy nexus metadata + replace (bool): whether to replace resource if found with filters_existence + distributions (list): paths to resource object as json and other distributions + images (list): paths to images to be attached to the resource + """ + + if "type" not in resource_description: + raise AccessPointException("The resource description should contain 'type'.") + + previous_resources = None + if filters_existence: + previous_resources = self.fetch_legacy_compatible( + filters_existence, legacy_filters_existence + ) + + if previous_resources: + if replace: + for resource in previous_resources: + rr = self.retrieve(resource.id) + self.forge.deprecate(rr) + + else: + logger.warning( + "The resource you are trying to register already exist and will be ignored." + ) + return + + resource_description["objectOfStudy"] = { + "@id": "http://bbp.epfl.ch/neurosciencegraph/taxonomies/objectsofstudy/singlecells", + "label": "Single Cell", + } + if resource_description.get("brainLocation", None) is not None: + resource_description["atlasRelease"] = self.atlas_release + + logger.debug("Registering resources: %s", resource_description) + + resource = self.forge.from_json(resource_description, na="None") + resource = self.add_contribution(resource) + + if distributions: + resource = Dataset.from_resource(self.forge, resource) + for path in distributions: + resource.add_distribution(path, content_type=f"application/{path.split('.')[-1]}") + + if images: + for path in images: + try: + resource_type = path.split("__")[-1].split(".")[0] + except IndexError: + resource_type = filters_existence.get("type", None) + # Do NOT do this BEFORE turning resource into a Dataset. + # That would break the storing LazyAction into a string + resource.add_image( + path=path, + content_type=f"application/{path.split('.')[-1]}", + about=resource_type, + ) + + self.forge.register(resource) + + def retrieve(self, id_): + """Retrieve a resource based on its id""" + + resource = self.forge.retrieve(id=id_, cross_bucket=self.cross_bucket) + + if resource: + return resource + + logger.debug("Could not retrieve resource of id: %s", id_) + + return None + + def fetch(self, filters): + """Fetch resources based on filters. + + Args: + filters (dict): keys and values used for the "WHERE". Should include "type" or "id". + + Returns: + resources (list): list of resources + """ + + if "type" not in filters and "id" not in filters: + raise AccessPointException("Search filters should contain either 'type' or 'id'.") + + logger.debug("Searching: %s", filters) + + resources = self.forge.search( + filters, + cross_bucket=self.cross_bucket, + limit=self.limit, + debug=self.debug, + search_endpoint=self.search_endpoint, + ) + + if resources: + return resources + + logger.debug("No resources for filters: %s", filters) + + return None + + def fetch_legacy_compatible(self, filters, legacy_filters=None): + """Fetch resources based on filters. Use legacy filters if no resources are found. + + Args: + filters (dict): keys and values used for the "WHERE". Should include "type" or "id". + legacy_filters (dict): same as filters, with legacy nexus metadata + + Returns: + resources (list): list of resources + """ + resources = self.fetch(filters) + if not resources and legacy_filters is not None: + resources = self.fetch(legacy_filters) + + if resources: + return resources + return None + + def fetch_one(self, filters, legacy_filters=None, strict=True): + """Fetch one and only one resource based on filters.""" + + resources = self.fetch_legacy_compatible(filters, legacy_filters) + + if resources is None: + if strict: + raise AccessPointException(f"Could not get resource for filters {filters}") + return None + + if len(resources) > 1: + if strict: + raise AccessPointException(f"More than one resource for filters {filters}") + return resources[0] + + return resources[0] + + def download(self, resource_id, download_directory, content_type=None): + """Download datafile from nexus.""" + resource = self.forge.retrieve(resource_id, cross_bucket=True) + + if resource is None: + raise AccessPointException(f"Could not find resource for id: {resource_id}") + + if hasattr(resource, "distribution"): + file_paths = [] + if isinstance(resource.distribution, list): + for dist in resource.distribution: + if hasattr(dist, "name"): + file_paths.append(pathlib.Path(download_directory) / dist.name) + else: + raise AttributeError( + f"A distribution of the resource {resource.name} does " + "not have a file name." + ) + else: + file_paths = [pathlib.Path(download_directory) / resource.distribution.name] + + self.forge.download( + resource, + "distribution.contentUrl", + download_directory, + cross_bucket=True, + content_type=content_type, + overwrite=True, + ) + + # Verify that each datafile for the resource was successfully downloaded + for fp in file_paths: + if not fp.exists(): + raise AccessPointException( + f"Download failed: file {fp} does not exist for resource {resource_id}" + ) + + return [str(fp) for fp in file_paths] + + return [] + + def deprecate(self, filters, legacy_filters=None): + """Deprecate resources based on filters.""" + + tmp_cross_bucket = self.cross_bucket + self.cross_bucket = False + + resources = self.fetch_legacy_compatible(filters, legacy_filters) + + if resources: + for resource in resources: + rr = self.retrieve(resource.id) + if rr is not None: + self.forge.deprecate(rr) + + self.cross_bucket = tmp_cross_bucket + + def deprecate_all(self, metadata, metadata_legacy=None): + """Deprecate all resources used or produced by BluePyModel. Use with extreme caution.""" + + if not yesno("Confirm deprecation of all BluePyEmodel resources in Nexus project"): + return + + for type_ in NEXUS_TYPE_TO_CLASS.keys(): + filters = {"type": type_} + filters.update(metadata) + + if metadata_legacy is None: + legacy_filters = None + else: + legacy_filters = {"type": type_} + legacy_filters.update(metadata_legacy) + + self.deprecate(filters, legacy_filters) + + def resource_location(self, resource, download_directory): + """Get the path of the files attached to a resource. If the resource is + not located on gpfs, download it instead""" + + paths = [] + + if not hasattr(resource, "distribution"): + raise AccessPointException(f"Resource {resource} does not have distribution") + + if isinstance(resource.distribution, list): + distribution_iter = resource.distribution + else: + distribution_iter = [resource.distribution] + + for distrib in distribution_iter: + filepath = None + + if hasattr(distrib, "atLocation"): + loc = self.forge.as_json(distrib.atLocation) + if "location" in loc: + filepath = loc["location"].replace("file:/", "") + + if filepath is None: + filepath = self.download(resource.id, download_directory)[0] + + paths.append(filepath) + + return paths + + @staticmethod + def resource_name(class_name, metadata, seed=None): + """Create a resource name from the class name and the metadata.""" + name_parts = [CLASS_TO_RESOURCE_NAME[class_name]] + if "iteration" in metadata: + name_parts.append(metadata["iteration"]) + if "eModel" in metadata: + name_parts.append(metadata["eModel"]) + if "tType" in metadata: + name_parts.append(metadata["tType"]) + # legacy nexus emodel metadata + if "emodel" in metadata: + name_parts.append(metadata["emodel"]) + # legacy nexus ttype metadata + if "ttype" in metadata: + name_parts.append(metadata["ttype"]) + if seed is not None: + name_parts.append(str(seed)) + + return "__".join(name_parts) + + @staticmethod + def dump_json_and_get_distributions(object_, class_name, metadata_str, seed=None): + """Write object as json dict, and get distribution paths (obj as json and others)""" + json_payload = object_.as_dict() + + path_json = f"{CLASS_TO_RESOURCE_NAME[class_name]}__{metadata_str}" + if seed is not None: + path_json += f"__{seed}" + path_json = str( + (pathlib.Path("./nexus_temp") / metadata_str / f"{path_json}.json").resolve() + ) + + distributions = [path_json] + json_payload.pop("nexus_images", None) # remove nexus_images from payload + if "nexus_distributions" in json_payload: + distributions += json_payload.pop("nexus_distributions") + + with open(path_json, "w") as fp: + json.dump(json_payload, fp, indent=2) + + return distributions + + @staticmethod + def get_seed_from_object(object_, class_name): + """Get the seed from the object if it has one else None.""" + seed = None + if class_name in ("EModel", "EModelScript"): + seed = object_.seed + return seed + + def object_to_nexus( + self, + object_, + metadata_dict, + metadata_str, + metadata_dict_legacy, + replace=True, + currents=None, + ): + """Transform a BPEM object into a dict which gets registered into Nexus as + the distribution of a Dataset of the matching type. The metadata + are also attached to the object to be able to retrieve the Resource.""" + + class_name = object_.__class__.__name__ + type_ = CLASS_TO_NEXUS_TYPE[class_name] + + seed = self.get_seed_from_object(object_, class_name) + score = None + if class_name == "EModel": + score = object_.fitness + + base_payload = { + "type": ["Entity", type_], + "name": self.resource_name(class_name, metadata_dict, seed=seed), + } + payload_existence = { + "type": type_, + "name": self.resource_name(class_name, metadata_dict, seed=seed), + } + payload_existence_legacy = { + "type": type_, + "name": self.resource_name(class_name, metadata_dict_legacy, seed=seed), + } + + base_payload.update(metadata_dict) + if score is not None: + base_payload["score"] = score + if currents is not None: + base_payload["holding_current"] = currents["holding"] + base_payload["threshold_current"] = currents["threshold"] + if hasattr(object_, "get_related_nexus_ids"): + related_nexus_ids = object_.get_related_nexus_ids() + if related_nexus_ids: + base_payload.update(related_nexus_ids) + + payload_existence.update(metadata_dict) + payload_existence.pop("annotation", None) + + payload_existence_legacy.update(metadata_dict_legacy) + payload_existence_legacy.pop("annotation", None) + + nexus_images = object_.as_dict().get("nexus_images", None) + distributions = self.dump_json_and_get_distributions( + object_=object_, class_name=class_name, metadata_str=metadata_str, seed=seed + ) + + self.register( + base_payload, + filters_existence=payload_existence, + legacy_filters_existence=payload_existence_legacy, + replace=replace, + distributions=distributions, + images=nexus_images, + ) + + def update_distribution(self, resource, metadata_str, object_): + """Update a resource distribution using python object. + + Cannot update resource that has more than one resource.""" + class_name = object_.__class__.__name__ + seed = self.get_seed_from_object(object_, class_name) + + distributions = self.dump_json_and_get_distributions( + object_=object_, + class_name=class_name, + metadata_str=metadata_str, + seed=seed, + ) + + path_json = distributions[0] + + resource = Dataset.from_resource(self.forge, resource, store_metadata=True) + # Nexus behavior: + # - if only one element, gives either a dict or a list + # - if multiple elements, returns a list of elements + # Here, we want to be sure that we only have one element + if isinstance(resource.distribution, list): + if len(resource.distribution) != 1: + raise TypeError( + f"'update_distribution' method cannot be used on {class_name} {metadata_str} " + "with more than 1 distribution." + ) + elif not isinstance(resource.distribution, dict): + raise TypeError( + "'update_distribution' method requires a dict or a single-element list for " + f"{class_name} {metadata_str}, got {type(resource.distribution)} instead." + ) + + # add distribution from object and remove old one from resource + resource.add_distribution(path_json, content_type=f"application/{path_json.split('.')[-1]}") + resource.distribution = [resource.distribution[1]] + return resource + + def resource_to_object(self, type_, resource, metadata, download_directory): + """Transform a Resource into a BPEM object of the matching type""" + + file_paths = self.download(resource.id, download_directory) + json_path = next((fp for fp in file_paths if pathlib.Path(fp).suffix == ".json"), None) + + if json_path is None: + # legacy case where the payload is in the Resource + # can no longer use this for recent resources + payload = self.forge.as_json(resource) + + for k in metadata: + payload.pop(k, None) + + for k in NEXUS_ENTRIES: + payload.pop(k, None) + + else: + # Case in which the payload is in a .json distribution + with open(json_path, "r") as f: + payload = json.load(f) + + return NEXUS_TYPE_TO_CLASS[type_](**payload) + + def nexus_to_object(self, type_, metadata, download_directory, legacy_metadata=None): + """Search for a single Resource matching the ``type_`` and metadata and return it + as a BPEM object of the matching type""" + + filters = {"type": type_} + filters.update(metadata) + + legacy_filters = None + if legacy_metadata: + legacy_filters = {"type": type_} + legacy_filters.update(legacy_metadata) + + resource = self.fetch_one(filters, legacy_filters) + + return self.resource_to_object(type_, resource, metadata, download_directory) + + def nexus_to_objects(self, type_, metadata, download_directory, legacy_metadata=None): + """Search for Resources matching the ``type_`` and metadata and return them + as BPEM objects of the matching type""" + + filters = {"type": type_} + filters.update(metadata) + + legacy_filters = None + if legacy_metadata: + legacy_filters = {"type": type_} + legacy_filters.update(legacy_metadata) + + resources = self.fetch_legacy_compatible(filters, legacy_filters) + + objects_ = [] + ids = [] + + if resources: + for resource in resources: + objects_.append( + self.resource_to_object(type_, resource, metadata, download_directory) + ) + ids.append(resource.id) + + return objects_, ids + + def get_nexus_id(self, type_, metadata, legacy_metadata=None): + """Search for a single Resource matching the ``type_`` and metadata and return its id""" + filters = {"type": type_} + filters.update(metadata) + + legacy_filters = None + if legacy_metadata: + legacy_filters = {"type": type_} + legacy_filters.update(legacy_metadata) + + resource = self.fetch_one(filters, legacy_filters) + + return resource.id + + @staticmethod + def brain_region_filter(resources): + """Filter resources to keep only brain regions + + Arguments: + resources (list of Resource): resources to be filtered + + Returns: + list of Resource: the filtered resources + """ + return [ + r for r in resources if hasattr(r, "subClassOf") and r.subClassOf == "nsg:BrainRegion" + ] + + def type_filter(self, resources, filter): + """Filter resources to keep only etypes/mtypes/ttypes + + Arguments: + resources (list of Resource): resources to be filtered + filter (str): can be "etype", "mytype" or "ttype" + + Returns: + list of Resource: the filtered resources + """ + if filter == "etype": + available_names = self.available_etypes + elif filter == "mtype": + available_names = self.available_mtypes + elif filter == "ttype": + available_names = self.available_ttypes + else: + raise AccessPointException( + f'filter is {filter} but should be in ["etype", "mtype", "ttype"]' + ) + return [r for r in resources if r.id in available_names] + + def filter_resources(self, resources, filter): + """Filter resources + + Arguments: + resources (list of Resource): resources to be filtered + filter (str): which filter to use + can be "brain_region", "etype", "mtype", "ttype" + + Returns: + list of Resource: the filtered resources + + Raises: + AccessPointException if filter not in ["brain_region", "etype", "mtype", "ttype"] + """ + if filter == "brain_region": + return self.brain_region_filter(resources) + if filter in ["etype", "mtype", "ttype"]: + return self.type_filter(resources, filter) + + filters = ["brain_region", "etype", "mtype", "ttype"] + raise AccessPointException( + f"Filter not expected in filter_resources: {filter}" + f"Please choose among the following filters: {filters}" + ) + + +def ontology_forge_access_point(access_token=None, forge_path=None): + """Returns an access point targeting the project containing the ontology for the + species and brain regions""" + + access_point = NexusForgeAccessPoint( + project="datamodels", + organisation="neurosciencegraph", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=forge_path, + access_token=access_token, + ) + + return access_point + + +def atlas_forge_access_point(access_token=None, forge_path=None): + """Returns an access point targeting the project containing the atlas""" + + access_point = NexusForgeAccessPoint( + project="atlas", + organisation="bbp", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=forge_path, + access_token=access_token, + ) + + return access_point + + +def raise_not_found_exception(base_text, label, access_point, filter, limit=30): + """Raise an exception mentioning the possible appropriate resource names available on nexus + + Arguments: + base_text (str): text to display in the Exception + label (str): name of the resource to search for + access_point (NexusForgeAccessPoint) + filter (str): which filter to use + can be "brain_region", "etype", "mtype", or "ttype" + limit (int): maximum number of resources to fetch when looking up + for resource name suggestions + """ + if not base_text.endswith("."): + base_text = f"{base_text}." + + resources = access_point.resolve(label, strategy="all", limit=limit) + if resources is None: + raise AccessPointException(base_text) + + # make sure that resources is iterable + if not isinstance(resources, list): + resources = [resources] + filtered_names = "\n".join( + set(r.label for r in access_point.filter_resources(resources, filter)) + ) + if filtered_names: + raise AccessPointException(f"{base_text} Maybe you meant one of those:\n{filtered_names}") + + raise AccessPointException(base_text) + + +def check_resource(label, category, access_point=None, access_token=None, forge_path=None): + """Checks that resource is present on nexus and is part of the provided category + + Arguments: + label (str): name of the resource to search for + category (str): can be "etype", "mtype" or "ttype" + access_point (str): ontology_forge_access_point(access_token) + forge_path (str): path to a .yml used as configuration by nexus-forge. + """ + allowed_categories = ["etype", "mtype", "ttype"] + if category not in allowed_categories: + raise AccessPointException(f"Category is {category}, but should be in {allowed_categories}") + + if access_point is None: + access_point = ontology_forge_access_point(access_token, forge_path) + + resource = access_point.resolve(label, strategy="exact") + # raise Exception if resource was not found + if resource is None: + base_text = f"Could not find {category} with name {label}" + raise_not_found_exception(base_text, label, access_point, category) + + # if resource found but not of the appropriate category, also raise Exception + available_names = [] + if category == "etype": + available_names = access_point.available_etypes + elif category == "mtype": + available_names = access_point.available_mtypes + elif category == "ttype": + available_names = access_point.available_ttypes + if resource.id not in available_names: + base_text = f"Resource {label} is not a {category}" + raise_not_found_exception(base_text, label, access_point, category) + + +def get_available_traces(species=None, brain_region=None, access_token=None, forge_path=None): + """Returns a list of Resources of type Traces from the bbp/lnmce Nexus project""" + + filters = {"type": "Trace", "distribution": {"encodingFormat": "application/nwb"}} + + if species: + filters["subject"] = species + if brain_region: + filters["brainLocation"] = brain_region + + resources = [] + for proj_traces in NEXUS_PROJECTS_TRACES: + access_point = NexusForgeAccessPoint( + project=proj_traces["project"], + organisation=proj_traces["organisation"], + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=forge_path, + access_token=access_token, + cross_bucket=True, + ) + tmp_resources = access_point.fetch(filters=filters) + if tmp_resources: + resources += tmp_resources + + return resources + + +def get_brain_region(brain_region, access_token=None, forge_path=None): + """Returns the resource corresponding to the brain region + + If the brain region name is not present in nexus, + raise an exception mentioning the possible brain region names available on nexus + + Arguments: + brain_region (str): name of the brain region to search for + access_token (str): nexus connection token + forge_path (str): path to a .yml used as configuration by nexus-forge. + """ + + filter = "brain_region" + access_point = ontology_forge_access_point(access_token, forge_path) + + if brain_region in ["SSCX", "sscx"]: + brain_region = "somatosensory areas" + if brain_region == "all": + # http://api.brain-map.org/api/v2/data/Structure/8 + brain_region = "Basic cell groups and regions" + + resource = access_point.resolve(brain_region, strategy="exact") + # try with capital 1st letter, or every letter lowercase + if resource is None: + # do not use capitalize, because it also make every other letter lowercase + if len(brain_region) > 1: + brain_region = f"{brain_region[0].upper()}{brain_region[1:]}" + elif len(brain_region) == 1: + brain_region = brain_region.upper() + resource = access_point.resolve(brain_region, strategy="exact") + + if resource is None: + resource = access_point.resolve(brain_region.lower(), strategy="exact") + + if isinstance(resource, list): + resource = resource[0] + + # raise Exception if resource was not found + if resource is None: + base_text = f"Could not find any brain region with name {brain_region}" + raise_not_found_exception(base_text, brain_region, access_point, filter) + + return resource + + +def get_brain_region_dict(brain_region, access_token=None, forge_path=None): + """Returns a dict with id and label of the resource corresponding to the brain region + + Arguments: + brain_region (str): name of the brain region to search for + access_token (str): nexus connection token + forge_path (str): path to a .yml used as configuration by nexus-forge. + + Returns: + dict: the id and label of the nexus resource of the brain region + """ + br_resource = get_brain_region(brain_region, access_token, forge_path) + + access_point = ontology_forge_access_point(access_token, forge_path) + + # if no exception was raised, filter to get id and label and return them + brain_region_dict = access_point.forge.as_json(br_resource) + return { + "id": brain_region_dict["id"], + "label": brain_region_dict["label"], + } + + +def get_brain_region_notation(brain_region, access_token=None, forge_path=None): + """Get the ontology of the brain location.""" + if brain_region is None: + return None + + brain_region_resource = get_brain_region( + brain_region, access_token=access_token, forge_path=forge_path + ) + + return brain_region_resource.notation + + +def get_nexus_brain_region(brain_region, access_token=None, forge_path=None): + """Get the ontology of the brain location.""" + if brain_region is None: + return None + + brain_region_from_nexus = get_brain_region_dict( + brain_region, access_token=access_token, forge_path=forge_path + ) + + return { + "type": "BrainLocation", + "brainRegion": brain_region_from_nexus, + } + + +def get_all_species(access_token=None, forge_path=None): + access_point = ontology_forge_access_point(access_token, forge_path) + + resources = access_point.forge.search({"subClassOf": "nsg:Species"}, limit=100) + + return sorted(set(r.label for r in resources)) + + +def get_curated_morphology(resources): + """Get curated morphology from multiple resources with same morphology name""" + for r in resources: + if hasattr(r, "annotation"): + annotations = r.annotation if isinstance(r.annotation, list) else [r.annotation] + for annotation in annotations: + if "QualityAnnotation" in annotation.type: + if annotation.hasBody.label == "Curated": + return r + if hasattr(r, "derivation"): + return r + return None + + +def filter_mechanisms_with_brain_region(forge, resources, brain_region_label, br_visited): + """Filter mechanisms by brain region""" + br_visited.add(brain_region_label) + filtered_resources = [ + r + for r in resources + if hasattr(r, "brainLocation") and r.brainLocation.brainRegion.label == brain_region_label + ] + if len(filtered_resources) > 0: + return filtered_resources, br_visited + + query = ( + """ + SELECT DISTINCT ?br ?label + WHERE{ + ?id label \"""" + + f"{brain_region_label}" + + """\" ; + isPartOf ?br . + ?br label ?label . + } + """ + ) + brs = forge.sparql(query, limit=1000) + # when fails can be None or empty list + if brs: + new_brain_region_label = brs[0].label + return filter_mechanisms_with_brain_region( + forge, resources, new_brain_region_label, br_visited + ) + + # if no isPartOf present, try with isLayerPartOf + query = ( + """ + SELECT DISTINCT ?br ?label + WHERE{ + ?id label \"""" + + f"{brain_region_label}" + + """\" ; + isLayerPartOf ?br . + ?br label ?label . + } + """ + ) + brs = forge.sparql(query, limit=1000) + # when fails can be None or empty list + if brs: + # can have multiple brain regions + for br in brs: + new_brain_region_label = br.label + resources, br_visited = filter_mechanisms_with_brain_region( + forge, resources, new_brain_region_label, br_visited + ) + if resources is not None: + return resources, br_visited + + return None, br_visited diff --git a/bluepyemodel/access_point/local.py b/bluepyemodel/access_point/local.py index b3dd1585..4b9d99d0 100644 --- a/bluepyemodel/access_point/local.py +++ b/bluepyemodel/access_point/local.py @@ -1,7 +1,7 @@ """LocalAccessPoint class.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/access_point/nexus.py b/bluepyemodel/access_point/nexus.py new file mode 100755 index 00000000..d775eb21 --- /dev/null +++ b/bluepyemodel/access_point/nexus.py @@ -0,0 +1,1395 @@ +"""Access point using Nexus Forge""" + +import copy +import logging +import os +import pathlib +import subprocess +import time +from itertools import chain + +import pandas +from kgforge.core import Resource + +from bluepyemodel.access_point.access_point import DataAccessPoint +from bluepyemodel.access_point.forge_access_point import NEXUS_PROJECTS_TRACES +from bluepyemodel.access_point.forge_access_point import AccessPointException +from bluepyemodel.access_point.forge_access_point import NexusForgeAccessPoint +from bluepyemodel.access_point.forge_access_point import check_resource +from bluepyemodel.access_point.forge_access_point import filter_mechanisms_with_brain_region +from bluepyemodel.access_point.forge_access_point import get_available_traces +from bluepyemodel.access_point.forge_access_point import get_brain_region_notation +from bluepyemodel.access_point.forge_access_point import get_curated_morphology +from bluepyemodel.access_point.forge_access_point import get_nexus_brain_region +from bluepyemodel.access_point.forge_access_point import ontology_forge_access_point +from bluepyemodel.efeatures_extraction.trace_file import TraceFile +from bluepyemodel.emodel_pipeline.emodel_script import EModelScript +from bluepyemodel.emodel_pipeline.emodel_settings import EModelPipelineSettings +from bluepyemodel.emodel_pipeline.emodel_workflow import EModelWorkflow +from bluepyemodel.export_emodel.utils import copy_hocs_to_new_output_path +from bluepyemodel.export_emodel.utils import get_hoc_file_path +from bluepyemodel.export_emodel.utils import get_output_path +from bluepyemodel.export_emodel.utils import select_emodels +from bluepyemodel.model.mechanism_configuration import MechanismConfiguration +from bluepyemodel.tools.mechanisms import NEURON_BUILTIN_MECHANISMS +from bluepyemodel.tools.mechanisms import discriminate_by_temp + +# pylint: disable=too-many-arguments,unused-argument + +logger = logging.getLogger("__main__") + + +class NexusAccessPoint(DataAccessPoint): + """API to retrieve, push and format data from and to the Knowledge Graph""" + + def __init__( + self, + emodel=None, + etype=None, + ttype=None, + mtype=None, + species=None, + brain_region=None, + iteration_tag=None, + synapse_class=None, + project="emodel_pipeline", + organisation="demo", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + forge_ontology_path=None, + access_token=None, + sleep_time=10, + ): + """Init + + Args: + emodel (str): name of the emodel + etype (str): name of the electric type. + ttype (str): name of the transcriptomic type. + Required if using the gene expression or IC selector. + mtype (str): name of the morphology type. + species (str): name of the species. + brain_region (str): name of the brain location. + iteration_tag (str): tag associated to the current run. + synapse_class (str): synapse class (neurotransmitter). + project (str): name of the Nexus project. + organisation (str): name of the Nexus organization to which the project belong. + endpoint (str): Nexus endpoint. + forge_path (str): path to a .yml used as configuration by nexus-forge. + forge_ontology_path (str): path to a .yml used for the ontology in nexus-forge. + access_token (str): Nexus connection token. + sleep_time (int): time to wait between two Nexus requests (in case of slow indexing). + """ + + super().__init__( + emodel, + etype, + ttype, + mtype, + species, + brain_region, + iteration_tag, + synapse_class, + ) + + self.access_point = NexusForgeAccessPoint( + project=project, + organisation=organisation, + endpoint=endpoint, + forge_path=forge_path, + access_token=access_token, + ) + + if forge_ontology_path is None: + self.forge_ontology_path = forge_path + else: + self.forge_ontology_path = forge_ontology_path + + # This trick is used to have nexus type descriptions on one side and basic + # strings on the other + self.emodel_metadata_ontology = copy.deepcopy(self.emodel_metadata) + self.build_ontology_based_metadata() + self.emodel_metadata.allen_notation = get_brain_region_notation( + self.emodel_metadata.brain_region, + self.access_point.access_token, + self.forge_ontology_path, + ) + + self.pipeline_settings = self.get_pipeline_settings(strict=False) + + directory_name = self.emodel_metadata.as_string() + (pathlib.Path("./nexus_temp/") / directory_name).mkdir(parents=True, exist_ok=True) + + self.sleep_time = sleep_time + + @property + def download_directory(self): + return pathlib.Path("./nexus_temp") / str(self.emodel_metadata.iteration) + + def check_mettypes(self): + """Check that etype, mtype and ttype are present on nexus""" + ontology_access_point = ontology_forge_access_point( + self.access_point.access_token, self.forge_ontology_path + ) + + logger.info("Checking if etype %s is present on nexus...", self.emodel_metadata.etype) + check_resource( + self.emodel_metadata.etype, + "etype", + access_point=ontology_access_point, + access_token=self.access_point.access_token, + forge_path=self.forge_ontology_path, + ) + logger.info("Etype checked") + + if self.emodel_metadata.mtype is not None: + logger.info( + "Checking if mtype %s is present on nexus...", + self.emodel_metadata.mtype, + ) + check_resource( + self.emodel_metadata.mtype, + "mtype", + access_point=ontology_access_point, + access_token=self.access_point.access_token, + forge_path=self.forge_ontology_path, + ) + logger.info("Mtype checked") + else: + logger.info("Mtype is None, its presence on Nexus is not being checked.") + + if self.emodel_metadata.ttype is not None: + logger.info( + "Checking if ttype %s is present on nexus...", + self.emodel_metadata.ttype, + ) + check_resource( + self.emodel_metadata.ttype, + "ttype", + access_point=ontology_access_point, + access_token=self.access_point.access_token, + forge_path=self.forge_ontology_path, + ) + logger.info("Ttype checked") + else: + logger.info("Ttype is None, its presence on Nexus is not being checked.") + + def get_pipeline_settings(self, strict=True): + if strict: + return self.access_point.nexus_to_object( + type_="EModelPipelineSettings", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + try: + return self.access_point.nexus_to_object( + type_="EModelPipelineSettings", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + except AccessPointException: + return EModelPipelineSettings() + + def store_pipeline_settings(self, pipeline_settings): + """Save an EModelPipelineSettings on Nexus""" + + self.access_point.object_to_nexus( + pipeline_settings, + self.emodel_metadata_ontology.for_resource(), + self.emodel_metadata.as_string(), + self.emodel_metadata_ontology.filters_for_resource_legacy(), + replace=True, + ) + + def build_ontology_based_metadata(self): + """Get the ontology related to the metadata""" + + self.emodel_metadata_ontology.species = self.get_nexus_subject(self.emodel_metadata.species) + self.emodel_metadata_ontology.brain_region = get_nexus_brain_region( + self.emodel_metadata.brain_region, + self.access_point.access_token, + self.forge_ontology_path, + ) + + def get_nexus_subject(self, species): + """ + Get the ontology of a species based on the species name. + + Args: + species (str): The common name or scientific name of the species. + Can be None, in which case the function will return None. + + Returns: + dict: The ontology data for the specified species. + + Raises: + ValueError: If the species is not recognized. + """ + + if species is None: + return None + + species = species.lower() + if species in ("human", "homo sapiens"): + subject = { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_9606", + "label": "Homo sapiens", + }, + } + + elif species in ("rat", "rattus norvegicus"): + subject = { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_10116", + "label": "Rattus norvegicus", + }, + } + + elif species in ("mouse", "mus musculus"): + subject = { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_10090", + "label": "Mus musculus", + }, + } + else: + raise ValueError(f"Unknown species {species}.") + + return subject + + def store_object(self, object_, seed=None, description=None, currents=None): + """Store a BPEM object on Nexus""" + + metadata_dict = self.emodel_metadata_ontology.for_resource() + if seed is not None: + metadata_dict["seed"] = seed + if description is not None: + metadata_dict["description"] = description + + self.access_point.object_to_nexus( + object_, + metadata_dict, + self.emodel_metadata.as_string(), + self.emodel_metadata_ontology.filters_for_resource_legacy(), + replace=True, + currents=currents, + ) + + def get_targets_configuration(self): + """Get the configuration of the targets (targets and ephys files used)""" + + configuration = self.access_point.nexus_to_object( + type_="ExtractionTargetsConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + configuration.available_traces = self.get_available_traces() + configuration.available_efeatures = self.get_available_efeatures() + + if not configuration.files: + logger.debug( + "Empty list of files in the TargetsConfiguration, filling " + "it using what is available on Nexus for the present etype." + ) + filtered_traces = [ + trace + for trace in configuration.available_traces + if trace.etype == self.emodel_metadata.etype + ] + if not filtered_traces: + raise AccessPointException( + "Could not find any trace with etype {self.emodel_metadata.etype}. " + "Please specify files in your ExtractionTargetsConfiguration." + ) + configuration.files = filtered_traces + + for file in configuration.files: + file.filepath = self.download_trace( + id_=file.id, id_legacy=file.resource_id, name=file.filename + ) + + return configuration + + def store_targets_configuration(self, configuration): + """Store the configuration of the targets (targets and ephys files used)""" + + # Search for all Traces on Nexus and add their Nexus ids to the configuration + traces = get_available_traces( + access_token=self.access_point.access_token, + forge_path=self.access_point.forge_path, + ) + + available_traces_names = [trace.name for trace in traces] + + for file in configuration.files: + if file.cell_name in available_traces_names: + file.id = traces[available_traces_names.index(file.cell_name)].id + else: + logger.warning("Trace %s not found.", file.cell_name) + + self.store_object(configuration) + + def get_fitness_calculator_configuration(self, record_ions_and_currents=False): + """Get the configuration of the fitness calculator (efeatures and protocols)""" + + configuration = self.access_point.nexus_to_object( + type_="FitnessCalculatorConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + # contains ion currents and ionic concentrations to be recorded + ion_variables = None + if record_ions_and_currents: + ion_currents, ionic_concentrations = self.get_ion_currents_concentrations() + if ion_currents is not None and ionic_concentrations is not None: + ion_variables = list(chain.from_iterable((ion_currents, ionic_concentrations))) + + for prot in configuration.protocols: + prot.recordings, prot.recordings_from_config = prot.init_recordings( + prot.recordings_from_config, ion_variables + ) + + if configuration.name_rmp_protocol is None: + configuration.name_rmp_protocol = self.pipeline_settings.name_rmp_protocol + if configuration.name_rin_protocol is None: + configuration.name_rin_protocol = self.pipeline_settings.name_Rin_protocol + if configuration.validation_protocols is None or configuration.validation_protocols == []: + configuration.validation_protocols = self.pipeline_settings.validation_protocols + if configuration.stochasticity is None: + configuration.stochasticity = self.pipeline_settings.stochasticity + + return configuration + + def store_fitness_calculator_configuration(self, configuration): + """Store a fitness calculator configuration as a resource of type + FitnessCalculatorConfiguration""" + workflow, nexus_id = self.get_emodel_workflow() + + if workflow is None: + raise AccessPointException( + "No EModelWorkflow available to which the EModels can be linked" + ) + + configuration.workflow_id = nexus_id + self.store_object(configuration) + # wait for the object to be uploaded and fetchable + time.sleep(self.sleep_time) + + # fetch just uploaded FCC resource to get its id and give it to emodel workflow + type_ = "FitnessCalculatorConfiguration" + filters = {"type": type_} + filters.update(self.emodel_metadata_ontology.filters_for_resource()) + filters_legacy = {"type": type_} + filters_legacy.update(self.emodel_metadata_ontology.filters_for_resource_legacy()) + resource = self.access_point.fetch_one(filters, filters_legacy) + fitness_id = resource.id + + workflow.fitness_configuration_id = fitness_id + self.store_or_update_emodel_workflow(workflow) + + def get_model_configuration(self, skip_get_available_morph=True): + """Get the configuration of the model, including parameters, mechanisms and distributions + + Args: + skip_get_available_morphs (bool): set to True to skip getting the available + morphologies and setting them to configuration. + available_morphologies are only used in + bluepyemodel.model.model_configuration.configure_model, so we assume + they have already been checked for configuration present on nexus. + """ + + configuration = self.access_point.nexus_to_object( + type_="EModelConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + morph_path = self.download_morphology( + configuration.morphology.name, + configuration.morphology.format, + configuration.morphology.id, + ) + any_downloaded = False + if self.pipeline_settings.use_ProbAMPANMDA_EMS: + any_downloaded = self.download_ProbAMPANMDA_EMS() + self.download_mechanisms(configuration.mechanisms, any_downloaded) + + configuration.morphology.path = morph_path + logger.debug("Using morphology: %s", configuration.morphology.path) + configuration.available_mechanisms = self.get_available_mechanisms() + if not skip_get_available_morph: + configuration.available_morphologies = self.get_available_morphologies() + + return configuration + + def fetch_and_filter_mechanism(self, mechanism, ontology_access_point): + """Find a mech resource based on its brain region, temperature, species and ljp correction + + Args: + mechanism (MechanismConfiguration): the mechanism to find on nexus + ontology_access_point (NexusForgeAccessPoint): access point + where to find the brain regions + + Returns the mechanism as a nexus resource + """ + default_temperatures = [34, 35, 37] + default_ljp = True + + resources = self.access_point.fetch( + {"type": "SubCellularModelScript", "name": mechanism.name} + ) + if resources is None: + raise AccessPointException(f"SubCellularModelScript {mechanism.name} not found") + + # brain region filtering + br_visited = set() + filtered_resources, br_visited = filter_mechanisms_with_brain_region( + ontology_access_point.forge, + resources, + self.emodel_metadata_ontology.brain_region["brainRegion"]["label"], + br_visited, + ) + br_visited_to_str = ", ".join(br_visited) + error_msg = f"brain region in ({br_visited_to_str})" + if filtered_resources is not None: + resources = filtered_resources + + # temperature filtering + if mechanism.temperature is not None: + error_msg += f"temperature = {mechanism.temperature} " + filtered_resources = [ + r + for r in resources + if hasattr(r, "temperature") + and getattr(r.temperature, "value", r.temperature) == mechanism.temperature + ] + if len(filtered_resources) > 0: + resources = filtered_resources + + # species filtering + error_msg += f"species = {self.emodel_metadata_ontology.species['species']['label']} " + filtered_resources = [ + r + for r in resources + if hasattr(r, "subject") + and r.subject.species.label == self.emodel_metadata_ontology.species["species"]["label"] + ] + if len(filtered_resources) > 0: + resources = filtered_resources + + # ljp correction filtering + if mechanism.ljp_corrected is not None: + error_msg += f"ljp correction = {mechanism.ljp_corrected} " + filtered_resources = [ + r + for r in resources + if hasattr(r, "isLjpCorrected") and r.isLjpCorrected == mechanism.ljp_corrected + ] + if len(filtered_resources) > 0: + resources = filtered_resources + + if len(resources) == 0: + raise AccessPointException( + f"SubCellularModelScript {mechanism.name} not found with {error_msg}" + ) + + # use default values + if len(resources) > 1: + logger.warning( + "More than one resource fetched for mechanism %s", + mechanism.name, + ) + if len(resources) > 1 and mechanism.temperature is None: + resources = discriminate_by_temp(resources, default_temperatures) + + if len(resources) > 1 and mechanism.ljp_corrected is None: + tmp_resources = [ + r + for r in resources + if hasattr(r, "isLjpCorrected") and r.isLjpCorrected is default_ljp + ] + if len(tmp_resources) > 0 and len(tmp_resources) < len(resources): + logger.warning( + "Discriminating resources based on ljp correction. " + "Keeping only resource with ljp correction." + ) + resources = tmp_resources + + if len(resources) > 1: + logger.warning( + "Could not reduce the number of resources fetched down to one. " + "Keeping the 1st resource of the list." + ) + + return resources[0] + + def store_model_configuration(self, configuration, path=None): + """Store a model configuration as a resource of type EModelConfiguration""" + + # Search for all Morphologies on Nexus and add their Nexus ids to the configuration + morphologies = self.access_point.fetch({"type": "NeuronMorphology"}) + if not morphologies: + raise AccessPointException( + "Cannot find morphologies on Nexus. Please make sure that " + "morphologies can be reached from the current Nexus session." + ) + + available_morphologies_names = [morphology.name for morphology in morphologies] + + if configuration.morphology.name in available_morphologies_names: + configuration.morphology.id = morphologies[ + available_morphologies_names.index(configuration.morphology.name) + ].id + else: + logger.warning("Morphology %s not found.", configuration.morphology.name) + + # set id to mechanisms by filtering with brain region, temperature, species, ljp correction + ontology_access_point = ontology_forge_access_point( + self.access_point.access_token, self.forge_ontology_path + ) + for mechanism in configuration.mechanisms: + if mechanism.name in NEURON_BUILTIN_MECHANISMS: + continue + mech_resource = self.fetch_and_filter_mechanism(mechanism, ontology_access_point) + mechanism.id = mech_resource.id + + if self.pipeline_settings.use_ProbAMPANMDA_EMS: + ProbAMPANMDA_EMS_id = self.get_ProbAMPANMDA_EMS_resource().id + configuration.extra_mech_ids = [(ProbAMPANMDA_EMS_id, "SynapsePhysiologyModel")] + + self.store_object(configuration) + + def get_distributions(self): + """Get the list of available distributions""" + + return self.access_point.nexus_to_objects( + type_="EModelChannelDistribution", + metadata={}, + download_directory=self.download_directory, + )[0] + + def store_distribution(self, distribution): + """Store a channel distribution as a resource of type EModelChannelDistribution""" + + self.store_object(distribution) + + def create_emodel_workflow(self, state="not launched"): + """Create an EModelWorkflow instance filled with the appropriate configuration""" + + try: + targets_configuration_id = self.access_point.get_nexus_id( + type_="ExtractionTargetsConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + except AccessPointException: + targets_configuration_id = None + + pipeline_settings_id = self.access_point.get_nexus_id( + type_="EModelPipelineSettings", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + emodel_configuration_id = self.access_point.get_nexus_id( + type_="EModelConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + try: + fitness_configuration_id = self.access_point.get_nexus_id( + type_="FitnessCalculatorConfiguration", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + except AccessPointException: + fitness_configuration_id = None + + return EModelWorkflow( + targets_configuration_id, + pipeline_settings_id, + emodel_configuration_id, + fitness_configuration_id=fitness_configuration_id, + state=state, + ) + + def get_emodel_workflow(self): + """Get the emodel workflow, containing configuration data and workflow status + + Returns None if the emodel workflow is not present on nexus.""" + + emodel_workflow, ids = self.access_point.nexus_to_objects( + type_="EModelWorkflow", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + if emodel_workflow: + return emodel_workflow[0], ids[0] + + return None, None + + def check_emodel_workflow_configurations(self, emodel_workflow): + """Return True if the emodel workflow's configurations are on nexus, and False otherwise""" + + for id_ in emodel_workflow.get_configuration_ids(): + if id_ is not None and self.access_point.retrieve(id_) is None: + return False + + return True + + def store_or_update_emodel_workflow(self, emodel_workflow): + """If emodel workflow is not on nexus, store it. If it is, fetch it and update its state""" + type_ = "EModelWorkflow" + + filters = {"type": type_} + filters.update(self.emodel_metadata_ontology.filters_for_resource()) + filters_legacy = {"type": type_} + filters_legacy.update(self.emodel_metadata_ontology.filters_for_resource_legacy()) + resources = self.access_point.fetch_legacy_compatible(filters, filters_legacy) + + # not present on nexus yet -> store it + if resources is None: + self.access_point.object_to_nexus( + emodel_workflow, + self.emodel_metadata_ontology.for_resource(), + self.emodel_metadata.as_string(), + self.emodel_metadata_ontology.filters_for_resource_legacy(), + replace=False, + ) + # if present on nexus -> update its state + else: + resource = resources[0] + resource.state = emodel_workflow.state + ids_dict = emodel_workflow.get_related_nexus_ids() + if "generates" in ids_dict: + resource.generates = ids_dict["generates"] + if "hasPart" in ids_dict: + resource.hasPart = ids_dict["hasPart"] + + # in case some data has been updated, e.g. fitness_configuration_id + updated_resource = self.access_point.update_distribution( + resource, self.emodel_metadata.as_string(), emodel_workflow + ) + + self.access_point.forge.update(updated_resource) + + def get_emodel(self, seed=None): + """Fetch an emodel""" + + metadata = self.emodel_metadata_ontology.filters_for_resource() + legacy_metadata = self.emodel_metadata_ontology.filters_for_resource_legacy() + + if seed is not None: + metadata["seed"] = int(seed) + legacy_metadata["seed"] = int(seed) + + emodel = self.access_point.nexus_to_object( + type_="EModel", + metadata=metadata, + download_directory=self.download_directory, + legacy_metadata=legacy_metadata, + ) + emodel.emodel_metadata = copy.deepcopy(self.emodel_metadata) + + return emodel + + def store_emodel(self, emodel, description=None): + """Store an EModel on Nexus""" + + workflow, nexus_id = self.get_emodel_workflow() + + if workflow is None: + raise AccessPointException( + "No EModelWorkflow available to which the EModels can be linked" + ) + + emodel.workflow_id = nexus_id + self.store_object(emodel, seed=emodel.seed, description=description) + # wait for the object to be uploaded and fetchable + time.sleep(self.sleep_time) + + # fetch just uploaded emodel resource to get its id and give it to emodel workflow + type_ = "EModel" + filters = {"type": type_, "seed": emodel.seed} + filters.update(self.emodel_metadata_ontology.filters_for_resource()) + filters_legacy = {"type": type_, "seed": emodel.seed} + filters_legacy.update(self.emodel_metadata_ontology.filters_for_resource_legacy()) + resource = self.access_point.fetch_one(filters, filters_legacy) + model_id = resource.id + + workflow.add_emodel_id(model_id) + self.store_or_update_emodel_workflow(workflow) + + def get_emodels(self, emodels=None): + """Get all the emodels""" + + emodels, _ = self.access_point.nexus_to_objects( + type_="EModel", + metadata=self.emodel_metadata_ontology.filters_for_resource(), + download_directory=self.download_directory, + legacy_metadata=self.emodel_metadata_ontology.filters_for_resource_legacy(), + ) + + for em in emodels: + em.emodel_metadata = copy.deepcopy(self.emodel_metadata) + + return emodels + + def has_best_model(self, seed): + """Check if the best model has been stored.""" + + try: + self.get_emodel(seed=seed) + return True + except AccessPointException: + return False + + def is_checked_by_validation(self, seed): + """Check if the emodel with a given seed has been checked by Validation task. + + Reminder: the logic of validation is as follows: + if None: did not go through validation + if False: failed validation + if True: passed validation + """ + + try: + emodel = self.get_emodel(seed=seed) + except AccessPointException: + return False + + if emodel.passed_validation is True or emodel.passed_validation is False: + return True + + return False + + def is_validated(self): + """Check if enough models have been validated. + + Reminder: the logic of validation is as follows: + if None: did not go through validation + if False: failed validation + if True: passed validation + """ + + try: + emodels = self.get_emodels() + except TypeError: + return False + + n_validated = len([em for em in emodels if em.passed_validation]) + + return n_validated >= self.pipeline_settings.n_model + + def has_pipeline_settings(self): + """Returns True if pipeline settings are present on Nexus""" + + try: + _ = self.get_pipeline_settings(strict=True) + return True + except AccessPointException: + return False + + def has_fitness_calculator_configuration(self): + """Check if the fitness calculator configuration exists""" + + try: + _ = self.get_fitness_calculator_configuration() + return True + except AccessPointException: + return False + + def has_targets_configuration(self): + """Check if the target configuration exists""" + + try: + _ = self.get_targets_configuration() + return True + except AccessPointException: + return False + + def has_model_configuration(self): + """Check if the model configuration exists""" + + try: + _ = self.get_model_configuration() + return True + except AccessPointException: + return False + + def get_ProbAMPANMDA_EMS_resource(self): + """Get the ProbAMPANMDA_EMS resource from nexus.""" + resources = self.access_point.fetch( + {"type": "SynapsePhysiologyModel", "name": "ProbAMPANMDA_EMS"} + ) + if resources is None: + raise AccessPointException("SynapsePhysiologyModel ProbAMPANMDA_EMS not found") + + if len(resources) > 1: + logger.warning( + "Could not reduce the number of resources fetched down to one. " + "Keeping the 1st resource of the list." + ) + return resources[0] + + def download_ProbAMPANMDA_EMS(self): + """Download the ProbAMPANMDA_EMS mod file. + + Returns True if the mod file has been downloaded, returns False otherwise. + """ + mechanisms_directory = self.get_mechanisms_directory() + resource = self.get_ProbAMPANMDA_EMS_resource() + + mod_file_name = "ProbAMPANMDA_EMS.mod" + if os.path.isfile(str(mechanisms_directory / mod_file_name)): + return False + + filepath = self.access_point.download( + resource.id, str(mechanisms_directory), content_type="application/neuron-mod" + )[0] + + # Rename the file in case it's different from the name of the resource + filepath = pathlib.Path(filepath) + if filepath.stem != "ProbAMPANMDA_EMS": + filepath.rename(pathlib.Path(filepath.parent / mod_file_name)) + + return True + + def download_mechanisms(self, mechanisms, any_downloaded=False): + """Download the mod files if not already downloaded""" + # pylint: disable=protected-access + + mechanisms_directory = self.get_mechanisms_directory() + ontology_access_point = ontology_forge_access_point( + self.access_point.access_token, self.forge_ontology_path + ) + + for mechanism in mechanisms: + if mechanism.name in NEURON_BUILTIN_MECHANISMS: + continue + + resource = None + if mechanism.id is not None: + resource = self.access_point.forge.retrieve(mechanism.id) + if resource is not None and resource._store_metadata["_deprecated"]: + logger.info( + "Nexus resource for mechanism %s is deprecated. " + "Looking for a new resource...", + mechanism.name, + ) + resource = None + + # if could not find by id, try with filtering + if resource is None: + resource = self.fetch_and_filter_mechanism(mechanism, ontology_access_point) + + mod_file_name = f"{mechanism.name}.mod" + if os.path.isfile(str(mechanisms_directory / mod_file_name)): + continue + + filepath = self.access_point.download(resource.id, str(mechanisms_directory))[0] + any_downloaded = True + # Rename the file in case it's different from the name of the resource + filepath = pathlib.Path(filepath) + if filepath.stem != mechanism: + filepath.rename(pathlib.Path(filepath.parent / mod_file_name)) + + if any_downloaded: + previous_dir = os.getcwd() + os.chdir(pathlib.Path(mechanisms_directory.parent)) + subprocess.run("nrnivmodl mechanisms", shell=True, check=True) + os.chdir(previous_dir) + + def download_morphology(self, name=None, format_=None, id_=None): + """Download a morphology by its id if provided. If no id is given, + the function attempts to download the morphology by its name, + provided it has not already been downloaded + + Args: + name (str): name of the morphology resource + format_ (str): Optional. Can be 'asc', 'swc', or 'h5'. + Must be available in the resource. + id_ (str): id of the nexus resource + + Raises: + TypeError if id_ and name are not given + AccessPointException if resource could not be retrieved + FileNotFoundError if downloaded morphology could not be find locally + """ + + if id_ is None and name is None: + raise TypeError("In download_morphology, at least name or id_ must be given.") + + if id_ is None: + species_label = self.emodel_metadata_ontology.species["species"]["label"] + resources = self.access_point.fetch( + { + "type": "NeuronMorphology", + "name": name, + "subject": {"species": {"label": species_label}}, + } + ) + if resources is None: + raise AccessPointException(f"Could not get resource for morphology {name}") + if len(resources) == 1: + resource = resources[0] + elif len(resources) >= 2: + resource = get_curated_morphology(resources) + if resource is None: + raise AccessPointException(f"Could not get resource for morphology {name}") + + res_id = resource.id + else: + res_id = id_ + + filepath = pathlib.Path(self.access_point.download(res_id, self.download_directory)[0]) + + # Some morphologies have .h5 attached and we don't want that: + if format_: + suffix = "." + format_ + filepath = filepath.with_suffix(suffix) + # special case example: format_ is 'asc', but morph has '.ASC' format + if not filepath.is_file() and filepath.with_suffix(suffix.upper()).is_file(): + filepath = filepath.with_suffix(suffix.upper()) + elif filepath.suffix == ".h5": + for suffix in [".swc", ".asc", ".ASC"]: + if filepath.with_suffix(suffix).is_file(): + filepath = filepath.with_suffix(suffix) + break + else: + raise FileNotFoundError( + f"Could not find morphology {filepath.stem}" + f"at path {filepath.parent} with allowed suffix '.asc', '.swc' or '.ASC'." + ) + + return str(filepath) + + def download_trace(self, id_=None, id_legacy=None, name=None): + """Does not actually download the Trace since traces are already stored on Nexus""" + + for proj_traces in NEXUS_PROJECTS_TRACES: + access_point = NexusForgeAccessPoint( + project=proj_traces["project"], + organisation=proj_traces["organisation"], + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=self.access_point.forge_path, + access_token=self.access_point.access_token, + cross_bucket=True, + ) + + if id_: + resource = access_point.retrieve(id_) + elif id_legacy: + resource = access_point.retrieve(id_legacy) + elif name: + resource = access_point.fetch_one( + { + "type": "Trace", + "name": name, + "distribution": {"encodingFormat": "application/nwb"}, + }, + strict=False, + ) + else: + raise TypeError("At least id_ or name should be informed.") + + if resource: + return access_point.resource_location(resource, self.download_directory)[0] + + raise ValueError(f"No matching resource for {id_} {name}") + + def get_mechanisms_directory(self): + """Return the path to the directory containing the mechanisms for the current emodel""" + + mechanisms_directory = self.download_directory / "mechanisms" + + return mechanisms_directory.resolve() + + def load_channel_gene_expression(self, name): + """Retrieve a channel gene expression resource and read its content""" + + dataset = self.access_point.fetch_one(filters={"type": "RNASequencing", "name": name}) + + filepath = self.access_point.resource_location(dataset, self.download_directory)[0] + + df = pandas.read_csv(filepath, index_col=["me-type", "t-type", "modality"]) + + return df, filepath + + def load_ic_map(self): + """Get the ion channel/genes map from Nexus""" + + resource_ic_map = self.access_point.fetch_one( + {"type": "IonChannelMapping", "name": "icmapping"} + ) + + return self.access_point.download(resource_ic_map.id, self.download_directory)[0] + + def get_t_types(self, table_name): + """Get the list of t-types available for the present emodel""" + + df, _ = self.load_channel_gene_expression(table_name) + # replace non-alphanumeric characters with underscores in t-types from RNASeq data + df["me-type"] = df["me-type"].str.replace(r"\W", "_") + return ( + df.loc[self.emodel_metadata.emodel].index.get_level_values("t-type").unique().tolist() + ) + + def get_available_morphologies(self): + """Get the list of names of the available morphologies""" + + resources = self.access_point.fetch({"type": "NeuronMorphology"}) + + if resources: + return {r.name for r in resources} + + logger.warning("Did not find any available morphologies.") + return set() + + def get_available_mechanisms(self, filters=None): + """Get all the available mechanisms. + Optional filters can be applied to refine the search.""" + + filter = {"type": "SubCellularModelScript"} + if filters: + filter.update(filters) + resources = self.access_point.fetch(filter) + + if resources is None: + logger.warning("No SubCellularModelScript mechanisms available") + return None + + available_mechanisms = [] + for r in resources: + logger.debug("fetching %s mechanism from nexus.", r.name) + version = r.modelId if hasattr(r, "modelId") else None + temperature = ( + getattr(r.temperature, "value", r.temperature) + if hasattr(r, "temperature") + else None + ) + ljp_corrected = r.isLjpCorrected if hasattr(r, "isLjpCorrected") else None + stochastic = r.stochastic if hasattr(r, "stochastic") else None + + parameters = {} + if hasattr(r, "exposesParameter"): + exposes_parameters = r.exposesParameter + if not isinstance(exposes_parameters, list): + exposes_parameters = [exposes_parameters] + for ep in exposes_parameters: + if ep.type == "ConductanceDensity": + lower_limit = ep.lowerLimit if hasattr(ep, "lowerLimit") else None + upper_limit = ep.upperLimit if hasattr(ep, "upperLimit") else None + if hasattr(r, "mod"): + parameters[f"{ep.name}_{r.mod.suffix}"] = [ + lower_limit, + upper_limit, + ] + else: + parameters[f"{ep.name}_{r.nmodlParameters.suffix}"] = [ + lower_limit, + upper_limit, + ] + + ion_currents = [] + ionic_concentrations = [] + # technically, also adds non-specific currents to ion_currents list, + # because they are not distinguished in nexus for now, but + # the code should work nevertheless + ions = [] + if hasattr(r, "mod") and hasattr(r.mod, "ion"): + ions = r.mod.ion if isinstance(r.mod.ion, list) else [r.mod.ion] + elif hasattr(r, "ion"): + ions = r.ion if isinstance(r.ion, list) else [r.ion] + + for ion in ions: + if hasattr(ion, "label"): + ion_name = ion.label.lower() + ion_currents.append(f"i{ion_name}") + ionic_concentrations.append(f"{ion_name}i") + + mech = MechanismConfiguration( + r.name, + location=None, + stochastic=stochastic, + version=version, + temperature=temperature, + ljp_corrected=ljp_corrected, + parameters=parameters, + ion_currents=ion_currents, + ionic_concentrations=ionic_concentrations, + id=r.id, + ) + + available_mechanisms.append(mech) + + return available_mechanisms + + def get_available_traces(self, filter_species=True, filter_brain_region=False): + """Get the list of available Traces for the current species from Nexus""" + + species = None + if filter_species: + species = self.emodel_metadata_ontology.species + brain_region = None + if filter_brain_region: + brain_region = self.emodel_metadata_ontology.brain_region + + resource_traces = get_available_traces( + species=species, + brain_region=brain_region, + access_token=self.access_point.access_token, + forge_path=self.access_point.forge_path, + ) + + traces = [] + if resource_traces is None: + return traces + + for r in resource_traces: + ecodes = None + if hasattr(r, "stimulus"): + # is stimulus a list + stimuli = r.stimulus if isinstance(r.stimulus, list) else [r.stimulus] + ecodes = { + stim.stimulusType.label: {} + for stim in stimuli + if hasattr(stim.stimulusType, "label") + } + species = None + if hasattr(r, "subject") and hasattr(r.subject, "species"): + species = r.subject.species + + brain_region = None + if hasattr(r, "brainLocation"): + brain_region = r.brainLocation + + etype = None + if hasattr(r, "annotation"): + if isinstance(r.annotation, Resource): + if "e-type" in r.annotation.name.lower(): + etype = r.annotation.hasBody.label + else: + for annotation in r.annotation: + if "e-type" in annotation.name.lower(): + etype = annotation.hasBody.label + + traces.append( + TraceFile( + r.name, + filename=None, + filepath=None, + resource_id=r.id, + ecodes=ecodes, + other_metadata=None, + species=species, + brain_region=brain_region, + etype=etype, + id=r.id, + ) + ) + return traces + + def store_morphology(self, morphology_name, morphology_path, mtype=None, reconstructed=True): + payload = { + "type": [ + "NeuronMorphology", + "Dataset", + ( + "ReconstructedNeuronMorphology" + if reconstructed + else "PlaceholderNeuronMorphology" + ), + ], + "name": pathlib.Path(morphology_path).stem, + "objectOfStudy": { + "@id": "http://bbp.epfl.ch/neurosciencegraph/taxonomies/objectsofstudy/singlecells", + "label": "Single Cell", + }, + } + + if mtype: + payload["annotation"] = ( + { + "@type": ["Annotation", "nsg:MTypeAnnotation"], + "hasBody": { + "@id": "nsg:InhibitoryNeuron", + "@type": ["Mtype", "AnnotationBody"], + "label": mtype, + "prefLabel": mtype, + }, + "name": "M-type Annotation", + }, + ) + + self.access_point.register( + resource_description=payload, + distributions=[morphology_path], + ) + + def store_hocs( + self, + only_validated=False, + only_best=True, + seeds=None, + map_function=map, + new_emodel_name=None, + description=None, + output_base_dir="export_emodels_hoc", + ): + """Store hoc files on nexus. + + Args: + export_function (function): can be export_emodels_hoc or export_emodels_sonata + """ + workflow, workflow_id = self.get_emodel_workflow() + if workflow is None: + raise AccessPointException( + "No EModelWorkflow available to which the EModelScripts can be linked" + ) + + emodels = self.get_emodels() + emodels = select_emodels( + self.emodel_metadata.emodel, + emodels, + only_validated=only_validated, + only_best=only_best, + seeds=seeds, + iteration=self.emodel_metadata.iteration, + ) + + if not emodels: + logger.warning( + "No emodels selected in store_hocs. No hoc file will be registered on nexus." + ) + + hold_key = "SearchHoldingCurrent.soma.v.bpo_holding_current" + thres_key = "SearchThresholdCurrent.soma.v.bpo_threshold_current" + + # maybe use map here? + for emodel in emodels: + if new_emodel_name is not None: + emodel.emodel_metadata.emodel = new_emodel_name + + # in case hocs have been created with the local output path + copy_hocs_to_new_output_path(emodel, output_base_dir) + + output_path = get_output_path( + emodel, output_base_dir=output_base_dir, use_allen_notation=True + ) + + hoc_file_path = pathlib.Path(get_hoc_file_path(output_path)).resolve() + if not hoc_file_path.is_file(): + logger.warning( + "Could not find the hoc file for %s. " + "Will not register EModelScript on nexus.", + emodel.emodel_metadata.emodel, + ) + continue + + currents = None + if emodel.features is not None: + if hold_key in emodel.features and thres_key in emodel.features: + currents = { + "holding": emodel.features[hold_key], + "threshold": emodel.features[thres_key], + } + + emodelscript = EModelScript(str(hoc_file_path), emodel.seed, workflow_id) + self.store_object( + emodelscript, + seed=emodel.seed, + description=description, + currents=currents, + ) + # wait for the object to be uploaded and fetchable + time.sleep(self.sleep_time) + + # fetch just uploaded emodelscript resource to get its id + type_ = "EModelScript" + filters = {"type": type_, "seed": emodel.seed} + filters.update(self.emodel_metadata_ontology.filters_for_resource()) + filters_legacy = {"type": type_, "seed": emodel.seed} + filters_legacy.update(self.emodel_metadata_ontology.filters_for_resource_legacy()) + resource = self.access_point.fetch_one(filters, filters_legacy, strict=True) + modelscript_id = resource.id + workflow.add_emodel_script_id(modelscript_id) + + time.sleep(self.sleep_time) + self.store_or_update_emodel_workflow(workflow) + + def store_emodels_hoc( + self, + only_validated=False, + only_best=True, + seeds=None, + map_function=map, + new_emodel_name=None, + description=None, + ): + self.store_hocs( + only_validated, + only_best, + seeds, + map_function, + new_emodel_name, + description, + "export_emodels_hoc", + ) + + def store_emodels_sonata( + self, + only_validated=False, + only_best=True, + seeds=None, + map_function=map, + new_emodel_name=None, + description=None, + ): + self.store_hocs( + only_validated, + only_best, + seeds, + map_function, + new_emodel_name, + description, + "export_emodels_sonata", + ) + + def get_hoc(self, seed=None): + """Get the EModelScript resource""" + metadata = self.emodel_metadata_ontology.filters_for_resource() + legacy_metadata = self.emodel_metadata_ontology.filters_for_resource_legacy() + if seed is not None: + metadata["seed"] = int(seed) + legacy_metadata["seed"] = int(seed) + + hoc = self.access_point.nexus_to_object( + type_="EModelScript", + metadata=metadata, + download_directory=self.download_directory, + legacy_metadata=legacy_metadata, + ) + return hoc + + def sonata_exists(self, seed): + """Returns True if the sonata hoc file has been exported""" + try: + _ = self.get_hoc(seed) + return True + except AccessPointException: + return False diff --git a/bluepyemodel/data/utils.py b/bluepyemodel/data/utils.py index 9a1ff11f..05eb677c 100644 --- a/bluepyemodel/data/utils.py +++ b/bluepyemodel/data/utils.py @@ -1,7 +1,7 @@ """Data utils""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/__init__.py b/bluepyemodel/ecode/__init__.py index 14627dfb..c6c949ab 100644 --- a/bluepyemodel/ecode/__init__.py +++ b/bluepyemodel/ecode/__init__.py @@ -1,7 +1,7 @@ """eCode init script""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/apwaveform.py b/bluepyemodel/ecode/apwaveform.py index 4ce8d197..2289f11d 100644 --- a/bluepyemodel/ecode/apwaveform.py +++ b/bluepyemodel/ecode/apwaveform.py @@ -1,7 +1,7 @@ """APWaveform stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/comb.py b/bluepyemodel/ecode/comb.py index f5d23d7b..3d64ea82 100644 --- a/bluepyemodel/ecode/comb.py +++ b/bluepyemodel/ecode/comb.py @@ -1,7 +1,7 @@ """Comb stimulus class.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/customfromfile.py b/bluepyemodel/ecode/customfromfile.py index 2a3100c9..c6f36305 100644 --- a/bluepyemodel/ecode/customfromfile.py +++ b/bluepyemodel/ecode/customfromfile.py @@ -1,7 +1,7 @@ """CustomFromFile stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/dehyperpol.py b/bluepyemodel/ecode/dehyperpol.py index 3e33a307..3a5368cc 100644 --- a/bluepyemodel/ecode/dehyperpol.py +++ b/bluepyemodel/ecode/dehyperpol.py @@ -1,7 +1,7 @@ """DeHyperpol stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/dendrite.py b/bluepyemodel/ecode/dendrite.py index 93bf8983..b36085b3 100644 --- a/bluepyemodel/ecode/dendrite.py +++ b/bluepyemodel/ecode/dendrite.py @@ -1,7 +1,7 @@ """Ecode for dendrite specific protocols, such as synaptic input, dendritic steps, or BAC.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/firepattern.py b/bluepyemodel/ecode/firepattern.py index f0d8ee5e..d4f5afb3 100644 --- a/bluepyemodel/ecode/firepattern.py +++ b/bluepyemodel/ecode/firepattern.py @@ -1,7 +1,7 @@ """FirePattern stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/hyperdepol.py b/bluepyemodel/ecode/hyperdepol.py index 90011532..c1412360 100644 --- a/bluepyemodel/ecode/hyperdepol.py +++ b/bluepyemodel/ecode/hyperdepol.py @@ -1,7 +1,7 @@ """HyperDepol stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/idrest.py b/bluepyemodel/ecode/idrest.py index da143b19..1740aa82 100644 --- a/bluepyemodel/ecode/idrest.py +++ b/bluepyemodel/ecode/idrest.py @@ -1,7 +1,7 @@ """IDrest stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/iv.py b/bluepyemodel/ecode/iv.py index 6ef628b7..f3718577 100644 --- a/bluepyemodel/ecode/iv.py +++ b/bluepyemodel/ecode/iv.py @@ -1,7 +1,7 @@ """IV stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/negcheops.py b/bluepyemodel/ecode/negcheops.py index 212ff131..ed363b35 100644 --- a/bluepyemodel/ecode/negcheops.py +++ b/bluepyemodel/ecode/negcheops.py @@ -1,7 +1,7 @@ """NegCheops stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/noise.py b/bluepyemodel/ecode/noise.py index 8799b8d1..06df0a95 100644 --- a/bluepyemodel/ecode/noise.py +++ b/bluepyemodel/ecode/noise.py @@ -1,7 +1,7 @@ """Noise stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/noiseou3.py b/bluepyemodel/ecode/noiseou3.py index 55569f43..7120f75f 100644 --- a/bluepyemodel/ecode/noiseou3.py +++ b/bluepyemodel/ecode/noiseou3.py @@ -1,7 +1,7 @@ """Noise stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/poscheops.py b/bluepyemodel/ecode/poscheops.py index 1a493b4e..fd0bc702 100644 --- a/bluepyemodel/ecode/poscheops.py +++ b/bluepyemodel/ecode/poscheops.py @@ -1,7 +1,7 @@ """PosCheops stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/probampanmda_ems.py b/bluepyemodel/ecode/probampanmda_ems.py index 3f410f15..2e54b0fb 100644 --- a/bluepyemodel/ecode/probampanmda_ems.py +++ b/bluepyemodel/ecode/probampanmda_ems.py @@ -1,7 +1,7 @@ """ProbAMPANMDA_EMS class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/ramp.py b/bluepyemodel/ecode/ramp.py index 262bf11c..aa80bd45 100644 --- a/bluepyemodel/ecode/ramp.py +++ b/bluepyemodel/ecode/ramp.py @@ -1,7 +1,7 @@ """Ramp stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/random_square_inputs.py b/bluepyemodel/ecode/random_square_inputs.py index 9ca41e92..7cb4e6ad 100644 --- a/bluepyemodel/ecode/random_square_inputs.py +++ b/bluepyemodel/ecode/random_square_inputs.py @@ -1,7 +1,7 @@ """IDrest stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/sahp.py b/bluepyemodel/ecode/sahp.py index c2058c5c..4e3100d0 100644 --- a/bluepyemodel/ecode/sahp.py +++ b/bluepyemodel/ecode/sahp.py @@ -1,7 +1,7 @@ """sAHP stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/sinespec.py b/bluepyemodel/ecode/sinespec.py index d94cc262..5f09e5a8 100644 --- a/bluepyemodel/ecode/sinespec.py +++ b/bluepyemodel/ecode/sinespec.py @@ -1,7 +1,7 @@ """SineSpec stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/spikerec.py b/bluepyemodel/ecode/spikerec.py index c157ee24..3b37a1ee 100644 --- a/bluepyemodel/ecode/spikerec.py +++ b/bluepyemodel/ecode/spikerec.py @@ -1,7 +1,7 @@ """SpikeRec stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/square.py b/bluepyemodel/ecode/square.py index 8f957baf..9b573813 100644 --- a/bluepyemodel/ecode/square.py +++ b/bluepyemodel/ecode/square.py @@ -1,7 +1,7 @@ """BPEM_stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/stimulus.py b/bluepyemodel/ecode/stimulus.py index ee6fc04b..194b1643 100644 --- a/bluepyemodel/ecode/stimulus.py +++ b/bluepyemodel/ecode/stimulus.py @@ -1,7 +1,7 @@ """BPEM_stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/subwhitenoise.py b/bluepyemodel/ecode/subwhitenoise.py index 2dfcbc17..55105584 100644 --- a/bluepyemodel/ecode/subwhitenoise.py +++ b/bluepyemodel/ecode/subwhitenoise.py @@ -1,7 +1,7 @@ """SubWhiteNoise stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/thresholdaddition.py b/bluepyemodel/ecode/thresholdaddition.py index 236adae0..41e61e3d 100644 --- a/bluepyemodel/ecode/thresholdaddition.py +++ b/bluepyemodel/ecode/thresholdaddition.py @@ -1,7 +1,7 @@ """IDrest stimulus class""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/ecode/whitenoise.py b/bluepyemodel/ecode/whitenoise.py index 11842855..169829e0 100644 --- a/bluepyemodel/ecode/whitenoise.py +++ b/bluepyemodel/ecode/whitenoise.py @@ -1,7 +1,7 @@ """Noise stimulus class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/__init__.py b/bluepyemodel/efeatures_extraction/__init__.py index 6a4668e6..f326bb85 100644 --- a/bluepyemodel/efeatures_extraction/__init__.py +++ b/bluepyemodel/efeatures_extraction/__init__.py @@ -1,7 +1,7 @@ """Electrophysiological features extraction module.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/auto_targets.py b/bluepyemodel/efeatures_extraction/auto_targets.py index 2693788c..53c5f285 100644 --- a/bluepyemodel/efeatures_extraction/auto_targets.py +++ b/bluepyemodel/efeatures_extraction/auto_targets.py @@ -1,7 +1,7 @@ """Auto-targets-related functions.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/efeatures_extraction.py b/bluepyemodel/efeatures_extraction/efeatures_extraction.py index 36e53c7b..f3f60868 100644 --- a/bluepyemodel/efeatures_extraction/efeatures_extraction.py +++ b/bluepyemodel/efeatures_extraction/efeatures_extraction.py @@ -1,7 +1,7 @@ """Efeatures extraction functions""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/target.py b/bluepyemodel/efeatures_extraction/target.py index 34a3e0a6..98d4c592 100644 --- a/bluepyemodel/efeatures_extraction/target.py +++ b/bluepyemodel/efeatures_extraction/target.py @@ -1,7 +1,7 @@ """Target""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/targets_configuration.py b/bluepyemodel/efeatures_extraction/targets_configuration.py index bd68307a..7e64ca0a 100644 --- a/bluepyemodel/efeatures_extraction/targets_configuration.py +++ b/bluepyemodel/efeatures_extraction/targets_configuration.py @@ -1,7 +1,7 @@ """TargetsConfiguration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/targets_configurator.py b/bluepyemodel/efeatures_extraction/targets_configurator.py index 7f7cd57f..a77ebd83 100644 --- a/bluepyemodel/efeatures_extraction/targets_configurator.py +++ b/bluepyemodel/efeatures_extraction/targets_configurator.py @@ -1,7 +1,7 @@ """Targets Configurator""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/efeatures_extraction/trace_file.py b/bluepyemodel/efeatures_extraction/trace_file.py index a32d3ebe..5cf61845 100644 --- a/bluepyemodel/efeatures_extraction/trace_file.py +++ b/bluepyemodel/efeatures_extraction/trace_file.py @@ -1,7 +1,7 @@ """TraceFile""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/__init__.py b/bluepyemodel/emodel_pipeline/__init__.py index 59315a83..01bf878e 100644 --- a/bluepyemodel/emodel_pipeline/__init__.py +++ b/bluepyemodel/emodel_pipeline/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/emodel.py b/bluepyemodel/emodel_pipeline/emodel.py index 2be9e971..3f7cf770 100644 --- a/bluepyemodel/emodel_pipeline/emodel.py +++ b/bluepyemodel/emodel_pipeline/emodel.py @@ -1,7 +1,7 @@ """EModel class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/emodel_metadata.py b/bluepyemodel/emodel_pipeline/emodel_metadata.py index 88277cf8..96edeba5 100644 --- a/bluepyemodel/emodel_pipeline/emodel_metadata.py +++ b/bluepyemodel/emodel_pipeline/emodel_metadata.py @@ -1,7 +1,7 @@ """EModelMetadata class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/emodel_pipeline.py b/bluepyemodel/emodel_pipeline/emodel_pipeline.py index c8290ac2..c5a8410b 100644 --- a/bluepyemodel/emodel_pipeline/emodel_pipeline.py +++ b/bluepyemodel/emodel_pipeline/emodel_pipeline.py @@ -1,7 +1,7 @@ """EModel_pipeline class.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -19,6 +19,7 @@ import glob import logging import pathlib +import warnings from bluepyemodel.access_point import get_access_point from bluepyemodel.efeatures_extraction.efeatures_extraction import extract_save_features_protocols @@ -57,7 +58,12 @@ def __init__( recipes_path=None, use_ipyparallel=None, use_multiprocessing=None, - data_access_point=None, + data_access_point="local", + nexus_endpoint="staging", + forge_path=None, + forge_ontology_path=None, + nexus_organisation=None, + nexus_project=None, ): """Initializes the EModel_pipeline. @@ -94,6 +100,16 @@ def __init__( synapse_class (str): name of the synapse class of the e-model, has to be "EXC", "INH". Not used at the moment. layer (str): layer of the e-model. To be depracted. + forge_path (str): path to the .yml used to connect to Nexus Forge. This is only needed + if you wish to customize the connection to Nexus. If not provided, + a default .yml file will be used. + forge_ontology_path (str): path to the .yml used for the ontology in Nexus Forge + if not provided, forge_path will be used. + nexus_organisation (str): name of the Nexus organisation in which the project is + located. + nexus_project (str): name of the Nexus project to which the forge will connect to + retrieve the data. + nexus_endpoint (str): Nexus endpoint address, e.g., ``https://bbp.epfl.ch/nexus/v1``. recipes_path (str): path of the recipes.json configuration file.This configuration file is the main file required when using the access point of type "local". It is expected to be a json file containing a dictionary whose keys are the names @@ -104,7 +120,9 @@ def __init__( the e-model building pipeline be based on ipyparallel. use_multiprocessing (bool): should the parallelization map used for the different steps of the e-model building pipeline be based on multiprocessing. - data_access_point (str): Used for legacy purposes only + data_access_point (str): name of the access_point used to access the data, + can be "nexus" or "local". + """ # pylint: disable=too-many-arguments @@ -121,13 +139,12 @@ def __init__( else: self.mapper = map - endpoint = None - - if data_access_point is not None and data_access_point != "local": - raise ValueError( - "Attempted to set a legacy variable. " - "This variable should not be modified in new code." - ) + if nexus_endpoint == "prod": + endpoint = "https://bbp.epfl.ch/nexus/v1" + elif nexus_endpoint == "staging": + endpoint = "https://staging.nexus.ocp.bbp.epfl.ch/v1" + else: + endpoint = nexus_endpoint self.access_point = get_access_point( emodel=emodel, @@ -140,10 +157,14 @@ def __init__( morph_class=morph_class, synapse_class=synapse_class, layer=layer, - access_point="local", recipes_path=recipes_path, final_path="final.json", + organisation=nexus_organisation, + project=nexus_project, endpoint=endpoint, + access_point=data_access_point, + forge_path=forge_path, + forge_ontology_path=forge_ontology_path, ) def configure_model( @@ -321,6 +342,99 @@ def summarize(self): print(self.access_point) +class EModel_pipeline_nexus(EModel_pipeline): + """The EModel_pipeline_nexus class is there to allow the execution of the steps + of the e-model building pipeline for Nexus using python (as opposed to the Luigi workflow). + This class is deprecated and maintained for legacy purposes. + """ + + def __init__( + self, + emodel, + etype=None, + ttype=None, + mtype=None, + species=None, + brain_region=None, + iteration_tag=None, + morph_class=None, + synapse_class=None, + layer=None, + forge_path=None, + forge_ontology_path=None, + nexus_organisation=None, + nexus_project=None, + nexus_endpoint="staging", + use_ipyparallel=None, + use_multiprocessing=None, + ): + """Initializes the Nexus EModel_pipeline. + + Args: + emodel (str): name of the emodel. + etype (str): name of the e-type of the e-model. Used as an identifier for the e-model. + ttype (str): name of the t-type of the e-model. Used as an identifier for the e-model. + This argument is required when using the gene expression or IC selector. + mtype (str): name of the m-type of the e-model. Used as an identifier for the e-model. + species (str): name of the species of the e-model. Used as an identifier for the + e-model. + brain_region (str): name of the brain region of the e-model. Used as an identifier for + the e-model. + iteration_tag (str): tag associated to the current run. Used as an identifier for the + e-model. + morph_class (str): name of the morphology class, has to be "PYR", "INT". To be + depracted. + synapse_class (str): name of the synapse class of the e-model, has to be "EXC", "INH". + Not used at the moment. + layer (str): layer of the e-model. To be depracted. + forge_path (str): path to the .yml used to connect to Nexus Forge. This is only needed + if you wish to customize the connection to Nexus. If not provided, + a default .yml file will be used. + forge_ontology_path (str): path to the .yml used for the ontology in Nexus Forge + if not provided, forge_path will be used. + nexus_organisation (str): name of the Nexus organisation in which the project is + located. + nexus_project (str): name of the Nexus project to which the forge will connect to + retrieve the data. + nexus_endpoint (str): Nexus endpoint address, e.g., ``https://bbp.epfl.ch/nexus/v1``. + use_ipyparallel (bool): should the parallelization map used for the different steps of + the e-model building pipeline be based on ipyparallel. + use_multiprocessing (bool): should the parallelization map used for the different steps + of the e-model building pipeline be based on multiprocessing. + """ + + # pylint: disable=too-many-arguments + + warnings.warn( + "EModel_pipeline_nexus is deprecated." + "Please use EModel_pipeline with data_access_point='nexus' instead.", + DeprecationWarning, + stacklevel=2, + ) + + super().__init__( + emodel=emodel, + etype=etype, + ttype=ttype, + mtype=mtype, + species=species, + brain_region=brain_region, + iteration_tag=iteration_tag, + morph_class=morph_class, + synapse_class=synapse_class, + layer=layer, + recipes_path=None, + use_ipyparallel=use_ipyparallel, + use_multiprocessing=use_multiprocessing, + data_access_point="nexus", + nexus_endpoint=nexus_endpoint, + forge_path=forge_path, + forge_ontology_path=forge_ontology_path, + nexus_organisation=nexus_organisation, + nexus_project=nexus_project, + ) + + def sanitize_gitignore(): """In order to avoid git issue when archiving the current working directory, adds the following lines to .gitignore: 'run/', 'checkpoints/', 'figures/', diff --git a/bluepyemodel/emodel_pipeline/emodel_script.py b/bluepyemodel/emodel_pipeline/emodel_script.py index 8fe31af6..6d3b3093 100644 --- a/bluepyemodel/emodel_pipeline/emodel_script.py +++ b/bluepyemodel/emodel_pipeline/emodel_script.py @@ -1,7 +1,7 @@ """EModelScript class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/emodel_settings.py b/bluepyemodel/emodel_pipeline/emodel_settings.py index 192fa2ae..6cabd0dc 100644 --- a/bluepyemodel/emodel_pipeline/emodel_settings.py +++ b/bluepyemodel/emodel_pipeline/emodel_settings.py @@ -1,7 +1,7 @@ """EModelPipelineSettings class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/emodel_workflow.py b/bluepyemodel/emodel_pipeline/emodel_workflow.py index 285d486c..017e8673 100644 --- a/bluepyemodel/emodel_pipeline/emodel_workflow.py +++ b/bluepyemodel/emodel_pipeline/emodel_workflow.py @@ -1,7 +1,7 @@ """EModelWorkflow class""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/memodel.py b/bluepyemodel/emodel_pipeline/memodel.py index 3af3ea05..d3b85a58 100644 --- a/bluepyemodel/emodel_pipeline/memodel.py +++ b/bluepyemodel/emodel_pipeline/memodel.py @@ -1,7 +1,7 @@ """MEModel class""" """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/emodel_pipeline/plotting.py b/bluepyemodel/emodel_pipeline/plotting.py index 67c5c930..6a34eea3 100644 --- a/bluepyemodel/emodel_pipeline/plotting.py +++ b/bluepyemodel/emodel_pipeline/plotting.py @@ -1,7 +1,7 @@ """Functions related to the plotting of the e-models.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/__init__.py b/bluepyemodel/evaluation/__init__.py index f6c596b3..f3395890 100644 --- a/bluepyemodel/evaluation/__init__.py +++ b/bluepyemodel/evaluation/__init__.py @@ -6,7 +6,7 @@ """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/efeature_configuration.py b/bluepyemodel/evaluation/efeature_configuration.py index 67a9f541..59075b91 100644 --- a/bluepyemodel/evaluation/efeature_configuration.py +++ b/bluepyemodel/evaluation/efeature_configuration.py @@ -1,7 +1,7 @@ """EFeatureConfiguration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/efel_feature_bpem.py b/bluepyemodel/evaluation/efel_feature_bpem.py index 89786ef7..7dd3b084 100644 --- a/bluepyemodel/evaluation/efel_feature_bpem.py +++ b/bluepyemodel/evaluation/efel_feature_bpem.py @@ -1,7 +1,7 @@ """Class eFELFeatureBPEM""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/evaluation.py b/bluepyemodel/evaluation/evaluation.py index e22f94a3..45ee452b 100644 --- a/bluepyemodel/evaluation/evaluation.py +++ b/bluepyemodel/evaluation/evaluation.py @@ -1,7 +1,7 @@ """ Emodels evaluation functions """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/evaluator.py b/bluepyemodel/evaluation/evaluator.py index ca4708a6..affcdeae 100644 --- a/bluepyemodel/evaluation/evaluator.py +++ b/bluepyemodel/evaluation/evaluator.py @@ -1,7 +1,7 @@ """Evaluator module.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/fitness_calculator_configuration.py b/bluepyemodel/evaluation/fitness_calculator_configuration.py index b57f247d..b700cacc 100644 --- a/bluepyemodel/evaluation/fitness_calculator_configuration.py +++ b/bluepyemodel/evaluation/fitness_calculator_configuration.py @@ -1,7 +1,7 @@ """FitnessCalculatorConfiguration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/modifiers.py b/bluepyemodel/evaluation/modifiers.py index a7bf8333..086371ba 100644 --- a/bluepyemodel/evaluation/modifiers.py +++ b/bluepyemodel/evaluation/modifiers.py @@ -1,7 +1,7 @@ """Functions for morphology modifications in evaluator.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/protocol_configuration.py b/bluepyemodel/evaluation/protocol_configuration.py index 7870283a..d89d0ffb 100644 --- a/bluepyemodel/evaluation/protocol_configuration.py +++ b/bluepyemodel/evaluation/protocol_configuration.py @@ -1,7 +1,7 @@ """ProtocolConfiguration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/protocols.py b/bluepyemodel/evaluation/protocols.py index a32094f9..b3d5a720 100644 --- a/bluepyemodel/evaluation/protocols.py +++ b/bluepyemodel/evaluation/protocols.py @@ -1,7 +1,7 @@ """Module with protocol classes.""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/recordings.py b/bluepyemodel/evaluation/recordings.py index b4362b98..e7209049 100644 --- a/bluepyemodel/evaluation/recordings.py +++ b/bluepyemodel/evaluation/recordings.py @@ -1,7 +1,7 @@ """Module with recording classes and functions.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/evaluation/utils.py b/bluepyemodel/evaluation/utils.py index 44836f54..1f0c5c91 100644 --- a/bluepyemodel/evaluation/utils.py +++ b/bluepyemodel/evaluation/utils.py @@ -1,7 +1,7 @@ """Utility module for evaluation.""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/export_emodel/__init__.py b/bluepyemodel/export_emodel/__init__.py index 59315a83..01bf878e 100644 --- a/bluepyemodel/export_emodel/__init__.py +++ b/bluepyemodel/export_emodel/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/export_emodel/export_emodel.py b/bluepyemodel/export_emodel/export_emodel.py index 5893bd22..ff5cf9f9 100644 --- a/bluepyemodel/export_emodel/export_emodel.py +++ b/bluepyemodel/export_emodel/export_emodel.py @@ -1,7 +1,7 @@ """Export the emodels in the SONATA format""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ import os import pathlib import shutil +import time import h5py @@ -29,6 +30,8 @@ from bluepyemodel.export_emodel.utils import get_output_path from bluepyemodel.export_emodel.utils import select_emodels +# pylint: disable=too-many-locals + logger = logging.getLogger(__name__) @@ -242,3 +245,141 @@ def export_emodels_hoc( if not cell_model.morphology.morph_modifiers: # Turn [] into None cell_model.morphology.morph_modifiers = None _export_emodel_hoc(cell_model, mo, output_dir=None, new_emodel_name=new_emodel_name) + + +def export_emodels_nexus( + local_access_point, + nexus_organisation, + nexus_project, + nexus_endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + forge_ontology_path=None, + access_token=None, + only_validated=False, + only_best=True, + seeds=None, + description=None, + sleep_time=10, + sonata=True, +): + """Transfer e-models from the LocalAccessPoint to a Nexus project + + Args: + local_access_point (LocalAccessPoint): The local access point containing the e-models. + nexus_organisation (str): The Nexus organisation to which the e-models will be transferred. + nexus_project (str): The Nexus project to which the e-models will be transferred. + nexus_endpoint (str, optional): The Nexus endpoint. + Defaults to "https://bbp.epfl.ch/nexus/v1". + forge_path (str, optional): The path to the forge. + forge_ontology_path (str, optional): The path to the forge ontology. + access_token (str, optional): The access token for Nexus. + only_validated (bool, optional): If True, only validated e-models will be transferred. + only_best (bool, optional): If True, only the best e-models will be transferred. + seeds (list, optional): The chosen seeds to export. + description (str, optional): Optional description to add to the resources in Nexus. + sleep_time (int, optional): time to wait between two Nexus requests + (in case of slow indexing). + sonata (bool, optional): Determines the format for registering e-models. + If True (default), uses Sonata hoc format. Otherwise, uses NEURON hoc format. + + Returns: + None + """ + + from bluepyemodel.access_point.nexus import NexusAccessPoint + + emodels = local_access_point.get_emodels() + emodels = select_emodels( + local_access_point.emodel_metadata.emodel, + emodels, + only_validated=only_validated, + only_best=only_best, + seeds=seeds, + ) + if not emodels: + return + + metadata = vars(local_access_point.emodel_metadata) + iteration = metadata.pop("iteration") + metadata.pop("allen_notation") + nexus_access_point = NexusAccessPoint( + **metadata, + iteration_tag=iteration, + project=nexus_project, + organisation=nexus_organisation, + endpoint=nexus_endpoint, + access_token=access_token, + forge_path=forge_path, + forge_ontology_path=forge_ontology_path, + sleep_time=sleep_time, + ) + + pipeline_settings = local_access_point.pipeline_settings + fitness_configuration = local_access_point.get_fitness_calculator_configuration() + model_configuration = local_access_point.get_model_configuration() + targets_configuration = local_access_point.get_targets_configuration() + + # Register the resources + logger.info("Exporting the emodel %s to Nexus...", local_access_point.emodel_metadata.emodel) + logger.info("Registering EModelPipelineSettings...") + nexus_access_point.store_pipeline_settings(pipeline_settings) + + logger.info("Registering ExtractionTargetsConfiguration...") + # Set local filepath to None to avoid discrepancies between local and Nexus paths + for file in targets_configuration.files: + file.filepath = None + nexus_access_point.store_targets_configuration(targets_configuration) + + logger.info("Registering EModelConfiguration...") + # Remove unused local data from the model configuration before uploading to Nexus + model_configuration.morphology.path = None + nexus_access_point.store_model_configuration(model_configuration) + + logger.info("Registering EModelWorkflow...") + filters = {"type": "EModelWorkflow", "eModel": metadata["emodel"], "iteration": iteration} + filters_legacy = { + "type": "EModelWorkflow", + "emodel": metadata["emodel"], + "iteration": iteration, + } + nexus_access_point.access_point.deprecate(filters, filters_legacy) + time.sleep(sleep_time) + emw = nexus_access_point.create_emodel_workflow(state="done") + nexus_access_point.store_or_update_emodel_workflow(emw) + + logger.info("Registering FitnessCalculatorConfiguration...") + time.sleep(sleep_time) + nexus_access_point.store_fitness_calculator_configuration(fitness_configuration) + + for mo in emodels: + time.sleep(sleep_time) + mo.emodel_metadata.allen_notation = nexus_access_point.emodel_metadata.allen_notation + mo.copy_pdf_dependencies_to_new_path(seed=mo.seed) + logger.info("Registering EModel %s...", mo.emodel_metadata.emodel) + nexus_access_point.store_emodel(mo, description=description) + + time.sleep(sleep_time) + if sonata: + logger.info( + "Registering EModelScript (in sonata hoc format with threshold_current and " + "holding_current in node.h5 file) for circuit building using neurodamus..." + ) + nexus_access_point.store_emodels_sonata( + only_best=only_best, + only_validated=only_validated, + seeds=seeds, + description=description, + ) + else: + logger.info("Registering EModelScript (in hoc format to run e-model using NEURON)...") + nexus_access_point.store_emodels_hoc( + only_best=only_best, + only_validated=only_validated, + seeds=seeds, + description=description, + ) + + logger.info( + "Exporting the emodel %s to Nexus done.", + local_access_point.emodel_metadata.emodel, + ) diff --git a/bluepyemodel/export_emodel/utils.py b/bluepyemodel/export_emodel/utils.py index ec4a6801..4703a411 100644 --- a/bluepyemodel/export_emodel/utils.py +++ b/bluepyemodel/export_emodel/utils.py @@ -1,7 +1,7 @@ """Export the emodels in the SONATA format""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/__init__.py b/bluepyemodel/icselector/__init__.py index 5067a6d3..c1b99c2b 100644 --- a/bluepyemodel/icselector/__init__.py +++ b/bluepyemodel/icselector/__init__.py @@ -1,7 +1,7 @@ """ Package root """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/icselector.py b/bluepyemodel/icselector/icselector.py index 5ebe2e2c..1a852edf 100644 --- a/bluepyemodel/icselector/icselector.py +++ b/bluepyemodel/icselector/icselector.py @@ -6,7 +6,7 @@ """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/modules/configuration.py b/bluepyemodel/icselector/modules/configuration.py index 0357282d..3001ea03 100644 --- a/bluepyemodel/icselector/modules/configuration.py +++ b/bluepyemodel/icselector/modules/configuration.py @@ -1,7 +1,7 @@ """Methods to handle cell model configuration.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/modules/distribution.py b/bluepyemodel/icselector/modules/distribution.py index c7cf18be..389e192e 100644 --- a/bluepyemodel/icselector/modules/distribution.py +++ b/bluepyemodel/icselector/modules/distribution.py @@ -1,7 +1,7 @@ """Mechanism class corresponding to mechanisms fields in the icmapping file.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/modules/gene_selector.py b/bluepyemodel/icselector/modules/gene_selector.py index 7dcf822e..3a8f4096 100644 --- a/bluepyemodel/icselector/modules/gene_selector.py +++ b/bluepyemodel/icselector/modules/gene_selector.py @@ -1,7 +1,7 @@ """Methods for selecting genes associated with a given me- and t-type""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/modules/mechanism.py b/bluepyemodel/icselector/modules/mechanism.py index 5cde0df4..7801ec19 100644 --- a/bluepyemodel/icselector/modules/mechanism.py +++ b/bluepyemodel/icselector/modules/mechanism.py @@ -1,7 +1,7 @@ """Mechanism class corresponding to mechanisms fields in the icmapping file.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/modules/model_selector.py b/bluepyemodel/icselector/modules/model_selector.py index 676a4b27..93d100f8 100644 --- a/bluepyemodel/icselector/modules/model_selector.py +++ b/bluepyemodel/icselector/modules/model_selector.py @@ -1,7 +1,7 @@ """Model selector selects NEURON mechanisms for cell model configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/icselector/version.py b/bluepyemodel/icselector/version.py index f67508ae..937c83c0 100644 --- a/bluepyemodel/icselector/version.py +++ b/bluepyemodel/icselector/version.py @@ -1,7 +1,7 @@ """ Package version """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/__init__.py b/bluepyemodel/model/__init__.py index d188ec12..f0c3d587 100644 --- a/bluepyemodel/model/__init__.py +++ b/bluepyemodel/model/__init__.py @@ -1,7 +1,7 @@ """Neuron model module""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/distribution_configuration.py b/bluepyemodel/model/distribution_configuration.py index 0255bc48..6aafbfaf 100644 --- a/bluepyemodel/model/distribution_configuration.py +++ b/bluepyemodel/model/distribution_configuration.py @@ -1,7 +1,7 @@ """Distribution Configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/mechanism_configuration.py b/bluepyemodel/model/mechanism_configuration.py index f6ac64ed..439bbff9 100644 --- a/bluepyemodel/model/mechanism_configuration.py +++ b/bluepyemodel/model/mechanism_configuration.py @@ -1,7 +1,7 @@ """Mechanism Configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/model.py b/bluepyemodel/model/model.py index f04e86d2..1323b168 100644 --- a/bluepyemodel/model/model.py +++ b/bluepyemodel/model/model.py @@ -1,7 +1,7 @@ """Cell model creation.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/model_configuration.py b/bluepyemodel/model/model_configuration.py index 5ba2f771..383d54b2 100644 --- a/bluepyemodel/model/model_configuration.py +++ b/bluepyemodel/model/model_configuration.py @@ -1,7 +1,7 @@ """Model configuration related functions""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/model_configurator.py b/bluepyemodel/model/model_configurator.py index d6269252..416fa901 100644 --- a/bluepyemodel/model/model_configurator.py +++ b/bluepyemodel/model/model_configurator.py @@ -1,7 +1,7 @@ """Model Configurator""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/morphology_configuration.py b/bluepyemodel/model/morphology_configuration.py index b4f333cd..b06839de 100644 --- a/bluepyemodel/model/morphology_configuration.py +++ b/bluepyemodel/model/morphology_configuration.py @@ -1,7 +1,7 @@ """Morphology Configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/morphology_utils.py b/bluepyemodel/model/morphology_utils.py index ac08edd6..afd84e09 100644 --- a/bluepyemodel/model/morphology_utils.py +++ b/bluepyemodel/model/morphology_utils.py @@ -1,7 +1,7 @@ """Morphology utils.""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/neuron_model_configuration.py b/bluepyemodel/model/neuron_model_configuration.py index 1804b714..59de6ff3 100644 --- a/bluepyemodel/model/neuron_model_configuration.py +++ b/bluepyemodel/model/neuron_model_configuration.py @@ -1,7 +1,7 @@ """Neuron Model Configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/parameter_configuration.py b/bluepyemodel/model/parameter_configuration.py index 655ef4fa..9367748b 100644 --- a/bluepyemodel/model/parameter_configuration.py +++ b/bluepyemodel/model/parameter_configuration.py @@ -1,7 +1,7 @@ """Parameter Configuration""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/model/utils.py b/bluepyemodel/model/utils.py index 66812514..50dce54c 100644 --- a/bluepyemodel/model/utils.py +++ b/bluepyemodel/model/utils.py @@ -1,7 +1,7 @@ """Utils""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/optimisation/__init__.py b/bluepyemodel/optimisation/__init__.py index 4bf3e6ce..d5955d17 100644 --- a/bluepyemodel/optimisation/__init__.py +++ b/bluepyemodel/optimisation/__init__.py @@ -1,7 +1,7 @@ """Electrical model optimisation module.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/optimisation/optimisation.py b/bluepyemodel/optimisation/optimisation.py index 90071692..b97f47bf 100644 --- a/bluepyemodel/optimisation/optimisation.py +++ b/bluepyemodel/optimisation/optimisation.py @@ -1,7 +1,7 @@ """Optimisation function""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tasks/__init__.py b/bluepyemodel/tasks/__init__.py index 40bc6151..edbdef8e 100644 --- a/bluepyemodel/tasks/__init__.py +++ b/bluepyemodel/tasks/__init__.py @@ -1,7 +1,7 @@ """Module with luigi tasks.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tasks/config.py b/bluepyemodel/tasks/config.py index f267e579..b8bbf48a 100644 --- a/bluepyemodel/tasks/config.py +++ b/bluepyemodel/tasks/config.py @@ -1,7 +1,7 @@ """Luigi config classes.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tasks/emodel_creation/__init__.py b/bluepyemodel/tasks/emodel_creation/__init__.py index fc6594ea..7b39a3ca 100644 --- a/bluepyemodel/tasks/emodel_creation/__init__.py +++ b/bluepyemodel/tasks/emodel_creation/__init__.py @@ -1,7 +1,7 @@ """Tasks for emodel optimisation module.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tasks/emodel_creation/optimisation.py b/bluepyemodel/tasks/emodel_creation/optimisation.py index 6e0b5462..4d9ba8fa 100644 --- a/bluepyemodel/tasks/emodel_creation/optimisation.py +++ b/bluepyemodel/tasks/emodel_creation/optimisation.py @@ -1,7 +1,7 @@ """Luigi tasks for emodel optimisation.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -1193,7 +1193,7 @@ def output(self): """ """ checkpoint_path = get_checkpoint_path(self.access_point.emodel_metadata, seed=self.seed) - fname = f"{Path(checkpoint_path).stem}.pdf" + fname = f"{Path(checkpoint_path).stem}__optimisation.pdf" return luigi.LocalTarget(Path("./figures") / self.emodel / "optimisation" / fname) diff --git a/bluepyemodel/tasks/luigi_custom.py b/bluepyemodel/tasks/luigi_custom.py index 48477144..6524ac52 100644 --- a/bluepyemodel/tasks/luigi_custom.py +++ b/bluepyemodel/tasks/luigi_custom.py @@ -1,7 +1,7 @@ """CustomFromFile luigi worker and custom luigi launcher.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tasks/luigi_tools.py b/bluepyemodel/tasks/luigi_tools.py index 83b8b5eb..1a6ca2f8 100644 --- a/bluepyemodel/tasks/luigi_tools.py +++ b/bluepyemodel/tasks/luigi_tools.py @@ -1,7 +1,7 @@ """Luigi tool module.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/__init__.py b/bluepyemodel/tools/__init__.py index 39a43e63..86bb18a7 100644 --- a/bluepyemodel/tools/__init__.py +++ b/bluepyemodel/tools/__init__.py @@ -1,7 +1,7 @@ """Collection of various standalone tools related to emodels.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/mechanisms.py b/bluepyemodel/tools/mechanisms.py index 44091430..6edace0e 100644 --- a/bluepyemodel/tools/mechanisms.py +++ b/bluepyemodel/tools/mechanisms.py @@ -1,7 +1,7 @@ """Mechanisms related functions""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/morphology.py b/bluepyemodel/tools/morphology.py index 0cdc7830..0d43857b 100644 --- a/bluepyemodel/tools/morphology.py +++ b/bluepyemodel/tools/morphology.py @@ -1,7 +1,7 @@ """Morphology related functions""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/multiprocessing.py b/bluepyemodel/tools/multiprocessing.py index c879bd1e..7177afc4 100644 --- a/bluepyemodel/tools/multiprocessing.py +++ b/bluepyemodel/tools/multiprocessing.py @@ -1,7 +1,7 @@ """Function related to parallel computing""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/multiprotocols_efeatures_utils.py b/bluepyemodel/tools/multiprotocols_efeatures_utils.py index c3fffba5..48dc7f03 100644 --- a/bluepyemodel/tools/multiprotocols_efeatures_utils.py +++ b/bluepyemodel/tools/multiprotocols_efeatures_utils.py @@ -1,7 +1,7 @@ """MultiProtocol eFeature Utils""" """ -Copyright 2023-2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/search_pdfs.py b/bluepyemodel/tools/search_pdfs.py index eaf580a0..8e908f50 100644 --- a/bluepyemodel/tools/search_pdfs.py +++ b/bluepyemodel/tools/search_pdfs.py @@ -2,7 +2,7 @@ of the emodel pipeline""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/tools/utils.py b/bluepyemodel/tools/utils.py index 7a6e63a6..443fed4b 100644 --- a/bluepyemodel/tools/utils.py +++ b/bluepyemodel/tools/utils.py @@ -1,7 +1,7 @@ """Utils""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/validation/__init__.py b/bluepyemodel/validation/__init__.py index 8ed00ff3..ea809788 100644 --- a/bluepyemodel/validation/__init__.py +++ b/bluepyemodel/validation/__init__.py @@ -1,7 +1,7 @@ """Validation module""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/validation/validation.py b/bluepyemodel/validation/validation.py index 0fdcafbe..28cf8286 100644 --- a/bluepyemodel/validation/validation.py +++ b/bluepyemodel/validation/validation.py @@ -1,7 +1,7 @@ """Validation functions.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/bluepyemodel/validation/validation_functions.py b/bluepyemodel/validation/validation_functions.py index 6e3dc04d..a9662aa9 100644 --- a/bluepyemodel/validation/validation_functions.py +++ b/bluepyemodel/validation/validation_functions.py @@ -1,7 +1,7 @@ """Validation functions.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/examples/L5PC/README.rst b/examples/L5PC/README.rst index 5b59d21d..293b0b2b 100644 --- a/examples/L5PC/README.rst +++ b/examples/L5PC/README.rst @@ -53,7 +53,8 @@ The main configuration file is named “recipes” as it contains the ingredient }, "validation_protocols": ["sAHP_220"], "name_Rin_protocol":"IV_-20", - "name_rmp_protocol":"IV_0" + "name_rmp_protocol":"IV_0", + "morph_modifiers"; ["replace_axon_with_taper"] } } } @@ -67,6 +68,7 @@ The keys of the dictionary are the names of the models that will be built. Here, * ``params`` contain the essential mechanisms specifying their locations (e.g., axonal, somatic) as well as their distributions and parameters, which can be either frozen or free. * ``features`` contains the path to the file that includes the output of the extraction step, see `Extraction`_ for more details. * ``pipeline_settings`` contains settings used to configure the pipeline. There are many settings, that can each be important for the success of the model building procedure. The complete list of the settings available can be seen in the API documentation of the class `EModelPipelineSettings <../../bluepyemodel/emodel_pipeline/emodel_settings.py>`_. An important setting if you wish to run e-feature extraction through the pipeline is ``path_extract_config`` which points to the path of the json file containing the targets of the extraction process (e.g. ``L5PC_config.json``), features names, protocols and files (ephys data). More details on how to generate this file can be found in the section `Extraction`_. +* ``morph_modifiers`` specifies morph modifiers mainly used to replace the axon in original morphology. Use a string for a named modifier or a list with ``[file path, function name, optional "hoc_string"]``. If not specified, a default modifier ``["replace_axon_with_taper"]`` is applied which will replace the axon with a tapered axon initial segment **(Note: using this modifier requires a given morphology with at least 3 axon sections.)** . Predefined modifiers can be found in the `modifiers.py <../../bluepyemodel/evaluation/modifiers.py>`_ e.g., ``["replace_axon_legacy"]``. If the provided morphology has no axon or less than three sections, set it to ``["bluepyopt_replace_axon"]``. Set it to ``[]`` to use the provided morphology without any change. In this example, the expected final structure of the local directory should be as follows: @@ -173,9 +175,6 @@ Analysis Once a round of optimisation is finished, you might want to get the results from the checkpoint files (within the `./checkpoints` directory) generated by the optimisation process and plot the traces and scores of the models - - - To proceed with the analysis, execute the command provided below: .. code-block:: shell diff --git a/examples/L5PC/analysis.sbatch b/examples/L5PC/analysis.sbatch index 7248d5ec..0e4dc27d 100755 --- a/examples/L5PC/analysis.sbatch +++ b/examples/L5PC/analysis.sbatch @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/analysis.sh b/examples/L5PC/analysis.sh index ab1955f4..9d760548 100755 --- a/examples/L5PC/analysis.sh +++ b/examples/L5PC/analysis.sh @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/create_venv.sh b/examples/L5PC/create_venv.sh index 63dbb796..e58d2201 100755 --- a/examples/L5PC/create_venv.sh +++ b/examples/L5PC/create_venv.sh @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/download_ephys_data.sh b/examples/L5PC/download_ephys_data.sh index c8bbe2d9..7f9af2d7 100755 --- a/examples/L5PC/download_ephys_data.sh +++ b/examples/L5PC/download_ephys_data.sh @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/exploit_models.ipynb b/examples/L5PC/exploit_models.ipynb index 12c4d8f0..0fb6e4c9 100644 --- a/examples/L5PC/exploit_models.ipynb +++ b/examples/L5PC/exploit_models.ipynb @@ -364,6 +364,15 @@ "scores = evaluator.fitness_calculator.calculate_scores(responses)\n", "pprint.pprint(scores)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plotting.scores(model=emodel, write_fig=False)" + ] } ], "metadata": { diff --git a/examples/L5PC/export_hoc.sbatch b/examples/L5PC/export_hoc.sbatch index 3e4012d3..8546b0bd 100755 --- a/examples/L5PC/export_hoc.sbatch +++ b/examples/L5PC/export_hoc.sbatch @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -37,4 +37,4 @@ sleep 20 srun ipengine --profile=${IPYTHON_PROFILE} --location=$(hostname) & sleep 20 -python pipeline.py --use_ipyparallel --step='export_hoc' --emodel=${OPT_EMODEL} --seed=${OPT_SEED} +python pipeline.py --use_ipyparallel --step='export_hoc' --emodel=${OPT_EMODEL} --seed=${OPT_SEED} --githash=${GITHASH} diff --git a/examples/L5PC/export_hoc.sh b/examples/L5PC/export_hoc.sh index 88dcc800..81f9c8f9 100755 --- a/examples/L5PC/export_hoc.sh +++ b/examples/L5PC/export_hoc.sh @@ -1,5 +1,5 @@ ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -17,8 +17,9 @@ source ./myvenv/bin/activate export OPT_EMODEL="L5PC" +export GITHASH="YOUR_GITHASH_HERE" for seed in {1..5}; do export OPT_SEED=${seed} - sbatch -J "export_hoc_${OPT_EMODEL}_${OPT_SEED}" ./export_hoc.sbatch + sbatch -J "export_hoc_${OPT_EMODEL}_${OPT_SEED}_${GITHASH}" ./export_hoc.sbatch done diff --git a/examples/L5PC/extract.sbatch b/examples/L5PC/extract.sbatch index 6d68ff8e..dbbad4b6 100755 --- a/examples/L5PC/extract.sbatch +++ b/examples/L5PC/extract.sbatch @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/extract.sh b/examples/L5PC/extract.sh index 16237b2e..1dee4b5a 100755 --- a/examples/L5PC/extract.sh +++ b/examples/L5PC/extract.sh @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/monitor_optimisation.py b/examples/L5PC/monitor_optimisation.py index e4063bc1..6afcf18e 100644 --- a/examples/L5PC/monitor_optimisation.py +++ b/examples/L5PC/monitor_optimisation.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/examples/L5PC/optimisation.sbatch b/examples/L5PC/optimisation.sbatch index 7d789cef..0a7f7bd4 100644 --- a/examples/L5PC/optimisation.sbatch +++ b/examples/L5PC/optimisation.sbatch @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/optimisation.sh b/examples/L5PC/optimisation.sh index 8cc2a2e0..a13bcb1d 100755 --- a/examples/L5PC/optimisation.sh +++ b/examples/L5PC/optimisation.sh @@ -1,7 +1,7 @@ #!/bin/bash ##################################################################### -# Copyright 2023, EPFL/Blue Brain Project +# Copyright 2023-2024 Blue Brain Project / EPFL # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/examples/L5PC/pipeline.py b/examples/L5PC/pipeline.py index aa611e1a..5f9bd9e9 100644 --- a/examples/L5PC/pipeline.py +++ b/examples/L5PC/pipeline.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -38,7 +38,7 @@ def configure_targets(access_point): if ecode in fn: files_metadata.append( { - "cell_name": "cell1", + "cell_name": filename.split("/")[-2], "filename": filename.split("/")[-1].split(".")[0], "ecodes": {ecode: ecodes_metadata[ecode]}, "other_metadata": { diff --git a/examples/L5PC/targets.py b/examples/L5PC/targets.py index 8d751797..853a77f4 100644 --- a/examples/L5PC/targets.py +++ b/examples/L5PC/targets.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/examples/icselector/icselector_example.py b/examples/icselector/icselector_example.py index f02efe23..d428840a 100644 --- a/examples/icselector/icselector_example.py +++ b/examples/icselector/icselector_example.py @@ -17,7 +17,7 @@ """ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024, EPFL/Blue Brain Project Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/examples/local2nexus/README.md b/examples/local2nexus/README.md new file mode 100644 index 00000000..8dcad990 --- /dev/null +++ b/examples/local2nexus/README.md @@ -0,0 +1,59 @@ +# Export local e-model to Nexus + +To export an e-model built locally to Nexus, start by copying the ``export_local_to_nexus.py`` script and the YAML files (forge.yml and nsg.yml) into your local e-model folder. This folder should already contain the following files created during the e-model construction process: + +- ``final.json``: which contains the analysis of each optimised model +- ``run/``: folder named after the githash of the commit generated by the run you wish to export. + - ``config/``: folder containing the configuration files + - ``morphologies/``: folder containing the morphology file +- ``figures/``: folder containing the figures generated by the analysis step of the local e-model pipeline +- ``export_emodels_hoc/``: folder containing the hoc file generated by the export step of the local e-model pipeline. + +Please ensure that you run both the analysis and export hoc step of the local e-model pipeline, see [here](https://github.com/BlueBrain/BluePyEModel/tree/main/examples/L5PC#running-the-different-steps). + +Once all the required files are in place, adjust the variables in the script to match the e-model data you wish to export, as well as the Nexus-related settings. Additionally, verify that the electrophysiological data, mechanisms, and morphology are registered in the Nexus project to which you want to export the e-model. +The script is designed exclusively to create the e-model related resources within the specified Nexus project and link the respective data registered on Nexus. + +Once everything is set, run the script to export the e-model to Nexus: +``` +python export_local_to_nexus.py +``` + +If the script runs successfully, the following e-model resources will be created in the specified Nexus project: +- ``EModelPipelineSettings`` (EMPS): the pipeline settings of the e-model. +- ``ExtractionTargetsConfiguration`` (ETC): the extraction target configuration of the e-model from the ``run/{githash}/config/extract_config`` folder, as well as the links to the ephys data. +- ``EModelConfiguration`` (EMC): the configuration of the e-model, which links to the morphology and mechanisms and stores a reformatted version of the parameters file of the e-model from ``run/{githash}/config/params`` folder. +- ``FitnessCalculatorConfiguration`` (FCC): the fitness calculator configuration of the e-model, which stores the features and protocols of the e-model from ``run/{githash}/config/features/`` folder. +- ``EmodelScript`` (ES): the hoc file of the e-model. +- ``EModel`` (EM): all the information related to an optimised e-model. It contains the final parameters of the e-model from final.json, and pdfs of the e-model distribution plots, features scores and e-model response traces. It also links to EModelWorflow. +- ``EModelWorkflow`` (EMW): the resource to which all the above resources are linked also contains the workflow state. + +The graph structure of the e-model resources is shown below: + +``` + EModelWorkflow + | + ├──> EModelPipelineSettings + | + ├──> ExtractionTargetsConfiguration + | | + | ├──> Trace1 + | ├──> ... + | └──> TraceN + | + ├──> EModelConfiguration + | | + | ├──> Mechanism1 + | ├──> ... + | └──> MechanismN + | └──> Morphology + | + ├──> FitnessCalculatorConfiguration + | + ├──> EModel + | + └──> EModelScript +``` + +## Troubleshooting: Delays in Resource Registration with Nexus +During the resource registration process, errors may occur if the resource is not yet fully registered and therefore not ready to be retrieved from Nexus. To address this, the ``sleep_time`` variable in the script can be adjusted ensuring the resource fully registers with Nexus and becomes retrievable. \ No newline at end of file diff --git a/examples/local2nexus/export_local_to_nexus.py b/examples/local2nexus/export_local_to_nexus.py new file mode 100644 index 00000000..32f66ddd --- /dev/null +++ b/examples/local2nexus/export_local_to_nexus.py @@ -0,0 +1,77 @@ +"""Upload local models to nexus.""" + +import getpass +import os +from bluepyemodel.export_emodel.export_emodel import export_emodels_nexus +from bluepyemodel.access_point.local import LocalAccessPoint +import logging + +logger = logging.getLogger(__name__) + +# Please change the following settings according to your needs and data: +emodel = "YOUR_EMODEL_NAME_HERE" # name of the local emodel you want to upload as it appears in the config/recipes.json file +githash = ( + "YOUR_GITHASH_HERE" # githash of the local emodel (provided during the optimization step). +) +only_validated = False # only upload validated emodels + +only_best = False # only upload best emodel +seeds = [1] # list of seeds that you want to upload, Please leave it empty if only_best=True. + +# should match the data of your LocalAccessPoint emodel, if it was not set, use None +etype = None +mtype = None +ttype = None +species = "rat" # e.g. "mouse" +brain_region = "SSCX" # e.g. "SSCX" + +description = "" + +# Nexus settings +nexus_project = "" # a valid Nexus project name to which the emodel should be uploaded. +nexus_organisation = "bbp" # choose between "bbp" or "public" +# Nexus advanced settings (only change if you know what you are doing) +nexus_endpoint = "https://bbp.epfl.ch/nexus/v1" +forge_path = "./forge.yml" +forge_ontology_path = "./nsg.yml" +sleep_time = 10 # increase the delay in case indexing is slow + + +def main(): + + # Set the logging level + logging.basicConfig(level=logging.INFO) + + print("Please input your access token you got from nexus:") + access_token = getpass.getpass() + + local_access_point = LocalAccessPoint( + emodel=emodel, + etype=etype, + mtype=mtype, + ttype=ttype, + species=species, + brain_region=brain_region, + final_path=os.path.join(".", "final.json"), + iteration_tag=githash, + recipes_path=os.path.join(".", "config", "recipes.json"), + ) + + export_emodels_nexus( + local_access_point, + nexus_organisation=nexus_organisation, + nexus_project=nexus_project, + nexus_endpoint=nexus_endpoint, + forge_path=forge_path, + access_token=access_token, + only_validated=only_validated, + only_best=only_best, + seeds=seeds, + description=description, + forge_ontology_path=forge_ontology_path, + sleep_time=sleep_time, + ) + + +if __name__ == "__main__": + main() diff --git a/examples/local2nexus/forge.yml b/examples/local2nexus/forge.yml new file mode 100644 index 00000000..2ba9597d --- /dev/null +++ b/examples/local2nexus/forge.yml @@ -0,0 +1,73 @@ +Model: + name: RdfModel + origin: store + source: BlueBrainNexus + context: + iri: "https://bbp.neuroshapes.org" + bucket: "neurosciencegraph/datamodels" + +Store: + name: BlueBrainNexus + endpoint: https://bbp.epfl.ch/nexus/v1 + model: + name: RdfModel + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + elastic: + endpoint: "https://bbp.epfl.ch/neurosciencegraph/data/views/aggreg-es/dataset" + mapping: "https://bbp.epfl.ch/neurosciencegraph/data/views/es/dataset" + default_str_keyword_field: "keyword" + vocabulary: + metadata: + iri: "https://bluebrain.github.io/nexus/contexts/metadata.json" + local_iri: "https://bluebrainnexus.io/contexts/metadata.json" + namespace: "https://bluebrain.github.io/nexus/vocabulary/" + deprecated_property: "https://bluebrain.github.io/nexus/vocabulary/deprecated" + project_property: "https://bluebrain.github.io/nexus/vocabulary/project" + max_connection: 5 + versioned_id_template: "{x.id}?rev={x._store_metadata._rev}" + file_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-store/file-to-resource-mapping.hjson + +Resolvers: + ontology: + - resolver: OntologyResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: terms + bucket: neurosciencegraph/datamodels + - identifier: CellType + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainCellType + - identifier: BrainRegion + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainRegion + - identifier: Species + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: Species + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/term-to-resource-mapping.hjson + agent: + - resolver: AgentResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: agents + bucket: bbp/agents + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/agent-to-resource-mapping.hjson + +Formatters: + identifier: https://bbp.epfl.ch/neurosciencegraph/data/{}/{} + identifier_bbn_self: https://bbp.epfl.ch/resources/{}/{}/{}/{} # https://bbp.epfl.ch/nexus/v1/resources/{organization}/{project}/{schema}/{id} diff --git a/examples/local2nexus/nsg.yml b/examples/local2nexus/nsg.yml new file mode 100644 index 00000000..356ac1e5 --- /dev/null +++ b/examples/local2nexus/nsg.yml @@ -0,0 +1,73 @@ +Model: + name: RdfModel + origin: store + source: BlueBrainNexus + context: + iri: "https://neuroshapes.org" + bucket: "neurosciencegraph/datamodels" + +Store: + name: BlueBrainNexus + endpoint: https://bbp.epfl.ch/nexus/v1 + model: + name: RdfModel + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + elastic: + endpoint: "https://bbp.epfl.ch/neurosciencegraph/data/views/aggreg-es/dataset" + mapping: "https://bbp.epfl.ch/neurosciencegraph/data/views/es/dataset" + default_str_keyword_field: "keyword" + vocabulary: + metadata: + iri: "https://bluebrain.github.io/nexus/contexts/metadata.json" + local_iri: "https://bluebrainnexus.io/contexts/metadata.json" + namespace: "https://bluebrain.github.io/nexus/vocabulary/" + deprecated_property: "https://bluebrain.github.io/nexus/vocabulary/deprecated" + project_property: "https://bluebrain.github.io/nexus/vocabulary/project" + max_connection: 5 + versioned_id_template: "{x.id}?rev={x._store_metadata._rev}" + file_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-store/file-to-resource-mapping.hjson + +Resolvers: + ontology: + - resolver: OntologyResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: terms + bucket: neurosciencegraph/datamodels + - identifier: CellType + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainCellType + - identifier: BrainRegion + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainRegion + - identifier: Species + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: Species + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/term-to-resource-mapping.hjson + agent: + - resolver: AgentResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: agents + bucket: bbp/agents + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/agent-to-resource-mapping.hjson + +Formatters: + identifier: https://bbp.epfl.ch/neurosciencegraph/data/{}/{} + identifier_bbn_self: https://bbp.epfl.ch/resources/{}/{}/{}/{} # https://bbp.epfl.ch/nexus/v1/resources/{organization}/{project}/{schema}/{id} diff --git a/examples/memodel/forge.yml b/examples/memodel/forge.yml new file mode 100644 index 00000000..2ba9597d --- /dev/null +++ b/examples/memodel/forge.yml @@ -0,0 +1,73 @@ +Model: + name: RdfModel + origin: store + source: BlueBrainNexus + context: + iri: "https://bbp.neuroshapes.org" + bucket: "neurosciencegraph/datamodels" + +Store: + name: BlueBrainNexus + endpoint: https://bbp.epfl.ch/nexus/v1 + model: + name: RdfModel + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + elastic: + endpoint: "https://bbp.epfl.ch/neurosciencegraph/data/views/aggreg-es/dataset" + mapping: "https://bbp.epfl.ch/neurosciencegraph/data/views/es/dataset" + default_str_keyword_field: "keyword" + vocabulary: + metadata: + iri: "https://bluebrain.github.io/nexus/contexts/metadata.json" + local_iri: "https://bluebrainnexus.io/contexts/metadata.json" + namespace: "https://bluebrain.github.io/nexus/vocabulary/" + deprecated_property: "https://bluebrain.github.io/nexus/vocabulary/deprecated" + project_property: "https://bluebrain.github.io/nexus/vocabulary/project" + max_connection: 5 + versioned_id_template: "{x.id}?rev={x._store_metadata._rev}" + file_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-store/file-to-resource-mapping.hjson + +Resolvers: + ontology: + - resolver: OntologyResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: terms + bucket: neurosciencegraph/datamodels + - identifier: CellType + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainCellType + - identifier: BrainRegion + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainRegion + - identifier: Species + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: Species + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/term-to-resource-mapping.hjson + agent: + - resolver: AgentResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: agents + bucket: bbp/agents + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/agent-to-resource-mapping.hjson + +Formatters: + identifier: https://bbp.epfl.ch/neurosciencegraph/data/{}/{} + identifier_bbn_self: https://bbp.epfl.ch/resources/{}/{}/{}/{} # https://bbp.epfl.ch/nexus/v1/resources/{organization}/{project}/{schema}/{id} diff --git a/examples/memodel/forge_ontology_path.yml b/examples/memodel/forge_ontology_path.yml new file mode 100644 index 00000000..c5894823 --- /dev/null +++ b/examples/memodel/forge_ontology_path.yml @@ -0,0 +1,73 @@ +Model: + name: RdfModel + origin: store + source: BlueBrainNexus + context: + iri: "https://neuroshapes.org" + bucket: "neurosciencegraph/datamodels" + +Store: + name: BlueBrainNexus + endpoint: https://bbp.epfl.ch/nexus/v1 + model: + name: RdfModel + searchendpoints: + sparql: + endpoint: "https://bbp.epfl.ch/neurosciencegraph/data/62529364-b584-4cc9-82ce-36efd690b111" + elastic: + endpoint: "https://bbp.epfl.ch/neurosciencegraph/data/views/aggreg-es/dataset" + mapping: "https://bbp.epfl.ch/neurosciencegraph/data/views/es/dataset" + default_str_keyword_field: "keyword" + vocabulary: + metadata: + iri: "https://bluebrain.github.io/nexus/contexts/metadata.json" + local_iri: "https://bluebrainnexus.io/contexts/metadata.json" + namespace: "https://bluebrain.github.io/nexus/vocabulary/" + deprecated_property: "https://bluebrain.github.io/nexus/vocabulary/deprecated" + project_property: "https://bluebrain.github.io/nexus/vocabulary/project" + max_connection: 5 + versioned_id_template: "{x.id}?rev={x._store_metadata._rev}" + file_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-store/file-to-resource-mapping.hjson + +Resolvers: + ontology: + - resolver: OntologyResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: terms + bucket: neurosciencegraph/datamodels + - identifier: CellType + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainCellType + - identifier: BrainRegion + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: BrainRegion + - identifier: Species + bucket: neurosciencegraph/datamodels + filters: + - path: subClassOf*.id + value: Species + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/term-to-resource-mapping.hjson + agent: + - resolver: AgentResolver + origin: store + source: BlueBrainNexus + targets: + - identifier: agents + bucket: bbp/agents + searchendpoints: + sparql: + endpoint: "https://bluebrain.github.io/nexus/vocabulary/defaultSparqlIndex" + result_resource_mapping: https://raw.githubusercontent.com/BlueBrain/nexus-forge/master/examples/configurations/nexus-resolver/agent-to-resource-mapping.hjson + +Formatters: + identifier: https://bbp.epfl.ch/neurosciencegraph/data/{}/{} + identifier_bbn_self: https://bbp.epfl.ch/resources/{}/{}/{}/{} # https://bbp.epfl.ch/nexus/v1/resources/{organization}/{project}/{schema}/{id} diff --git a/examples/memodel/memodel.py b/examples/memodel/memodel.py new file mode 100644 index 00000000..1c65972a --- /dev/null +++ b/examples/memodel/memodel.py @@ -0,0 +1,400 @@ +"""Get EModel, modify morphology, plot analysis and upload MEModel""" + +# Attention! This will overwrite figures made with the same access point. +# It is highly recommended to clean the figures folder between two runs +# to avoid any leftover figure to be wrongly associated with a MEModel. + +import copy +import getpass +import pathlib + +from kgforge.core import KnowledgeGraphForge +from kgforge.specializations.resources import Dataset + +from bluepyemodel.access_point.forge_access_point import get_brain_region_notation +from bluepyemodel.access_point.nexus import NexusAccessPoint +from bluepyemodel.emodel_pipeline.memodel import MEModel +from bluepyemodel.emodel_pipeline.plotting import plot_models +from bluepyemodel.emodel_pipeline.plotting import scores +from bluepyemodel.evaluation.evaluation import compute_responses +from bluepyemodel.evaluation.evaluation import get_evaluator_from_access_point +from bluepyemodel.tools.search_pdfs import copy_emodel_pdf_dependencies_to_new_path +from bluepyemodel.validation.validation import compute_scores + + +def connect_forge(bucket, endpoint, access_token, forge_path=None): + """Creation of a forge session""" + if not forge_path: + forge_path = ( + "https://raw.githubusercontent.com/BlueBrain/nexus-forge/" + + "master/examples/notebooks/use-cases/prod-forge-nexus.yml" + ) + forge = KnowledgeGraphForge( + forge_path, bucket=bucket, endpoint=endpoint, token=access_token + ) + return forge + + +def get_ids_from_memodel(memodel_r): + """Get EModel and Morphology ids from MEModel resource metadata.""" + emodel_id = None + morph_id = None + if not hasattr(memodel_r, "hasPart"): + raise AttributeError("ME-Model resource has no 'hasPart' metadata") + for haspart in memodel_r.hasPart: + if haspart.type == "EModel": + emodel_id = haspart.id + elif haspart.type == "NeuronMorphology": + morph_id = haspart.id + if emodel_id is None: + raise TypeError("Could not find any EModel resource id link in MEModel resource.") + if morph_id is None: + raise TypeError("Could not find any NeuronMorphology resource id link in MEModel resource.") + + return emodel_id, morph_id + + +def get_morph_mtype(annotation): + morph_mtype = None + if hasattr(annotation, "hasBody"): + if hasattr(annotation.hasBody, "label"): + morph_mtype = annotation.hasBody.label + else: + raise ValueError("Morphology resource has no label in annotation.hasBody.") + else: + raise ValueError("Morphology resource has no hasBodz in annotation.") + + return morph_mtype + + +def get_morph_metadata(access_point, morph_id): + resource = access_point.access_point.retrieve(morph_id) + if resource is None: + raise TypeError(f"Could not find the morphology resource with id {morph_id}") + + morph_brain_region = None + if hasattr(resource, "brainLocation"): + if hasattr(resource.brainLocation, "brainRegion"): + if hasattr(resource.brainLocation.brainRegion, "label"): + morph_brain_region = resource.brainLocation.brainRegion.label + else: + raise AttributeError("Morphology resource has no label in brainLocation.brainRegion") + else: + raise AttributeError("Morphology resource has no brainRegion in brainLocation.") + else: + raise AttributeError("Morphology resource has no brainLocation.") + + morph_mtype = None + if not hasattr(resource, "annotation"): + raise AttributeError("Morphology resource has no annotation.") + + if isinstance(resource.annotation, dict): + if hasattr(resource.annotation, "type") and ( + "MTypeAnnotation" in resource.annotation.type or + "nsg:MTypeAnnotation" in resource.annotation.type + ): + morph_mtype = get_morph_mtype(resource.annotation) + elif isinstance(resource.annotation, list): + for annotation in resource.annotation: + if hasattr(annotation, "type") and ( + "MTypeAnnotation" in annotation.type or + "nsg:MTypeAnnotation" in annotation.type + ): + morph_mtype = get_morph_mtype(annotation) + + if morph_mtype is None: + raise TypeError("Could not find mtype in morphology resource") + + return morph_mtype, morph_brain_region + + +def get_new_emodel_metadata( + access_point, + morph_id, + morph_name, + update_emodel_name, + use_brain_region_from_morphology, + use_mtype_in_githash, +): + new_emodel_metadata = copy.deepcopy(access_point.emodel_metadata) + new_mtype, new_br = get_morph_metadata(access_point, morph_id) + new_emodel_metadata.mtype = new_mtype + + if update_emodel_name: + new_emodel_metadata.emodel = f"{new_emodel_metadata.etype}_{new_mtype}" + + if use_brain_region_from_morphology: + new_emodel_metadata.brain_region = new_br + new_emodel_metadata.allen_notation = get_brain_region_notation( + new_br, + access_point.access_point.access_token, + access_point.forge_ontology_path, + ) + + if use_mtype_in_githash: + new_emodel_metadata.iteration = f"{new_emodel_metadata.iteration}-{morph_name}" + + return new_emodel_metadata + + +def get_cell_evaluator(access_point, morph_name, morph_format, morph_id): + # create cell evaluator from access point + cell_evaluator = get_evaluator_from_access_point( + access_point, + include_validation_protocols=True, + record_ions_and_currents=access_point.pipeline_settings.plot_currentscape, + ) + + # get morphology path + morph_path = access_point.download_morphology( + name=morph_name, # optional in BPEMnexus 0.0.9.dev3 onwards if id_ is given + format_=morph_format, + id_=morph_id, + ) + + # modify the evaluator to use the 'new' morphology + cell_evaluator.cell_model.morphology.morphology_path = morph_path + + return cell_evaluator + + +def plot_scores(access_point, cell_evaluator, mapper, figures_dir, seed): + """Plot scores figures and return total fitness (sum of scores)""" + emodel_score = None + emodels = compute_responses( + access_point, + cell_evaluator=cell_evaluator, + seeds=[seed], + map_function=mapper, + preselect_for_validation=False, # model is probably already validated. ignore preselection. + ) + if not emodels: + raise ValueError("In plot_scores, no emodels for %s", access_point.emodel_metadata.emodel) + + # we iterate but we expect only one emodel to be in the list + for model in emodels: + compute_scores(model, access_point.pipeline_settings.validation_protocols) + + figures_dir_scores = figures_dir / "scores" / "all" + scores(model, figures_dir_scores) # plotting fct + # the scores have been added to the emodel at the compute_scores step + emodel_score = sum(list(model.scores.values())) + + return emodel_score + + +def plot(access_point, seed, cell_evaluator, figures_dir, mapper): + """Plot figures and return total fitness (sum of scores)""" + # compute scores + # we need to do this outside of main plotting function with custom function + # so that we do not take old emodel scores in scores figure + emodel_score = plot_scores(access_point, cell_evaluator, mapper, figures_dir, seed) + + plot_models( + access_point=access_point, + mapper=mapper, + seeds=[seed], + figures_dir=figures_dir, + plot_distributions=True, + plot_scores=False, # scores figure done outside of this + plot_traces=True, + plot_thumbnail=True, + plot_currentscape=access_point.pipeline_settings.plot_currentscape, + plot_bAP_EPSP=access_point.pipeline_settings.plot_bAP_EPSP, + plot_dendritic_ISI_CV=True, # for detailed cADpyr cells. will be skipped otherwise + plot_dendritic_rheobase=True, # for detailed cADpyr cells. will be skipped otherwise + only_validated=False, + save_recordings=False, + load_from_local=False, + cell_evaluator=cell_evaluator, # <-- feed the modified evaluator here + ) + + return emodel_score + + +def get_nexus_images(access_point, seed, new_emodel_metadata, morph_id, emodel_id): + """Get the nexus images from memodel method using new emodel metadata.""" + # create MEModel (easier to get images with it) + memodel = MEModel( + seed=seed, + emodel_metadata=access_point.emodel_metadata, + emodel_id=emodel_id, + morphology_id=morph_id, + validated=False, + ) + + # update MEModel metadata + memodel.emodel_metadata = new_emodel_metadata + + return memodel.build_pdf_dependencies(memodel.seed) + + +def update_memodel( + forge, + memodel_r, + seed, + new_emodel_metadata, + subject_ontology, + brain_location_ontology, + nexus_images, + emodel_score=None, + new_status="done", +): + """Update ME-Model.""" + # update metadata in resource + metadata_for_resource = new_emodel_metadata.for_resource() + metadata_for_resource["subject"] = subject_ontology + metadata_for_resource["brainLocation"] = brain_location_ontology + for key, item in metadata_for_resource.items(): + setattr(memodel_r, key, item) + + memodel_r.seed = seed + memodel_r.objectOfStudy = { + "@id": "http://bbp.epfl.ch/neurosciencegraph/taxonomies/objectsofstudy/singlecells", + "label": "Single Cell", + } + memodel_r.status = new_status + if emodel_score is not None: + memodel_r.score = emodel_score + + # do not add any description: we expect it to be already present + + # make memodel resource into a Dataset to be able to add images + # have store_metadata=True to be able to update resource + memodel_r = Dataset.from_resource(forge, memodel_r, store_metadata=True) + + # add images in memodel resource + # Do NOT do this BEFORE turning resource into a Dataset. + # That would break the storing LazyAction into a string + for path in nexus_images: + resource_type = path.split("__")[-1].split(".")[0] + memodel_r.add_image( + path=path, + content_type=f"application/{path.split('.')[-1]}", + about=resource_type, + ) + + # update memodel resource + forge.update(memodel_r) + + +if __name__ == "__main__": + project = "mmb-point-neuron-framework-model" + organisation = "bbp" + endpoint = "https://bbp.epfl.ch/nexus/v1" + forge_path = "./forge.yml" # this file has to be present + forge_ontology_path = "./forge_ontology_path.yml" # this file also + memodel_id = "" # replace with the id of the MEModel you want to update + + mapper = map + # also available: + # from bluepyemodel.tools.multiprocessing import get_mapper + # mapper = get_mapper(backend="ipyparallel") + # mapper = get_mapper(backend="multiprocessing") + + # MEModel metadata-related config + update_emodel_name = True + use_brain_region_from_morphology = True + use_mtype_in_githash = True # to distinguish from other MEModel + add_score = True + + + # create forge and retrieve ME-Model + access_token = getpass.getpass() + forge = connect_forge( + bucket=f"{organisation}/{project}", + endpoint=endpoint, + access_token=access_token, + forge_path=forge_path + ) + + # memodel resource + memodel_r = forge.retrieve(memodel_id) + emodel_id, morph_id = get_ids_from_memodel(memodel_r) + emodel_r = forge.retrieve(emodel_id) + morph_r = forge.retrieve(morph_id) + + # get metadata from EModel resource + emodel = emodel_r.eModel if hasattr(emodel_r, "eModel") else None + etype = emodel_r.eType if hasattr(emodel_r, "eType") else None + ttype = emodel_r.tType if hasattr(emodel_r, "tType") else None + mtype = emodel_r.mType if hasattr(emodel_r, "mType") else None + species = None + if hasattr(emodel_r, "subject"): + if hasattr(emodel_r.subject, "species"): + species = emodel_r.subject.species.label if hasattr(emodel_r.subject.species, "label") else None + brain_region = None + if hasattr(emodel_r, "brainLocation"): + if hasattr(emodel_r.brainLocation, "brainRegion"): + brain_region = emodel_r.brainLocation.brainRegion.label if hasattr(emodel_r.brainLocation.brainRegion, "label") else None + iteration_tag = emodel_r.iteration if hasattr(emodel_r, "iteration") else None + synapse_class = emodel_r.synapse_class if hasattr(emodel_r, "synapseClass") else None + seed = int(emodel_r.seed if hasattr(emodel_r, "seed") else 0) + + # get morph metadata + morph_name = morph_r.name if hasattr(morph_r, "name") else None + morph_format = "swc" # assumes swc is always present and we do not care about small differences between format + + # additional metadata we will need when saving me-model resource + subject_ontology = emodel_r.subject if hasattr(emodel_r, "subject") else None + brain_location_ontology = morph_r.brainLocation if hasattr(morph_r, "brainLocation") else None + + # feed nexus acces point with appropriate data + access_point = NexusAccessPoint( + emodel=emodel, + etype=etype, + ttype=ttype, + mtype=mtype, + species=species, + brain_region=brain_region, + iteration_tag=iteration_tag, + synapse_class=synapse_class, + project=project, + organisation=organisation, + endpoint=endpoint, + forge_path=forge_path, # this file has to be present + forge_ontology_path=forge_ontology_path, # this file also + access_token=access_token, + ) + + # get cell evaluator with 'new' morphology + cell_evaluator = get_cell_evaluator(access_point, morph_name, morph_format, morph_id) + + # get new emodel metadata (mtype, emodel, brain region, iteration/githash) + # to correspond to combined metadata of emodel and morphology + new_emodel_metadata = get_new_emodel_metadata( + access_point, + morph_id, + morph_name, + update_emodel_name, + use_brain_region_from_morphology, + use_mtype_in_githash, + ) + + # plotting + figures_dir = pathlib.Path("./figures") / access_point.emodel_metadata.emodel + # trick: get scores from plot_scores, so that we don't have to run the model twice + emodel_score = plot(access_point, seed, cell_evaluator, figures_dir, mapper) + if not add_score: + emodel_score = None + # attention! after this step, do NOT push EModel again. + # It has been modified and would overwrite the correct one on nexus + + # move figures: to correspond to combined metadata of emodel and morphology + copy_emodel_pdf_dependencies_to_new_path( + access_point.emodel_metadata, new_emodel_metadata, True, True, seed, overwrite=True + ) + + nexus_images = get_nexus_images(access_point, seed, new_emodel_metadata, morph_id, emodel_id) + + # create and store MEModel + update_memodel( + forge, + memodel_r, + seed, + new_emodel_metadata, + subject_ontology, + brain_location_ontology, + nexus_images, + emodel_score, + ) diff --git a/examples/run_emodel/README.rst b/examples/run_emodel/README.rst new file mode 100644 index 00000000..bd6a8c1d --- /dev/null +++ b/examples/run_emodel/README.rst @@ -0,0 +1,33 @@ +Running an emodel on BlueCelluLab +================================= + +The ``run_emodel.py`` script provides an example to run a simulation of an emodel stored on Nexus with BlueCellulab. The script takes care of downloading all the resources related to the emodel, including hoc templates, morphologies, and mod files. + +Prerequisites +------------- +Before running the script, ensure that you have the necessary Python packages installed. It is recommended to create a new virtual environment for this purpose: + +1. Create a new virtual environment: ``python -m venv venv`` +2. Activate the virtual environment: ``source venv/bin/activate`` + +With the virtual environment activated, install the following packages: + +- ``bluepyemodel``: Install using pip with the command ``pip install bluepyemodel`` +- ``bluecellulab``: Install using pip with the command ``pip install bluecellulab``` + +Usage +----- +To execute the script, you must provide the ``emodel_id``, which is the Nexus ``Resource ID`` for the emodel resource. + +To run the script: + +.. code-block:: shell + + python run_emodel.py --emodel_id="emodel_id" + +After running the script, the simulation results will be saved in the ``figures`` directory. + +Configuration +------------- +The script can be customised to alter various model parameters, including stimulus amplitudes, and also change other model parameters such as ``v_init`` and ``temperature``. Modify these parameters directly within the script as needed. +If you want to run a model that uses threshold-based optimization, you need to specify the amplitudes as a percentage of the threshold value. \ No newline at end of file diff --git a/examples/run_emodel/img_nexus_id.png b/examples/run_emodel/img_nexus_id.png new file mode 100644 index 00000000..74295239 Binary files /dev/null and b/examples/run_emodel/img_nexus_id.png differ diff --git a/examples/run_emodel/img_nexus_token.png b/examples/run_emodel/img_nexus_token.png new file mode 100644 index 00000000..4541c13d Binary files /dev/null and b/examples/run_emodel/img_nexus_token.png differ diff --git a/examples/run_emodel/run_emodel.ipynb b/examples/run_emodel/run_emodel.ipynb new file mode 100644 index 00000000..7d14fa61 --- /dev/null +++ b/examples/run_emodel/run_emodel.ipynb @@ -0,0 +1,616 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Download and run an e-model " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the emodel data is already downloaded, you can proceed directly to the 'Simulating the Emodel' section" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downloading the Emodel" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from kgforge.core import KnowledgeGraphForge\n", + "import getpass\n", + "from bluepyemodel.access_point.nexus import NexusAccessPoint\n", + "import os\n", + "import shutil\n", + "from pathlib import Path\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def connect_forge(bucket, endpoint, access_token, forge_path=None):\n", + " \"\"\"Creation of a forge session\"\"\"\n", + "\n", + " forge = KnowledgeGraphForge(\n", + " forge_path, bucket=bucket, endpoint=endpoint, token=access_token\n", + " )\n", + " return forge" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify the Nexus ID for the emodel you wish to simulate. Ensure to set the correct organisation/project." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Image\n", + "display(Image(filename=\"img_nexus_id.png\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "emodel_id=\"\" # paste the id here\n", + "\n", + "ORG = \"\" # paste the organization here\n", + "PROJECT = \"\" # paste the project here\n", + "\n", + "# Advanced settings\n", + "endpoint = \"https://bbp.epfl.ch/nexus/v1\"\n", + "forge_path = (\n", + " \"https://raw.githubusercontent.com/BlueBrain/nexus-forge/\"\n", + " + \"master/examples/notebooks/use-cases/prod-forge-nexus.yml\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the EModel (EM) resource from Nexus and download its morphology, mechanisms, hoc and the final parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To obtain your Nexus access token, please visit https://bbp.epfl.ch/nexus/web/:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Image\n", + "display(Image(filename=\"img_nexus_token.png\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "access_token = getpass.getpass()\n", + "forge = connect_forge(f\"{ORG}/{PROJECT}\", endpoint, access_token, forge_path=forge_path)\n", + "r = forge.retrieve(emodel_id)\n", + "\n", + "if r is None:\n", + " raise ValueError(f\"Resource with id {emodel_id} not found.\")\n", + "emodel = r.__dict__.get('eModel', r.__dict__.get('emodel'))\n", + "etype = r.__dict__.get('eType', r.__dict__.get('etype', None))\n", + "ttype = r.__dict__.get('tType', r.__dict__.get('ttype', None))\n", + "mtype = r.__dict__.get('mType', r.__dict__.get('mtype', None))\n", + "iteration_tag = r.__dict__.get(\"iteration\", None)\n", + "seed = r.__dict__.get(\"seed\", None)\n", + "\n", + "if r.subject.species.label == \"Rattus norvegicus\":\n", + " species = \"rat\"\n", + "elif r.subject.species.label == \"Mus musculus\":\n", + " species = \"mouse\"\n", + "elif r.subject.species.label == \"Homo sapiens\":\n", + " species = \"human\"\n", + "else:\n", + " raise ValueError(f\"Species {r.subject.species.label} not supported.\")\n", + "\n", + "brain_region = r.brainLocation.brainRegion.label\n", + "\n", + "metadata = {\n", + " \"emodel\": emodel,\n", + " \"etype\": etype,\n", + " \"mtype\": mtype,\n", + " \"ttype\": ttype,\n", + " \"species\": species,\n", + " \"iteration_tag\": iteration_tag,\n", + " \"brain_region\": brain_region,\n", + "}\n", + "\n", + "# Download data from Nexus\n", + "nap = NexusAccessPoint(\n", + " **metadata,\n", + " project=PROJECT,\n", + " organisation=ORG,\n", + " endpoint=endpoint,\n", + " access_token=access_token,\n", + " forge_path=forge_path,\n", + " sleep_time=7,\n", + ")\n", + "\n", + "print(\"Downloading data...\")\n", + "model_configuration = nap.get_model_configuration()\n", + "nap.get_hoc()\n", + "nap.get_emodel()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulating the Emodel " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "import glob\n", + "import json\n", + "import os\n", + "import shutil\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Copies the necessary mechanisms into the working directory" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def load_mechanism(directory_path):\n", + " #Copy the correct mechanism in the working directory\n", + "\n", + " if os.path.exists(\"x86_64\") and os.path.isdir(\"x86_64\"):\n", + " shutil.rmtree(\"x86_64\")\n", + " source_folder = f\"{directory_path}/x86_64/\"\n", + " destination_folder = \"./x86_64/\"\n", + " shutil.copytree(source_folder, destination_folder)\n", + "\n", + "folder_id = nap.get_emodel().emodel_metadata.as_string()\n", + "directory_path = f\"./nexus_temp/{folder_id}\"\n", + "load_mechanism(directory_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading the data for the simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read the EModel resource which contains the final features of the emodel to get the holding and threshold current" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def getHoldingThreshCurrent(directory_path):\n", + " pattern = os.path.join(directory_path, 'EM_*' + 'json')\n", + " final = glob.glob(pattern)\n", + " if final:\n", + " file_name = final[0]\n", + " with open(file_name, 'r') as file:\n", + " data = json.load(file)\n", + " else:\n", + " raise FileNotFoundError(f\"No EModel resource found in {directory_path}.\")\n", + "\n", + " holding_current = 0\n", + " threshold_current = 0\n", + "\n", + " for feature in data['features']:\n", + " if 'bpo_holding_current' in feature['name']:\n", + " holding_current = feature['value']\n", + " print(feature)\n", + " elif 'bpo_threshold_current' in feature['name']:\n", + " threshold_current = feature['value']\n", + " print(feature)\n", + "\n", + " return (holding_current, threshold_current)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the hoc and morphology" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "hoc_file = Path(directory_path) / \"model.hoc\"\n", + "morph_file = nap.download_morphology(model_configuration.morphology.name, model_configuration.morphology.format, model_configuration.morphology.id)\n", + "holding_current, threshold_current = getHoldingThreshCurrent(directory_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from bluecellulab import Cell, Simulation\n", + "from bluecellulab.stimulus.circuit_stimulus_definitions import OrnsteinUhlenbeck, ShotNoise\n", + "from bluecellulab.simulation.neuron_globals import NeuronGlobals\n", + "from bluecellulab.circuit.circuit_access import EmodelProperties\n", + "\n", + "NeuronGlobals.get_instance().temperature = 34.0\n", + "NeuronGlobals.get_instance().v_init = -70\n", + "\n", + "emodel_properties = EmodelProperties(threshold_current=threshold_current,\n", + " holding_current=holding_current)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step Stimulus" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Define stimulus parameters\n", + "start_time = 15.0 # Start time of the stimulus\n", + "stop_time = 25.0 # Stop time of the stimulus\n", + "level = 1.0 # Current level of the stimulus\n", + "\n", + "cell = Cell(hoc_file, morph_file, template_format=\"v6\", emodel_properties=emodel_properties)\n", + "icneurodamusobj = cell.add_step(start_time=start_time, stop_time=stop_time, level=level)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import neuron\n", + "iclamp_current = neuron.h.Vector()\n", + "iclamp_current.record(icneurodamusobj.ic._ref_i)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the simulation\n", + "max_time = 100\n", + "sim = Simulation()\n", + "sim.add_cell(cell)\n", + "sim.run(max_time, cvode=False)\n", + "time, voltage = cell.get_time(), cell.get_soma_voltage()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the simulation\n", + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(7.5, 10))\n", + "\n", + "ax1.plot(time, iclamp_current, drawstyle='steps-post')\n", + "ax1.set_title(\"Stimulus\")\n", + "ax1.set_xlabel(\"Time (ms)\")\n", + "ax1.set_ylabel(\"Current (nA)\")\n", + "ax1.fill_between(time, 0, list(iclamp_current), step=\"post\", color='gray', alpha=0.3)\n", + "ax1.grid(True)\n", + "\n", + "ax2.plot(time, voltage)\n", + "ax2.set_title(\"Response\")\n", + "ax2.set_xlabel(\"Time (ms)\")\n", + "ax2.set_ylabel(\"Voltage (mV)\")\n", + "ax2.grid(True)\n", + "\n", + "plt.suptitle(\"Step\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ramp stimulus" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Define ramp stimulus parameters\n", + "start_time = 50.0 # Start time of the ramp\n", + "stop_time = 125.0 # Stop time of the ramp\n", + "start_level = 0.0 # Start level of the ramp\n", + "stop_level = 2.0 # Stop level of the ramp\n", + "\n", + "cell = Cell(hoc_file, morph_file, template_format=\"v6\", emodel_properties=emodel_properties)\n", + "ramp_obj = cell.add_ramp(start_time=start_time, stop_time=stop_time, start_level=start_level, stop_level=stop_level)\n", + "\n", + "ramp_current = neuron.h.Vector()\n", + "ramp_current.record(ramp_obj.ic._ref_i)\n", + "\n", + "# To add the holding current\n", + "# from bluecellulab.cell.injector import Hyperpolarizing\n", + "# hyperpolarizing = Hyperpolarizing(\"single-cell\", delay=0, duration=params['tstop'])\n", + "# cell.add_replay_hypamp(hyperpolarizing)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the simulation\n", + "max_time = 200\n", + "sim = Simulation()\n", + "sim.add_cell(cell)\n", + "sim.run(max_time, cvode=False)\n", + "time, voltage = cell.get_time(), cell.get_soma_voltage()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the simulation\n", + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(7.5, 10))\n", + "\n", + "ax1.plot(time, ramp_current)\n", + "ax1.set_title(\"Ramp Stimulus\")\n", + "ax1.set_xlabel(\"Time (ms)\")\n", + "ax1.set_ylabel(\"Current (nA)\")\n", + "ax1.fill_between([start_time, stop_time], start_level, stop_level, color='gray', alpha=0.3)\n", + "ax1.grid(True)\n", + "\n", + "ax2.plot(time, voltage)\n", + "ax2.set_title(\"Response\")\n", + "ax2.set_xlabel(\"Time (ms)\")\n", + "ax2.set_ylabel(\"Voltage (mV)\")\n", + "ax2.grid(True)\n", + "\n", + "plt.suptitle(\"Ramp\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Shot noise stimulus" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "shotnoise_stimulus = ShotNoise(\n", + " target=\"single-cell\", delay=25, duration=20,\n", + " rise_time=0.4, decay_time=4, rate=2E3, amp_mean=40E-3, amp_var=16E-4,\n", + " seed=3899663\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cell = Cell(hoc_file, morph_file, template_format=\"v6\", emodel_properties=emodel_properties)\n", + "time_vec, stim_vec = cell.add_replay_shotnoise(\n", + " cell.soma, 0.5,\n", + " shotnoise_stimulus,\n", + " shotnoise_stim_count=3)\n", + "time_vec = time_vec.to_python()\n", + "stim_vec = stim_vec.to_python()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the simulation\n", + "max_time = 60\n", + "sim = Simulation()\n", + "sim.add_cell(cell)\n", + "sim.run(max_time, cvode=False)\n", + "time, voltage = cell.get_time(), cell.get_soma_voltage()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# add 0 to the beginning of the stim vector\n", + "new_stim_vec = [0] + stim_vec + [0]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "new_time_vec = [0]+time_vec+[max_time]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the simulation\n", + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 5))\n", + "\n", + "ax1.plot(new_time_vec, new_stim_vec, '-o')\n", + "# ax1.plot(time_vec, stim_vec, '-o')\n", + "ax1.set_title(\"Shot noise Stimulus\")\n", + "ax1.set_xlabel(\"Time (ms)\")\n", + "ax1.set_ylabel(\"Current (nA)\")\n", + "ax1.grid(True)\n", + "\n", + "ax2.plot(time, voltage)\n", + "ax2.set_title(\"Response\")\n", + "ax2.set_xlabel(\"Time (ms)\")\n", + "ax2.set_ylabel(\"Voltage (mV)\")\n", + "ax2.grid(True)\n", + "\n", + "plt.suptitle(\"Shot Noise\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv-bpem", + "language": "python", + "name": "venv-bpem" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/run_emodel/run_emodel.py b/examples/run_emodel/run_emodel.py new file mode 100644 index 00000000..43c06c76 --- /dev/null +++ b/examples/run_emodel/run_emodel.py @@ -0,0 +1,187 @@ +"""Running the emodel with BlueCelluLab""" + +import argparse +import getpass +import glob +import json +import os +import shutil +from pathlib import Path + +import matplotlib.pyplot as plt +from kgforge.core import KnowledgeGraphForge + +from bluepyemodel.access_point.nexus import NexusAccessPoint + +###################################################### +# CONFIGURATION +###################################################### +# Amplitudes for simulation +# if using threshold based amplitudes, set the amplitudes as a percentage of the threshold current +amplitudes = [-120, -40, 0, 150, 200, 250] # threshold based +# amplitudes = [-0.2, -0.4, -0.6, -0.8, -1.0, 0.2, 0.4, 0.6, 0.8, 1.0] # absolute amplitudes + +TEMPERATURE = 34.0 # celsius +V_INIT = -70 # mV + +# Nexus configuration +ORG = "" # "bbp" or "public +PROJECT = "" # Nexus project name where the emodel is stored +bucket = f"{ORG}/{PROJECT}" +endpoint = "https://bbp.epfl.ch/nexus/v1" +access_token = getpass.getpass("Enter your Nexus token: ") +forge_path = ( + "https://raw.githubusercontent.com/BlueBrain/nexus-forge/" + + "master/examples/notebooks/use-cases/prod-forge-nexus.yml" +) +###################################################### + +def getHoldingThreshCurrent(directory_path): + pattern = os.path.join(directory_path, 'EM_*' + 'json') + final = glob.glob(pattern) + if final: + file_name = final[0] + with open(file_name, 'r') as file: + data = json.load(file) + else: + raise FileNotFoundError(f"No EModel resource found in {directory_path}.") + + holding_current = 0 + threshold_current = 0 + + for feature in data['features']: + if 'soma.v.bpo_holding_current' in feature['name']: + holding_current = feature['value'] + print(feature) + elif 'soma.v.bpo_threshold_current' in feature['name']: + threshold_current = feature['value'] + print(feature) + + return (holding_current, threshold_current) + +def load_mechanism(directory_path): + #Copy the mechanism in the working directory + if os.path.exists("./x86_64") and os.path.isdir("./x86_64"): + shutil.rmtree("./x86_64") + source_folder = f"{directory_path}/x86_64/" + destination_folder = "./x86_64/" + shutil.copytree(source_folder, destination_folder) + +def connect_forge(bucket, endpoint, access_token, forge_path=None): + """Creation of a forge session""" + + forge = KnowledgeGraphForge( + forge_path, bucket=bucket, endpoint=endpoint, token=access_token + ) + return forge + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument('--emodel_id', action="store", type=str, required=True) + args = parser.parse_args() + emodel_id = args.emodel_id + + # Get metadata + forge = connect_forge(bucket, endpoint, access_token, forge_path=forge_path) + r = forge.retrieve(emodel_id) + if r is None: + raise ValueError(f"Resource with id {emodel_id} not found.") + emodel = r.__dict__.get('eModel', r.__dict__.get('emodel')) + etype = r.__dict__.get('eType', r.__dict__.get('etype', None)) + ttype = r.__dict__.get('tType', r.__dict__.get('ttype', None)) + mtype = r.__dict__.get('mType', r.__dict__.get('mtype', None)) + iteration_tag = r.__dict__.get("iteration", None) + seed = r.__dict__.get("seed", None) + description = r.__dict__.get("description", None) + if description is not None: + if "placeholder" in description: + description = "placeholder" + elif "detailed" in description: + description = "detailed" + + if r.subject.species.label == "Rattus norvegicus": + species = "rat" + elif r.subject.species.label == "Mus musculus": + species = "mouse" + elif r.subject.species.label == "Homo sapiens": + species = "human" + else: + raise ValueError(f"Species {r.subject.species.label} not supported.") + + brain_region = r.brainLocation.brainRegion.label + + metadata = { + "emodel": emodel, + "etype": etype, + "mtype": mtype, + "ttype": ttype, + "species": species, + "iteration_tag": iteration_tag, + "brain_region": brain_region, + } + + nap = NexusAccessPoint( + **metadata, + project=PROJECT, + organisation=ORG, + endpoint=endpoint, + access_token=access_token, + forge_path=forge_path, + sleep_time=7, + ) + + # Download data from Nexus + print("Downloading data...") + model_configuration = nap.get_model_configuration() + nap.get_hoc() + nap.get_emodel() + + # Load the data and mechanism for simulation + folder_id = nap.get_emodel().emodel_metadata.as_string() + directory_path = f"./nexus_temp/{folder_id}" + load_mechanism(directory_path=directory_path) + hoc_file = Path(directory_path) / "model.hoc" + morph_file = nap.download_morphology(model_configuration.morphology.name, model_configuration.morphology.format, model_configuration.morphology.id) + holding_current, threshold_current = getHoldingThreshCurrent(directory_path) + + # Run the simulation + from bluecellulab import Cell + from bluecellulab import Simulation + from bluecellulab.circuit.circuit_access import EmodelProperties + from bluecellulab.simulation.neuron_globals import NeuronGlobals + + emodel_properties = EmodelProperties(threshold_current=threshold_current, + holding_current=holding_current) + + if threshold_current != 0: + print("The emodel uses threshold based amplitudes") + amplitudes = [x * threshold_current / 100 for x in amplitudes] + + fig, axes = plt.subplots(nrows=len(amplitudes), ncols=1, figsize=(10, 2*len(amplitudes))) + fig.suptitle(nap.get_emodel().emodel_metadata.emodel, fontsize=16) + print("Running simulation...") + for i, amp in enumerate(amplitudes): + cell = Cell(hoc_file, morph_file, template_format="v6", emodel_properties=emodel_properties) + sim = Simulation() + sim.add_cell(cell) + cell.add_step(start_time=550.0, stop_time=950.0, level=amp) # step current injection + NeuronGlobals.get_instance().temperature = TEMPERATURE + NeuronGlobals.get_instance().v_init = V_INIT + sim.run(1000, cvode=False, dt=0.025) + time, voltage = cell.get_time(), cell.get_soma_voltage() + if threshold_current != 0: + axes[i].plot(time, voltage, label=f"step_{amplitudes[i]}") + else: + axes[i].plot(time, voltage, label=f"step_{amp}") + axes[i].set_xlabel("Time (ms)") + axes[i].set_ylabel("Vm (mV)") + axes[i].legend(loc='upper right') + + if not os.path.exists("./figures"): + os.makedirs("./figures") + plt.tight_layout() + plt.savefig(f"./figures/{description}_{emodel}_{iteration_tag}_{seed}.png", dpi=300) + print("Simulation completed. Results saved in ./figures/") + + diff --git a/setup.py b/setup.py index 521dcee5..7026cf6e 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,7 @@ #!/usr/bin/env python """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -36,6 +36,11 @@ "sphinx-bluebrain-theme", ] +EXTRA_NEXUS = [ + "nexusforge>=0.8.2", + "entity_management>=1.2", + "pyJWT>=2.1.0", +] setup( name="bluepyemodel", @@ -73,9 +78,10 @@ ], extras_require={ "luigi": EXTRA_LUIGI, - "all": EXTRA_LUIGI + EXTRA_TEST, + "all": EXTRA_LUIGI + EXTRA_TEST + EXTRA_NEXUS, "docs": EXTRA_DOC + EXTRA_LUIGI, "test": EXTRA_TEST, + "nexus": EXTRA_NEXUS, }, packages=find_packages(exclude=("tests",)), include_package_data=True, diff --git a/tests/__init__.py b/tests/__init__.py index 59315a83..01bf878e 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/conftest.py b/tests/conftest.py index b697e9c4..d96266a5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,5 +1,5 @@ """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/functional_tests/__init__.py b/tests/functional_tests/__init__.py index 59315a83..01bf878e 100644 --- a/tests/functional_tests/__init__.py +++ b/tests/functional_tests/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/functional_tests/test_protocols.py b/tests/functional_tests/test_protocols.py index 3e6b6eef..cb505694 100644 --- a/tests/functional_tests/test_protocols.py +++ b/tests/functional_tests/test_protocols.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/functional_tests/test_protocols_from_nexus.py b/tests/functional_tests/test_protocols_from_nexus.py index c770785a..5fe82a2b 100644 --- a/tests/functional_tests/test_protocols_from_nexus.py +++ b/tests/functional_tests/test_protocols_from_nexus.py @@ -1,5 +1,5 @@ """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/functional_tests/test_validation.py b/tests/functional_tests/test_validation.py index 7d3a51c5..d0f8e3eb 100644 --- a/tests/functional_tests/test_validation.py +++ b/tests/functional_tests/test_validation.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/functional_tests/test_validation_from_nexus.py b/tests/functional_tests/test_validation_from_nexus.py index 6d806c8a..a7d6f22b 100644 --- a/tests/functional_tests/test_validation_from_nexus.py +++ b/tests/functional_tests/test_validation_from_nexus.py @@ -1,5 +1,5 @@ """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/test_models/__init__.py b/tests/test_models/__init__.py index 59315a83..01bf878e 100644 --- a/tests/test_models/__init__.py +++ b/tests/test_models/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/test_models/dummycells.py b/tests/test_models/dummycells.py index 8c73f22f..f145427d 100644 --- a/tests/test_models/dummycells.py +++ b/tests/test_models/dummycells.py @@ -1,7 +1,7 @@ """Dummy cell model used for testing""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/__init__.py b/tests/unit_tests/__init__.py index 59315a83..01bf878e 100644 --- a/tests/unit_tests/__init__.py +++ b/tests/unit_tests/__init__.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_data_utils.py b/tests/unit_tests/test_data_utils.py index d30a4319..878ffb3c 100644 --- a/tests/unit_tests/test_data_utils.py +++ b/tests/unit_tests/test_data_utils.py @@ -1,7 +1,7 @@ """Tests for EModelMetadata methods.""" """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_ecodes.py b/tests/unit_tests/test_ecodes.py index 573de61f..d0a8cd75 100644 --- a/tests/unit_tests/test_ecodes.py +++ b/tests/unit_tests/test_ecodes.py @@ -1,7 +1,7 @@ """ECodes tests.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_emodel_pipeline.py b/tests/unit_tests/test_emodel_pipeline.py index 1e1ab2ab..e0fd7013 100644 --- a/tests/unit_tests/test_emodel_pipeline.py +++ b/tests/unit_tests/test_emodel_pipeline.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -17,8 +17,10 @@ import pytest from bluepyemodel.access_point.local import LocalAccessPoint +from bluepyemodel.access_point.nexus import NexusAccessPoint from bluepyemodel.emodel_pipeline.emodel_pipeline import EModel_pipeline from tests.utils import DATA +from unittest.mock import patch @pytest.fixture @@ -37,12 +39,14 @@ def pipeline(): return pipe -def test_init(pipeline): +def test_init_local(pipeline): assert isinstance(pipeline.access_point, LocalAccessPoint) + + +def test_init_nexus_missing_project(): with pytest.raises( ValueError, - match="Attempted to set a legacy variable. " - "This variable should not be modified in new code.", + match= "Nexus project name is required for Nexus access point.", ): _ = EModel_pipeline( emodel="cADpyr_L5TPC", diff --git a/tests/unit_tests/test_emodelmetadata.py b/tests/unit_tests/test_emodelmetadata.py index d342193a..4ff774c9 100644 --- a/tests/unit_tests/test_emodelmetadata.py +++ b/tests/unit_tests/test_emodelmetadata.py @@ -1,7 +1,7 @@ """Tests for EModelMetadata methods.""" """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_evaluator.py b/tests/unit_tests/test_evaluator.py index d8e24133..aa0339a1 100644 --- a/tests/unit_tests/test_evaluator.py +++ b/tests/unit_tests/test_evaluator.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_fitness_calculator_configuration.py b/tests/unit_tests/test_fitness_calculator_configuration.py index f64a6bd4..3fd0cd81 100644 --- a/tests/unit_tests/test_fitness_calculator_configuration.py +++ b/tests/unit_tests/test_fitness_calculator_configuration.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_local_access_point.py b/tests/unit_tests/test_local_access_point.py index f4ab3209..8af9546c 100644 --- a/tests/unit_tests/test_local_access_point.py +++ b/tests/unit_tests/test_local_access_point.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_local_access_point_from_nexus.py b/tests/unit_tests/test_local_access_point_from_nexus.py index 3d44f32a..db9578a8 100644 --- a/tests/unit_tests/test_local_access_point_from_nexus.py +++ b/tests/unit_tests/test_local_access_point_from_nexus.py @@ -1,5 +1,5 @@ """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_model.py b/tests/unit_tests/test_model.py index 55d7bf57..7aea5976 100644 --- a/tests/unit_tests/test_model.py +++ b/tests/unit_tests/test_model.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_model_parameters_configuration.py b/tests/unit_tests/test_model_parameters_configuration.py index 04a1d999..9788b17e 100644 --- a/tests/unit_tests/test_model_parameters_configuration.py +++ b/tests/unit_tests/test_model_parameters_configuration.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_morphology_utils.py b/tests/unit_tests/test_morphology_utils.py index 4fc40977..f5f55bc6 100644 --- a/tests/unit_tests/test_morphology_utils.py +++ b/tests/unit_tests/test_morphology_utils.py @@ -1,7 +1,7 @@ """Tests for EModelMetadata methods.""" """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_nexus_access_point.py b/tests/unit_tests/test_nexus_access_point.py new file mode 100644 index 00000000..ab525154 --- /dev/null +++ b/tests/unit_tests/test_nexus_access_point.py @@ -0,0 +1,233 @@ +""" +Copyright 2023-2024 Blue Brain Project / EPFL + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +import pytest +from unittest.mock import PropertyMock, patch, Mock +from bluepyemodel.access_point.forge_access_point import NexusForgeAccessPoint, AccessPointException +from bluepyemodel.access_point.nexus import NexusAccessPoint +from datetime import datetime, timezone, timedelta +import logging + + +def jwt_payload(): + return { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + } + + +@pytest.fixture(autouse=True) +def mock_jwt_decode(): + with patch("jwt.decode") as mock_jwt: + mock_jwt.return_value = jwt_payload() + yield mock_jwt + + +@pytest.fixture +def mock_nexus_access_point(): + with patch("bluepyemodel.access_point.forge_access_point.NexusForgeAccessPoint.refresh_token") as mock_refresh, \ + patch.object(NexusForgeAccessPoint, "forge", new_callable=PropertyMock) as mock_forge_prop, \ + patch("bluepyemodel.access_point.nexus.get_brain_region_notation", return_value="SS") as mock_brain_region, \ + patch("bluepyemodel.access_point.nexus.NexusAccessPoint.get_pipeline_settings", return_value=Mock()) as mock_pipeline_settings, \ + patch("bluepyemodel.access_point.nexus.NexusAccessPoint.build_ontology_based_metadata") as mock_build_metadata: + + mock_refresh.return_value = (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + + mock_forge = Mock() + mock_resource = Mock() + mock_resource.id = '0' + mock_forge.resolve.return_value = mock_resource + mock_forge_prop.return_value = mock_forge + + mock_nexus_forge_access_point = NexusForgeAccessPoint( + project="test", + organisation="demo", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + access_token="test_token" + ) + + with patch("bluepyemodel.access_point.forge_access_point.NexusForgeAccessPoint", return_value=mock_nexus_forge_access_point): + yield NexusAccessPoint( + emodel="L5_TPC", + etype="cAC", + ttype="189_L4/5 IT CTX", + mtype="L5_TPC:B", + species="mouse", + brain_region="SSCX", + iteration_tag="v0", + project="test", + organisation="demo", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + forge_ontology_path=None, + access_token="test_token", + sleep_time=0 + ) + + +@pytest.fixture +def nexus_patches(): + with patch("bluepyemodel.access_point.nexus.get_brain_region_notation", return_value="SS") as mock_brain_region, \ + patch("bluepyemodel.access_point.nexus.NexusAccessPoint.get_pipeline_settings", return_value=Mock()) as mock_pipeline_settings, \ + patch("bluepyemodel.access_point.nexus.NexusAccessPoint.build_ontology_based_metadata") as mock_build_metadata: + yield mock_brain_region, mock_pipeline_settings, mock_build_metadata + + +def test_init(mock_nexus_access_point): + """ + Test the initialization of the NexusAccessPoint. + """ + emodel_metadata = mock_nexus_access_point.emodel_metadata + assert emodel_metadata.emodel == "L5_TPC" + assert emodel_metadata.etype == "cAC" + assert emodel_metadata.ttype == "189_L4/5 IT CTX" + assert emodel_metadata.mtype == "L5_TPC:B" + assert emodel_metadata.species == "mouse" + assert emodel_metadata.brain_region == "SSCX" + assert emodel_metadata.allen_notation == "SS" + assert emodel_metadata.iteration == "v0" + assert mock_nexus_access_point.forge_ontology_path is None + assert mock_nexus_access_point.sleep_time == 0 + + resolved_resource = mock_nexus_access_point.access_point.forge.resolve() + assert resolved_resource.id == '0' + + +@pytest.fixture +def mock_available_etypes(): + with patch.object(NexusForgeAccessPoint, 'available_etypes', new_callable=PropertyMock) as mock_etypes: + mock_etypes.return_value = ["0", "1", "2"] + yield mock_etypes + + +@pytest.fixture +def mock_available_mtypes(): + with patch.object(NexusForgeAccessPoint, 'available_mtypes', new_callable=PropertyMock) as mock_mtypes: + mock_mtypes.return_value = ["0", "1", "2"] + yield mock_mtypes + + +@pytest.fixture +def mock_available_ttypes(): + with patch.object(NexusForgeAccessPoint, 'available_ttypes', new_callable=PropertyMock) as mock_ttypes: + mock_ttypes.return_value = ["0", "1", "2"] + yield mock_ttypes + + +@pytest.fixture +def mock_check_mettypes_dependencies(): + with patch("bluepyemodel.access_point.nexus.ontology_forge_access_point") as mock_ontology_forge, \ + patch("bluepyemodel.access_point.nexus.check_resource") as mock_check_resource: + mock_ontology_forge.return_value = Mock() + yield mock_ontology_forge, mock_check_resource + + +def test_check_mettypes(mock_nexus_access_point, mock_available_etypes, mock_available_mtypes, mock_available_ttypes, mock_check_mettypes_dependencies, caplog): + """ + Test the check_mettypes function of the NexusAccessPoint. + """ + mock_ontology_forge, mock_check_resource = mock_check_mettypes_dependencies + + mock_nexus_access_point.emodel_metadata.etype = "cAC" + mock_nexus_access_point.emodel_metadata.mtype = None + mock_nexus_access_point.emodel_metadata.ttype = None + + with caplog.at_level(logging.INFO): + mock_nexus_access_point.check_mettypes() + + assert "Checking if etype cAC is present on nexus..." in caplog.text + assert "Etype checked" in caplog.text + assert "Mtype is None, its presence on Nexus is not being checked." in caplog.text + assert "Ttype is None, its presence on Nexus is not being checked." in caplog.text + + mock_ontology_forge.assert_called_once_with( + mock_nexus_access_point.access_point.access_token, + mock_nexus_access_point.forge_ontology_path + ) + + mock_check_resource.assert_any_call( + "cAC", + "etype", + access_point=mock_ontology_forge.return_value, + access_token=mock_nexus_access_point.access_point.access_token, + forge_path=mock_nexus_access_point.forge_ontology_path + ) + + +def test_get_nexus_subject_none(mock_nexus_access_point): + """ + Test get_nexus_subject with None as input. + """ + assert mock_nexus_access_point.get_nexus_subject(None) is None + + +def test_get_nexus_subject_human(mock_nexus_access_point): + """ + Test get_nexus_subject with 'human' as input. + """ + expected_subject = { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_9606", + "label": "Homo sapiens", + }, + } + assert mock_nexus_access_point.get_nexus_subject("human") == expected_subject + + +@pytest.mark.parametrize("species, expected_subject", [ + (None, None), + ("human", { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_9606", + "label": "Homo sapiens", + } + }), + ("mouse", { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_10090", + "label": "Mus musculus", + } + }), + ("rat", { + "type": "Subject", + "species": { + "id": "http://purl.obolibrary.org/obo/NCBITaxon_10116", + "label": "Rattus norvegicus", + } + }), +]) + + +def test_get_nexus_subject_parametrized(mock_nexus_access_point, species, expected_subject): + """ + Parametrized test for get_nexus_subject with different species inputs. + """ + assert mock_nexus_access_point.get_nexus_subject(species) == expected_subject + + +def test_get_nexus_subject_unknown_species(mock_nexus_access_point): + """ + Test get_nexus_subject with an unknown species input. + """ + with pytest.raises(ValueError, match="Unknown species unknown_species."): + mock_nexus_access_point.get_nexus_subject("unknown_species") diff --git a/tests/unit_tests/test_nexus_forge_access_point.py b/tests/unit_tests/test_nexus_forge_access_point.py new file mode 100644 index 00000000..18714422 --- /dev/null +++ b/tests/unit_tests/test_nexus_forge_access_point.py @@ -0,0 +1,180 @@ +""" +Copyright 2023-2024 Blue Brain Project / EPFL + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +import math +import pytest +from unittest.mock import Mock, patch +from bluepyemodel.access_point.forge_access_point import AccessPointException, NexusForgeAccessPoint, get_brain_region, get_brain_region_dict +from datetime import datetime, timezone, timedelta + +@pytest.fixture +def mock_forge_access_point(): + with patch("jwt.decode") as mock_jwt_decode: + mock_jwt_decode.return_value = { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + } + with patch("bluepyemodel.access_point.forge_access_point.NexusForgeAccessPoint.refresh_token") as mock_refresh_token: + mock_refresh_token.return_value = (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + with patch("bluepyemodel.access_point.forge_access_point.KnowledgeGraphForge") as mock_kg_forge: + return NexusForgeAccessPoint( + project="test", + organisation="demo", + endpoint="https://bbp.epfl.ch/nexus/v1", + forge_path=None, + access_token="test_token" + ) + + +def test_nexus_forge_access_point_init(mock_forge_access_point): + """ + Test the initialization of NexusForgeAccessPoint. + """ + assert mock_forge_access_point.bucket == "demo/test" + assert mock_forge_access_point.endpoint == "https://bbp.epfl.ch/nexus/v1" + assert mock_forge_access_point.access_token == "test_token" + assert mock_forge_access_point.agent.id == "https://bbp.epfl.ch/nexus/v1/realms/bbp/users/test_user" + + +def test_refresh_token_not_expired(mock_forge_access_point): + """ + Test refresh_token method when the token is not expired. + """ + future_exp = (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + with patch("jwt.decode") as mock_jwt_decode: + mock_jwt_decode.return_value = { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": future_exp + } + exp_timestamp = mock_forge_access_point.refresh_token() + assert math.isclose(exp_timestamp, future_exp, abs_tol=0.1) + + +def test_refresh_token_expired_offset(mock_forge_access_point, caplog): + """ + Test refresh_token method when the token is about to expire. + """ + future_exp = (datetime.now(timezone.utc) + timedelta(seconds=299)).timestamp() + new_future_exp = (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + with patch("jwt.decode") as mock_jwt_decode: + mock_jwt_decode.side_effect = [ + { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": future_exp + }, + { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": new_future_exp + } + ] + with patch.object(mock_forge_access_point, "get_access_token", return_value="new_test_token"): + with caplog.at_level("INFO"): + exp_timestamp = mock_forge_access_point.refresh_token() + assert math.isclose(exp_timestamp, new_future_exp, abs_tol=0.1) + assert "Nexus access token has expired, refreshing token..." in caplog.text + + +def test_refresh_token_expired(mock_forge_access_point, caplog): + """ + Test refresh_token method when the token has expired. + """ + past_exp = (datetime.now(timezone.utc) - timedelta(seconds=1)).timestamp() + new_future_exp = (datetime.now(timezone.utc) + timedelta(hours=1)).timestamp() + with patch("jwt.decode") as mock_jwt_decode: + mock_jwt_decode.side_effect = [ + { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": past_exp + }, + { + "preferred_username": "test_user", + "name": "Test User", + "email": "test_user@example.com", + "sub": "test_sub", + "exp": new_future_exp + } + ] + with patch.object(mock_forge_access_point, "get_access_token", return_value="new_test_token"): + with caplog.at_level("INFO"): + exp_timestamp = mock_forge_access_point.refresh_token() + assert math.isclose(exp_timestamp, new_future_exp, abs_tol=0.1) + assert "Nexus access token has expired, refreshing token..." in caplog.text + + +@pytest.fixture +def mock_get_brain_region_resolve(): + with patch("bluepyemodel.access_point.forge_access_point.ontology_forge_access_point") as mock_ontology_access_point: + mock_access_point = Mock() + mock_ontology_access_point.return_value = mock_access_point + + def resolve(brain_region, strategy, **kwargs): + if brain_region.lower() in ["somatosensory areas", "basic cell groups and regions", "mock_brain_region"]: + mock_resource = Mock() + mock_resource.id = "mock_id" + mock_resource.label = "mock_label" + return mock_resource + return None + + mock_access_point.resolve = resolve + yield mock_ontology_access_point, mock_access_point + + +def test_get_brain_region_found(mock_get_brain_region_resolve): + """ + Test get_brain_region function when the brain region is found. + """ + resource = get_brain_region("SSCX", access_token="test_token") + assert resource.id == "mock_id" + assert resource.label == "mock_label" + + +def test_get_brain_region_not_found(mock_get_brain_region_resolve): + """ + Test get_brain_region function when the brain region is not found. + """ + with pytest.raises(AccessPointException, match=r"Could not find any brain region with name UnknownRegion"): + get_brain_region("UnknownRegion", access_token="test_token") + + +def test_get_brain_region_dict(mock_get_brain_region_resolve): + """ + Test get_brain_region_dict function to ensure it returns the correct dictionary. + """ + _, mock_access_point = mock_get_brain_region_resolve + + mock_access_point.forge.as_json.return_value = { + "id": "mock_id", + "label": "mock_label" + } + + result = get_brain_region_dict("SSCX", access_token="test_token") + assert result["id"] == "mock_id" + assert result["label"] == "mock_label" diff --git a/tests/unit_tests/test_optimisation.py b/tests/unit_tests/test_optimisation.py index f6d534cf..9450549f 100644 --- a/tests/unit_tests/test_optimisation.py +++ b/tests/unit_tests/test_optimisation.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_plotting.py b/tests/unit_tests/test_plotting.py index 75ec2487..16b4dce1 100644 --- a/tests/unit_tests/test_plotting.py +++ b/tests/unit_tests/test_plotting.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_targets_configuration.py b/tests/unit_tests/test_targets_configuration.py index 183658ff..e57a76ac 100644 --- a/tests/unit_tests/test_targets_configuration.py +++ b/tests/unit_tests/test_targets_configuration.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_tools.py b/tests/unit_tests/test_tools.py index 7003c2cc..85e1cb84 100644 --- a/tests/unit_tests/test_tools.py +++ b/tests/unit_tests/test_tools.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/unit_tests/test_validation_functions.py b/tests/unit_tests/test_validation_functions.py index f21881af..222f67af 100644 --- a/tests/unit_tests/test_validation_functions.py +++ b/tests/unit_tests/test_validation_functions.py @@ -1,5 +1,5 @@ """ -Copyright 2023, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/tests/utils.py b/tests/utils.py index 192081af..382649b1 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -1,5 +1,5 @@ """ -Copyright 2024, EPFL/Blue Brain Project +Copyright 2023-2024 Blue Brain Project / EPFL Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.