def delete(self, nanopub: Nanopublication) -> dict: """ Realiza la eliminacion de la nanopublicacion pasada """ if nanopub != None: nanopub.delete() return {"status": "ok"} return {"status": "error"}
def get_term_stats( self, protocol: str = None, users: list = None, tags: list = None ) -> list: """ retorna las estadisticas de uso de de las terminos para el protocolo si este se envia, (en caso de no enviarlo se calcula de forma global) [\n "related":[ { "term":<term>, "uris":[ {"label":<uri>,"count":<use> } ] } ], "used": [{ "label":<term>, "count":<number of use> }] \n] """ not_step_tag_filter = [NanopublicationRepository.TAG_FILTER("step", False)] pipeline = NanopublicationRepository._with_protocol_filter( pipeline=[ {"$unwind": "$components"}, { "$facet": { "used": not_step_tag_filter + self.TERM_USED, "related": not_step_tag_filter + self.TERM_RELATED, } }, ], protocol=protocol, tags=tags, users=users, ) return list(Nanopublication.objects().aggregate(pipeline))
def save(self, nanopub: Nanopublication) -> Nanopublication: """ Realiza el almacenado de la nanopublicacion pasada """ if nanopub != None: return nanopub.save() return None
def __export_nanopublication( self, nanopub: Nanopublication, json: bool = False, rdf_format: str = None, temp_rdf: bool = False, ): if nanopub != None: if rdf_format != None and rdf_format != "trig": nanopub.rdf_raw = DBNanopub( db_nano_pub=nanopub, settings=self.settings, from_db_rdf=(not temp_rdf)).serialize(rdf_format) return nanopub.to_json_map() if json else nanopub else: return {"error": "not-found"}
def get_nanopub_by_artifact_code(self, artifact_code: str) -> Nanopublication: """ retorna la primera Nanopublication relacionada al artifact_code pasado, este se relaciona con el PublicationInfo.artifact_code de la misma """ db_nanopub = Nanopublication.objects( publication_info__artifact_code=artifact_code ).first() return self.__load_workflows_of_nanopub(nanopub=db_nanopub)
def get_nanopubs_by_protocol(self, protocol: str) -> list: """ retorna la lista de nanopublicaciones asociadas a la uri del protocolo pasado """ return list( map( (lambda nanopub: self.__load_workflows_of_nanopub(nanopub=nanopub)), Nanopublication.objects(protocol=protocol), ) )
def __load_workflows_of_nanopub(self, nanopub: Nanopublication) -> list: """ shortcut and validator to load associated workflows of passed nanopub """ if self.workflows_repository != None and nanopub != None: workflows = self.workflows_repository.get_workflows_of_nanopub( nanopub_id=nanopub.id ) nanopub.workflows = workflows return nanopub
def get_nanopub( self, id: str, protocol=None, default: Nanopublication = None ) -> Nanopublication: """ Realiza la consulta de la nanopublicacion asociada a los filtros pasados. en caso de la consulta no retornar un valor se retornara el default pasado """ query = {"id": id} if protocol != None: query["protocol"] = protocol db_nanopub = Nanopublication.objects(**query).first() if db_nanopub != None: self.__load_workflows_of_nanopub(db_nanopub) return db_nanopub return default
def get_nanopubs_by_author_stats(self, protocol: str = None): """ returns the amount of annotations make for user in a protocol if this is sended otherwise returns for all protocols [\n { "label":<author>, "count":<number of nano publications> } \n] """ pipeline = NanopublicationRepository._with_protocol_filter( pipeline=[ {"$group": {"_id": "$author", "count": {"$sum": 1}}}, {"$project": {"_id": 0, "label": "$_id", "count": "$count"}}, ], protocol=protocol, ) return list(Nanopublication.objects().aggregate(pipeline))
def get_ontologies_stats( self, protocol: str = None, users: list = None, tags: list = None ) -> list: """ retorna las estadisticas de uso de de las ontologias para el protocolo si este se envia, (en caso de no enviarlo se calcula de forma global) [\n { "label":<tag>, "count":<number of use> } \n] """ pipeline = NanopublicationRepository._with_protocol_filter( pipeline=[{"$unwind": "$components"}] + self.GROUP_BY_ONTOLOGIES, protocol=protocol, users=users, tags=tags, ) return list(Nanopublication.objects().aggregate(pipeline))
def get_essential_stats( self, protocol: str = None, users: list = None, tags: list = None ): """ retorna las estadisticas esenciales del protocolo si este se envia. (en caso de no enviarlo se calcula de forma global) esta incluye estadisticas de tags, ontologias, terminos [\n { "ontologies": [{ "label":<tag>, "count":<number of use> }], "tags": [{ "label":<tag>, "count":<number of use> }], "terms": { "related":[ { "term":<term>, "uris":[ {"label":<uri>,"count":<use> } ] } ], "used": [{ "label":<term>, "count":<number of use> }] } } \n] """ not_step_tag_filter = [NanopublicationRepository.TAG_FILTER("step", False)] pipeline = NanopublicationRepository._with_protocol_filter( pipeline=[ {"$unwind": {"path": "$components"}}, { "$facet": { "tags": NanopublicationRepository.GROUP_BY_TAGS(tags), "ontologies": self.GROUP_BY_ONTOLOGIES, "terms_used": not_step_tag_filter + self.TERM_USED, "terms_related": not_step_tag_filter + self.TERM_RELATED, } }, { "$project": { "tags": 1, "ontologies": 1, "terms": {"used": "$terms_used", "related": "$terms_related"}, } }, ], protocol=protocol, users=users, tags=tags, ) return list(Nanopublication.objects().aggregate(pipeline))
def all_nanopubs_metadata(self, size: int = 10) -> list: """ returns all nanopubs metadata """ pipeline = [ { "$group": {"_id": "1", "count": {"$sum": 1}}}, { "$project": { "_id": 0, "totalRecords": "$count", "page": {"$literal": 1}, "size": {"$literal": size}, } } ] empty = { "totalRecords": 0, "page": 1, "size": size } data = list(Nanopublication.objects().aggregate(pipeline)) return data[0] if len(data) == 1 else empty
def nanopubs_stats( self, protocol: str = None, users: list = None, tags: list = None, page: int = 1 ) -> list: conditions = NanopublicationRepository._with_protocol_filter( pipeline=[{"$unwind": "$components"}], protocol=protocol, tags=tags, users=users, ) projection = [ { "$project": { "_id": 0, "id": "$components.id", "text": "$components.term", "tag": NanopublicationRepository.GENERIC_REDUCE("$components.tags"), "text_position": { "$concat": [ {"$toString": "$components.text_position.start"}, ",", {"$toString": "$components.text_position.end"}, ] }, "ontologies": NanopublicationRepository.GENERIC_REDUCE( "$components.ontologies_info.url" ), "ontologies_label": NanopublicationRepository.GENERIC_REDUCE( "$components.ontologies_info.label" ), "ontologies_term": NanopublicationRepository.GENERIC_REDUCE( "$components.ontologies_info.term" ), } } ] (empty, pipeline) = NanopublicationRepository._with_pagination( projection=projection, conditions=conditions, page=page, size=40 ) data = list(Nanopublication.objects().aggregate(pipeline)) return data[0] if len(data) == 1 else empty
def all_nanopubs(self, page: int = 1, size: int = 10, projection_mode:str = None) -> list: """ returns all nanopubs with pagination """ projection = [] if projection_mode == "publication": projection = [ { "$project": { "_id": 0, "publication_info": "$publication_info" } } ] (empty, pipeline) = NanopublicationRepository._with_pagination( projection=projection, conditions=[], page=page, size=size, ) data = list(Nanopublication.objects().aggregate(pipeline)) return data[0] if len(data) == 1 else empty
def __update_nanopub_and_protocol(self, request: NanopubRequest) -> tuple: """ realiza la actualizacion o creacion de la nanopublicacion y su protocolo realacionado, constuyendo esta a partir de los datos del Nanopubrequest\n (los cambios realizados se persistiran)\n retorna una tupla donde el primer parametro es el protocolo(Protocol) seguido de la nanopublicacion(Nanopublication) """ clean_url = clean_url_with_settings(url=request.url, settings=self.settings) protocol = self.protocols_repo.get_protocol( uri=clean_url, default=Protocol.fromAnnotation(request.step, settings=self.settings), ) nanopublication = self.nanopubs_repo.get_nanopub( protocol=protocol, id=request.id, default=Nanopublication( id=request.id, protocol=protocol, author=request.user, generatedAtTime=request.step.created, ), ) # iterator for load bio_annotations def components_iterator(component, annotation): bio_annotations = list( map( lambda ontology: BioPortalService.annotation_parse(ontology ), self.assertion_strategy.bio_annotations( annotation=annotation, full=True), )) component.rel_uris = list( map(lambda ontology: ontology["id"], bio_annotations)) component.ontologies_info = list( map( lambda ontology: OntologyInfo( label=ontology["ontologyLabel"], url=ontology["id"], term=ontology["prefLabel"], selector=ontology["selector"][0], ), bio_annotations, )) return component # aply new changes in nanopub nanopublication.components = NanopublicationComponent.fromAnnotations( annotations=request.annotations, iterator=components_iterator) # previous nanopub uri if exist previous_nanopub_uri = (nanopublication.publication_info.nanopub_uri if nanopublication.publication_info != None else None) # nanopublication remote registration rdf_nanopub = DBNanopub(db_nano_pub=nanopublication, settings=self.settings) nanopublication.publication_info = self._publish_fairworksflows_nanopub( rdf_nanopub) # fetch remote rdf for local mirror if nanopublication.publication_info != None: rdf_nanopub = DBNanopub( db_nano_pub=nanopublication, settings=self.settings, np_client=self.nanopubremote, ) nanopublication.rdf_raw = rdf_nanopub.serialize("trig") # persist data self.nanopubs_repo.save(nanopub=nanopublication) self.protocols_repo.save(protocol=protocol) # retraction of previous remote nanopublication if previous_nanopub_uri != None: self._retract_fairworksflows_nanopub( nanopub_uri=previous_nanopub_uri) return (protocol, nanopublication)