Release 4.3.1 (#247)

Author: mboudet

CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 This changelog was started for release 4.2.0.
 
+
+## [4.3.1] - 2021-06-16
+
+### Fixed
+
+- Fixed an issue with categories
+- Fixed an issue with GFF import
+
 ## [4.3.0] - 2021-06-10
 
 ### Added
@@ -26,7 +34,6 @@ This changelog was started for release 4.2.0.
 - Now return the created file id (instead of celery task id) in the create file endpoint
 - Fixed Flask version to < 2.0.0 due to compatibility issues
 
-
 ### Fixed
 
 - Fixed the console restriction to admin/users (was not fully functional)

askomics/libaskomics/GffFile.py

@@ -162,6 +162,8 @@ def generate_rdf_content(self):
 
         total_lines = sum(1 for line in open(self.path))
         row_number = 0
+        feature_dict = {}
+        delayed_link = []
 
         for rec in GFF.parse(handle, limit_info=limit, target_lines=1):
 
@@ -196,9 +198,11 @@ def generate_rdf_content(self):
                     else:
                         entity = self.namespace_entity[self.format_uri(self.format_gff_entity(feature.qualifiers["ID"][0]))]
                         entity_label = self.format_gff_entity(feature.qualifiers["ID"][0])
+                        feature_dict[self.format_gff_entity(feature.qualifiers["ID"][0])] = feature.type
                 else:
                     entity = self.namespace_entity[self.format_uri(self.format_gff_entity(feature.id))]
                     entity_label = self.format_gff_entity(feature.id)
+                    feature_dict[self.format_gff_entity(feature.id)] = feature.type
 
                 self.graph_chunk.add((entity, rdflib.RDF.type, entity_type))
                 self.graph_chunk.add((entity, rdflib.RDFS.label, rdflib.Literal(entity_label)))
@@ -298,19 +302,41 @@ def generate_rdf_content(self):
                 for qualifier_key, qualifier_value in feature.qualifiers.items():
 
                     for value in qualifier_value:
+                        skip = False
 
                         if qualifier_key in ("Parent", "Derives_from"):
+                            if len(value.split(":")) == 1:
+                                # The entity is not in the value, try to detect it
+                                if value in feature_dict:
+                                    related_type = feature_dict[value]
+                                    related_qualifier_key = qualifier_key + "_" + related_type
+                                else:
+                                    # Do this later
+                                    delayed_link.append({
+                                        "uri": self.namespace_data[self.format_uri(qualifier_key)],
+                                        "label": rdflib.Literal(qualifier_key),
+                                        "type": [rdflib.OWL.ObjectProperty, self.namespace_internal[self.format_uri("AskomicsRelation")]],
+                                        "domain": entity_type,
+                                        "range": value,
+                                        "qualifier_key": qualifier_key,
+                                        "feature_type": feature.type
+                                    })
+                                    skip = True
+                            else:
+                                related_type = value.split(":")[0]
+                                related_qualifier_key = qualifier_key + "_" + related_type
+
                             relation = self.namespace_data[self.format_uri(qualifier_key)]
                             attribute = self.namespace_data[self.format_uri(self.format_gff_entity(value))]
 
-                            if (feature.type, qualifier_key) not in attribute_list:
-                                attribute_list.append((feature.type, qualifier_key))
+                            if not skip and (feature.type, related_qualifier_key) not in attribute_list:
+                                attribute_list.append((feature.type, related_qualifier_key))
                                 self.attribute_abstraction.append({
                                     "uri": self.namespace_data[self.format_uri(qualifier_key)],
                                     "label": rdflib.Literal(qualifier_key),
                                     "type": [rdflib.OWL.ObjectProperty, self.namespace_internal[self.format_uri("AskomicsRelation")]],
                                     "domain": entity_type,
-                                    "range": self.namespace_data[self.format_uri(value.split(":")[0])]
+                                    "range": self.namespace_data[self.format_uri(related_type)]
                                 })
 
                         else:
@@ -363,3 +389,13 @@ def generate_rdf_content(self):
                         self.graph_chunk.add((entity, self.namespace_internal["includeInReference"], block_reference))
 
                 yield
+
+        # Add missing abstractions
+        for link in delayed_link:
+            if link["range"] in feature_dict:
+                entity_type = feature_dict[link['range']]
+                related_qualifier_key = link.pop("qualifier_key") + "_" + entity_type
+                feature_type = link.pop("feature_type")
+                if (feature_type, related_qualifier_key) not in attribute_list:
+                    link['range'] = self.namespace_data[self.format_uri(entity_type)]
+                    self.attribute_abstraction.append(link)

askomics/libaskomics/SparqlQuery.py

@@ -1280,20 +1280,17 @@ def build_query_from_json(self, preview=False, for_editor=False):
                 # values
                 if attribute["filterSelectedValues"] != [] and not attribute["optional"] and not attribute["linked"]:
                     uri_val_list = []
-                    for value in attribute["filterSelectedValues"]:
-                        if attribute["faldo"] and attribute["faldo"].endswith("faldoStrand"):
-                            value_var = faldo_strand
-                            uri_val_list.append("<{}>".format(value))
+                    if attribute["faldo"] and attribute["faldo"].endswith("faldoStrand"):
+                        value_var = faldo_strand
+                    else:
+                        value_var = category_value_uri
+                    uri_val_list = ["<{}>".format(value) for value in attribute["filterSelectedValues"]]
+                    if uri_val_list:
+                        if attribute["exclude"]:
+                            filter_string = "FILTER ( {} NOT IN ( {} ) ) .".format(value_var, " ,".join(uri_val_list))
+                            self.store_filter(filter_string, block_id, sblock_id, pblock_ids)
                         else:
-                            value_var = category_value_uri
-                            uri_val_list.append("<{}>".format(value))
-
-                        if uri_val_list:
-                            if attribute["exclude"]:
-                                filter_string = "FILTER ( {} NOT IN ( {} ) ) .".format(value_var, " ,".join(uri_val_list))
-                                self.store_filter(filter_string, block_id, sblock_id, pblock_ids)
-                            else:
-                                self.store_value("VALUES {} {{ {} }}".format(value_var, ' '.join(uri_val_list)), block_id, sblock_id, pblock_ids)
+                            self.store_value("VALUES {} {{ {} }}".format(value_var, ' '.join(uri_val_list)), block_id, sblock_id, pblock_ids)
 
                 if attribute["linked"]:
                     var_2 = self.format_sparql_variable("{}{}_{}Category".format(

package-lock.json

@@ -8,7 +8,7 @@
     "ontology"
   ],
   "name": "AskOmics",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "description": "Visual SPARQL query builder",
   "author": "Xavier Garnier",
   "license": "AGPL-3.0",

package.json

@@ -5,7 +5,7 @@
 
 setup(
     name='askomics',
-    version='4.3.0',
+    version='4.3.1',
     description='''
         AskOmics is a visual SPARQL query interface supporting both intuitive
         data integration and querying while shielding the user from most of the