Merge 7a0677e into 0fe36d1

.github/workflows/github-publish-celery-flaskomics.yml

@@ -1,4 +1,4 @@
-name: Publish Flaskomics Docker image to github 
+name: Publish Flaskomics Docker image to github
 
 on:
   push:
@@ -14,13 +14,14 @@ env:
 
 jobs:
   build-and-push-image:
+    if: github.repository == 'askomics/flaskomics'
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
 
     steps:
-      - 
+      -
         name: Checkout repository
         uses: actions/checkout@v3
 
@@ -60,7 +61,7 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
-          file: ./docker/DockerfileCelery 
+          file: ./docker/DockerfileCelery
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

.github/workflows/github-publish-flaskomics.yml

@@ -1,4 +1,4 @@
-name: Publish Flaskomics Docker image to github 
+name: Publish Flaskomics Docker image to github
 
 on:
   push:
@@ -14,13 +14,14 @@ env:
 
 jobs:
   build-and-push-image:
+    if: github.repository == 'askomics/flaskomics'
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
 
     steps:
-      - 
+      -
         name: Checkout repository
         uses: actions/checkout@v3
 

CHANGELOG.md

@@ -26,6 +26,8 @@ This changelog was started for release 4.2.0.
 - Fixed Gff Faldo integration (was only integrating the last selected entity)
 - Fixed an issue when using filters and an 'UNION' node
 - Fixed an issue when launching a query with a 'linked' attribute toggled but unselected
+- Fixed missing includeIn and includeInReference in bed files
+- Fixed 'overlap_with' faldo query
 
 ### Changed
 

askomics/libaskomics/BedFile.py

@@ -110,12 +110,12 @@ def set_rdf_abstraction_domain_knowledge(self):
             # Domain Knowledge
             if "values" in attribute.keys():
                 for value in attribute["values"]:
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDF.type, self.namespace_data[self.format_uri("{}CategoryValue".format(attribute["label"]))]))
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDFS.label, rdflib.Literal(value)))
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri("{}Category".format(attribute["label"]))], self.namespace_internal[self.format_uri("category")], self.namespace_data[self.format_uri(value)]))
-
+                    o = self.namespace_data[self.format_uri(value)]
                     if attribute["label"] == rdflib.Literal("strand"):
-                        self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDF.type, self.get_faldo_strand(value)))
+                        o = self.get_faldo_strand(value)
+                    self.graph_abstraction_dk.add((o, rdflib.RDF.type, self.namespace_data[self.format_uri("{}CategoryValue".format(attribute["label"]))]))
+                    self.graph_abstraction_dk.add((o, rdflib.RDFS.label, rdflib.Literal(value)))
+                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri("{}Category".format(attribute["label"]))], self.namespace_internal[self.format_uri("category")], o))
 
         # Faldo:
         if self.faldo_entity:
@@ -306,4 +306,19 @@ def generate_rdf_content(self):
                 self.graph_chunk.add((begin, rdflib.RDF.type, faldo_strand))
                 self.graph_chunk.add((end, rdflib.RDF.type, faldo_strand))
 
+            # blocks
+            block_base = self.settings.getint("triplestore", "block_size")
+            block_start = int(self.convert_type(feature.start + 1)) // block_base
+            block_end = int(self.convert_type(feature.end)) // block_base
+
+            for slice_block in range(block_start, block_end + 1):
+                self.graph_chunk.add((entity, self.namespace_internal['includeIn'], rdflib.Literal(int(slice_block))))
+                block_reference = self.rdfize(self.format_uri("{}_{}".format(feature.chrom, slice_block)))
+                self.graph_chunk.add((entity, self.namespace_internal["includeInReference"], block_reference))
+                if faldo_strand:
+                    self.graph_chunk.add((entity, self.namespace_internal["includeInStrand"], faldo_strand))
+                    strand_ref = self.get_reference_strand_uri(feature.chrom, faldo_strand, slice_block)
+                    for sref in strand_ref:
+                        self.graph_chunk.add((entity, self.namespace_internal["includeInReferenceStrand"], sref))
+
             yield

askomics/libaskomics/CsvFile.py

@@ -367,11 +367,11 @@ def set_rdf_domain_knowledge(self):
                 p = self.namespace_internal["category"]
                 for value in self.category_values[self.header[index]]:
                     o = self.rdfize(value)
+                    if self.columns_type[index] == "strand":
+                        o = self.get_faldo_strand(value)
                     self.graph_abstraction_dk.add((s, p, o))
                     self.graph_abstraction_dk.add((o, rdflib.RDF.type, self.namespace_data["{}CategoryValue".format(self.format_uri(self.header[index]))]))
                     self.graph_abstraction_dk.add((o, rdflib.RDFS.label, rdflib.Literal(value)))
-                    if self.columns_type[index] == "strand":
-                        self.graph_abstraction_dk.add((o, rdflib.RDF.type, self.get_faldo_strand(value)))
 
     def set_rdf_abstraction(self):
         """Set the abstraction"""
@@ -617,8 +617,9 @@ def generate_rdf_content(self):
                     # Category
                     elif current_type in ('category', 'reference', 'strand'):
                         potential_relation = self.rdfize(current_header)
-                        if not cell:
-                            cell = "unknown/both"
+                        if current_type == "strand":
+                            # Override csv value, use "proper" values
+                            cell = self.get_faldo_strand_label(cell)
                         if current_header not in self.category_values.keys():
                             # Add the category in dict, and the first value in a set
                             self.category_values[current_header] = {cell, }
@@ -708,5 +709,14 @@ def generate_rdf_content(self):
                         if reference:
                             block_reference = self.rdfize(self.format_uri("{}_{}".format(reference, slice_block)))
                             self.graph_chunk.add((entity, self.namespace_internal["includeInReference"], block_reference))
+                            if faldo_strand:
+                                strand_ref = self.get_reference_strand_uri(reference, faldo_strand, slice_block)
+                                for sref in strand_ref:
+                                    self.graph_chunk.add((entity, self.namespace_internal["includeInReferenceStrand"], sref))
+                        if faldo_strand:
+                            self.graph_chunk.add((entity, self.namespace_internal["includeInStrand"], faldo_strand))
+                            if faldo_strand == self.faldo.BothStrandPosition:
+                                self.graph_chunk.add((entity, self.namespace_internal["includeInStrand"], self.faldo.ForwardStrandPosition))
+                                self.graph_chunk.add((entity, self.namespace_internal["includeInStrand"], self.faldo.ReverseStrandPosition))
 
                 yield

askomics/libaskomics/Database.py

@@ -270,6 +270,7 @@ def create_results_table(self):
             template boolean,
             has_form_attr boolean,
             form boolean,
+            version text,
             FOREIGN KEY(user_id) REFERENCES users(user_id)
         )
         '''
@@ -355,6 +356,17 @@ def update_results_table(self):
         except Exception:
             pass
 
+        query = '''
+        ALTER TABLE results
+        ADD version text NULL
+        DEFAULT(NULL)
+        '''
+
+        try:
+            self.execute_sql_query(query)
+        except Exception:
+            pass
+
     def create_endpoints_table(self):
         """Create the endpoints table"""
         query = '''

askomics/libaskomics/File.py

@@ -436,6 +436,39 @@ def get_faldo_strand(self, raw_strand):
 
         return self.faldo.BothStrandPosition
 
+    def get_faldo_strand_label(self, raw_strand):
+        """Get faldo strand label
+
+        Parameters
+        ----------
+        raw_strand : string
+            raw value of strand
+
+        Returns
+        -------
+        label
+            "+", "-", or "."
+        """
+
+        if raw_strand in ("+", "plus", "1", "positive", "forward"):
+            return "+"
+
+        if raw_strand in ("-", "minus", "moins", "-1", "reverse", "negative"):
+            return "-"
+
+        return "."
+
+    def get_reference_strand_uri(self, reference, strand, block):
+        faldo_dict = {
+            self.faldo.ForwardStrandPosition: "ForwardStrand",
+            self.faldo.ReverseStrandPosition: "ReverseStrand",
+            self.faldo.BothStrandPosition: "BothStrand"
+        }
+        if strand == self.faldo.BothStrandPosition:
+            return [self.rdfize(self.format_uri("{}_s{}_{}".format(reference, dstrand, block))) for dstrand in faldo_dict.values()]
+
+        return [self.rdfize(self.format_uri("{}_s{}_{}".format(reference, faldo_dict[strand], block)))]
+
     def get_rdf_type(self, value):
         """get xsd type of a value
 

askomics/libaskomics/GffFile.py

@@ -144,13 +144,12 @@ def set_rdf_abstraction_domain_knowledge(self):
             # Domain Knowledge
             if "values" in attribute.keys():
                 for value in attribute["values"]:
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDF.type, self.namespace_data[self.format_uri("{}CategoryValue".format(attribute["label"]))]))
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDFS.label, rdflib.Literal(value)))
-                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri("{}Category".format(attribute["label"]))], self.namespace_internal[self.format_uri("category")], self.namespace_data[self.format_uri(value)]))
-
+                    o = self.namespace_data[self.format_uri(value)]
                     if attribute["label"] == rdflib.Literal("strand"):
-                        self.graph_abstraction_dk.add((self.namespace_data[self.format_uri(value)], rdflib.RDF.type, self.get_faldo_strand(value)))
-
+                        o = self.get_faldo_strand(value)
+                    self.graph_abstraction_dk.add((o, rdflib.RDF.type, self.namespace_data[self.format_uri("{}CategoryValue".format(attribute["label"]))]))
+                    self.graph_abstraction_dk.add((o, rdflib.RDFS.label, rdflib.Literal(value)))
+                    self.graph_abstraction_dk.add((self.namespace_data[self.format_uri("{}Category".format(attribute["label"]))], self.namespace_internal[self.format_uri("category")], o))
         # Faldo:
         if self.faldo_entity:
             for key, values in self.faldo_abstraction.items():
@@ -412,15 +411,20 @@ def generate_rdf_content(self):
                     self.graph_chunk.add((begin, rdflib.RDF.type, faldo_strand))
                     self.graph_chunk.add((end, rdflib.RDF.type, faldo_strand))
 
-                    # blocks
-                    block_base = self.settings.getint("triplestore", "block_size")
-                    block_start = int(self.convert_type(feature.location.start)) // block_base
-                    block_end = int(self.convert_type(feature.location.end)) // block_base
-
-                    for slice_block in range(block_start, block_end + 1):
-                        self.graph_chunk.add((entity, self.namespace_internal['includeIn'], rdflib.Literal(int(slice_block))))
-                        block_reference = self.rdfize(self.format_uri("{}_{}".format(rec.id, slice_block)))
-                        self.graph_chunk.add((entity, self.namespace_internal["includeInReference"], block_reference))
+                # blocks
+                block_base = self.settings.getint("triplestore", "block_size")
+                block_start = int(self.convert_type(feature.location.start)) // block_base
+                block_end = int(self.convert_type(feature.location.end)) // block_base
+
+                for slice_block in range(block_start, block_end + 1):
+                    self.graph_chunk.add((entity, self.namespace_internal['includeIn'], rdflib.Literal(int(slice_block))))
+                    block_reference = self.rdfize(self.format_uri("{}_{}".format(rec.id, slice_block)))
+                    self.graph_chunk.add((entity, self.namespace_internal["includeInReference"], block_reference))
+                    if faldo_strand:
+                        self.graph_chunk.add((entity, self.namespace_internal["includeInStrand"], faldo_strand))
+                        strand_ref = self.get_reference_strand_uri(rec.id, faldo_strand, slice_block)
+                        for sref in strand_ref:
+                            self.graph_chunk.add((entity, self.namespace_internal["includeInReferenceStrand"], sref))
 
                 yield
 

askomics/libaskomics/Result.py

@@ -9,6 +9,8 @@
 from askomics.libaskomics.Params import Params
 from askomics.libaskomics.Utils import Utils
 
+from pkg_resources import get_distribution
+
 
 class Result(Params):
     """Result represent a query result file
@@ -381,6 +383,7 @@ def save_in_db(self, start=None):
             ?,
             ?,
             ?,
+            ?,
             ?
         )
         '''
@@ -396,7 +399,8 @@ def save_in_db(self, start=None):
             json.dumps({"graphs": self.graphs, "endpoints": self.endpoints}),
             False,
             self.session["user"]["admin"] and any([attrib.get("form") for attrib in self.graph_state["attr"]]) if (self.graph_state and self.graph_state.get("attr")) else False,
-            False
+            False,
+            get_distribution('askomics').version
         ), get_id=True)
 
         return self.id