Merge pull request #88 from omics-datascience/update/differential_expression_param_csv

Update/differential expression param csv

Author: Genarito

src/differential_expression/admin.py

@@ -61,31 +61,18 @@ class DifferentialExpressionExperimentResultAdmin(admin.ModelAdmin):
     """Admin configuration for DifferentialExpressionExperimentResult model."""
 
     list_display = (
-        'id', 'experiment', 'gene', 'adj_p_val', 'log_fc', 
-        'p_value', 'ave_expr', 'is_significant_display'
+        'id', 'experiment', 'gene', 'adj_p_val', 'log_fc',
+        'p_value', 'ave_expr'
     )
     list_filter = ('experiment__state', 'experiment__user')
     search_fields = ('gene', 'experiment__name', 'experiment__user__username')
-    readonly_fields = ('id', 'is_significant_display')
-    
+    readonly_fields = ('id',)
+
     fieldsets = (
         ('Basic Information', {
             'fields': ('id', 'experiment', 'gene')
         }),
         ('Statistical Results', {
             'fields': ('p_value', 'adj_p_val', 'log_fc', 'ave_expr', 't_statistic', 'b_statistic')
         }),
-        ('Significance', {
-            'fields': ('is_significant_display',),
-            'classes': ('collapse',)
-        }),
     )
-    
-    def is_significant_display(self, obj):
-        """Display if the gene is significant with default thresholds."""
-        try:
-            return obj.is_significant()
-        except:
-            return False
-    is_significant_display.short_description = 'Is Significant (p<0.05, |logFC|>1)'
-    is_significant_display.boolean = True

src/differential_expression/models.py

@@ -231,10 +231,4 @@ class Meta:
     def __str__(self):
         return f"{self.gene} - {self.experiment.name}"
 
-    def is_significant(self, p_threshold=0.05, fc_threshold=1.0):
-        """Check if this gene is significantly differentially expressed."""
-        return (self.adj_p_val is not None and
-                self.log_fc is not None and
-                self.adj_p_val <= p_threshold and
-                abs(self.log_fc) >= fc_threshold)
 

src/differential_expression/serializers.py

@@ -31,17 +31,9 @@ class DifferentialExpressionExperimentResultSerializer(serializers.ModelSerializ
     """
     Serializer for Differential Expression Experiment Results.
     """
-    is_significant = serializers.SerializerMethodField()
-
     class Meta:
         model = DifferentialExpressionExperimentResult
-        fields = ['id', 'gene', 'ave_expr', 'p_value', 'adj_p_val', 'log_fc', 't_statistic', 'b_statistic',
-                  'is_significant']
-
-    @staticmethod
-    def get_is_significant(obj):
-        """Check if this gene is significantly differentially expressed."""
-        return obj.adj_p_val <= 0.05 and abs(obj.log_fc) >= 1.0
+        fields = ['id', 'gene', 'ave_expr', 'p_value', 'adj_p_val', 'log_fc', 't_statistic', 'b_statistic']
 
 
 class DifferentialExpressionVolcanoPlotSerializer(serializers.ModelSerializer):

src/differential_expression/views.py

@@ -757,8 +757,9 @@ def download_differential_expression_results(request, pk: int):
     """
     Downloads all the differential expression results for a specific experiment.
     Returns a TSV file with all results (no pagination).
-    Supports optional filtering via query parameter:
-    - p_value: adjusted p-value threshold (returns genes with adj_p_val <= p_value)
+    Supports optional filtering via query parameters:
+    - adj_p_val: adjusted p-value threshold (returns genes with adj_p_val <= adj_p_val)
+    - log_fc: log fold change threshold (returns genes with |log_fc| >= log_fc)
     """
     experiment = get_object_or_404(DifferentialExpressionExperiment, pk=pk)
 
@@ -770,28 +771,46 @@ def download_differential_expression_results(request, pk: int):
             experiment.shared_users.filter(id=user.id).exists()):
         return HttpResponse('Unauthorized', status=401)
 
-    # Get filter parameter from query string
-    p_value = request.GET.get('p_value')
+    # Get filter parameters from query string
+    adj_p_val = request.GET.get('adj_p_val')
+    log_fc = request.GET.get('log_fc')
 
-    # Apply filter if provided
-    if p_value is not None:
+    results = experiment.results.all()
+    filename_suffix = ''
+
+    # Apply adj_p_val filter if provided
+    if adj_p_val is not None:
         try:
-            p_value = float(p_value)
+            adj_p_val = float(adj_p_val)
         except ValueError:
-            return HttpResponse('Invalid p_value. Must be numeric.', status=400)
+            return HttpResponse('Invalid adj_p_val. Must be numeric.', status=400)
 
-        # Validate p_value
-        if p_value < 0 or p_value > 1:
-            return HttpResponse('p_value must be between 0 and 1', status=400)
+        if adj_p_val < 0 or adj_p_val > 1:
+            return HttpResponse('adj_p_val must be between 0 and 1', status=400)
 
-        # Filter results: adj_p_val <= p_value (significant genes)
-        results = experiment.results.filter(adj_p_val__lte=p_value).order_by('adj_p_val')
-        filename_suffix = f'_filtered_p{p_value}'
-    else:
-        # Get all results (no filtering)
-        results = experiment.results.all().order_by('adj_p_val')
+        results = results.filter(adj_p_val__lte=adj_p_val)
+        filename_suffix += f'_p{adj_p_val}'
+
+    # Apply log_fc filter if provided
+    if log_fc is not None:
+        try:
+            log_fc = float(log_fc)
+        except ValueError:
+            return HttpResponse('Invalid log_fc. Must be numeric.', status=400)
+
+        if log_fc < 0:
+            return HttpResponse('log_fc must be >= 0', status=400)
+
+        results = results.filter(
+            Q(log_fc__gte=log_fc) | Q(log_fc__lte=-log_fc)
+        )
+        filename_suffix += f'_fc{log_fc}'
+
+    if not filename_suffix:
         filename_suffix = '_all'
 
+    results = results.order_by('adj_p_val')
+
     if not results.exists():
         return HttpResponse('No results found for this experiment', status=404)
 

src/frontend/static/frontend/src/components/common/PaginatedTable.tsx

@@ -65,6 +65,9 @@ type PaginationCustomFilter = {
     urlToRetrieveOptions?: string,
     /** Receives all the current custom filter's values and must return the current `disabled` prop of the filter */
     disabledFunction?: (actualValues: { [key: string]: any }) => boolean
+
+    /** Callback when the filter value changes */
+    onChangeFilterEvent?: (value: any) => void
 }
 
 /**
@@ -387,6 +390,10 @@ class PaginatedTable<T> extends React.Component<PaginatedTableProps<T>, Paginate
                         disabled={filter.disabledFunction ? filter.disabledFunction(this.state.tableControl.filters) : false}
                         onChange={(_, { value }) => {
                             this.handleTableControlChanges(filter.keyForServer, value, true, true)
+
+                            if (filter.onChangeFilterEvent) {
+                                filter.onChangeFilterEvent(value)
+                            }
                         }}
                     />
                 )

src/frontend/static/frontend/src/components/differential-expression/DifferentialExpressionModalResultsTableView.tsx

@@ -1,6 +1,6 @@
-import React, { useMemo } from 'react'
+import React, { useState } from 'react'
 import { Table, Icon, TableCell, Form, Button } from 'semantic-ui-react'
-import { PaginatedTable } from '../common/PaginatedTable'
+import { PaginatedTable, PaginationCustomFilter } from '../common/PaginatedTable'
 import { DiffExpExperimentDetail } from './types'
 import { TableCellWithTitle } from '../common/TableCellWithTitle'
 declare const urlDifferentialExpressionExperimentResults: string
@@ -11,32 +11,67 @@ interface DifferentialExpressionModalResultsProps {
 }
 
 export const DifferentialExpressionModalResultsTableView = (props: DifferentialExpressionModalResultsProps) => {
-    const downloadUrl = useMemo(() => {
-        const searchParams = new URLSearchParams()
+    const [pValueFilter, setPValueFilter] = useState<number>(0.05)
+    const [logFilter, setLogFilter] = useState<number>(1)
+
+    const downloadUrl = () => {
+        const searchParams = new URLSearchParams({
+            adj_p_val: pValueFilter.toString(),
+            log_fc: logFilter.toString(),
+        })
 
         return `${urlDownloadDifferentialExpressionResults}/${props.differentialExpressionAnalysisId}?${searchParams.toString()}`
-    }, [props.differentialExpressionAnalysisId])
+    }
 
     const onDownload = () => {
-        window.open(downloadUrl, '_blank', 'noopener,noreferrer')
+        window.open(downloadUrl(), '_blank', 'noopener,noreferrer')
     }
 
+    const customInputs: PaginationCustomFilter[] = [
+        {
+            label: 'Log fold change threshold',
+            keyForServer: 'fc_threshold',
+            defaultValue: 1,
+            width: 2,
+            options: [
+                { key: 'no_log', text: 'No Log Fold' },
+                { key: '1', text: '1', value: 1 },
+                { key: '2', text: '2', value: 2 },
+                { key: '3', text: '3', value: 3 },
+                { key: '4', text: '4', value: 4 },
+                { key: '5', text: '5', value: 5 },
+            ],
+            onChangeFilterEvent: (value) => setLogFilter(value),
+        },
+        {
+            label: 'P-value threshold',
+            keyForServer: 'p_threshold',
+            defaultValue: 0.05,
+            width: 2,
+            options: [
+                { key: 'no_p_val', text: 'No P-value' },
+                { key: '0.05', text: '0.05', value: 0.05 },
+                { key: '0.01', text: '0.01', value: 0.01 },
+            ],
+            onChangeFilterEvent: (value) => setPValueFilter(value),
+        },
+    ]
+
     return (
         <>
             <PaginatedTable<DiffExpExperimentDetail>
                 headerTitle='Experiment results'
                 headers={[
                     { name: 'Gene', serverCodeToSort: 'gene' },
-                    { name: 'adj_p_val', serverCodeToSort: 'adj_p_val' },
-                    { name: 'ave_expr', serverCodeToSort: 'ave_expr' },
-                    { name: 'b_statistic', serverCodeToSort: 'b_statistic' },
-                    { name: 'log_fc', serverCodeToSort: 'log_fc' },
-                    { name: 'is_significant', serverCodeToSort: 'is_significant' },
-                    { name: 'p_value', serverCodeToSort: 'p_value' },
-                    { name: 't_statistic', serverCodeToSort: 't_statistic' },
+                    { name: 'Adjusted p-value', serverCodeToSort: 'adj_p_val' },
+                    { name: 'Average expression', serverCodeToSort: 'ave_expr' },
+                    { name: 'B statistic', serverCodeToSort: 'b_statistic' },
+                    { name: 'Log Fold Change', serverCodeToSort: 'log_fc' },
+                    { name: 'P-value', serverCodeToSort: 'p_value' },
+                    { name: 'T statistic', serverCodeToSort: 't_statistic' },
                 ]}
                 defaultSortProp={{ sortField: 'created_at', sortOrderAscendant: false }}
-                customFilters={undefined}
+                customFilters={customInputs}
                 showSearchInput
                 customElements={[
                     <Form.Field key='download-csv-button' className='custom-table-field' title='Download results in a CSV file'>
@@ -66,15 +101,6 @@ export const DifferentialExpressionModalResultsTableView = (props: DifferentialE
                             {differentialExpressionAnalysis.b_statistic.toFixed(4)}
                         </TableCell>
                         <TableCell>{differentialExpressionAnalysis.log_fc.toFixed(4)}</TableCell>
-                        <TableCell textAlign='center'>
-                            {differentialExpressionAnalysis.is_significant
-                                ? (
-                                    <Icon title='Is significant' name='check' color='green' />
-                                )
-                                : (
-                                    <Icon title='Is not significant' name='close' color='red' />
-                                )}
-                        </TableCell>
                         <TableCell>{differentialExpressionAnalysis.p_value}</TableCell>
                         <TableCell>
                             {differentialExpressionAnalysis.t_statistic.toFixed(4)}

src/frontend/static/frontend/src/components/differential-expression/types.ts

@@ -70,8 +70,6 @@ export interface DiffExpExperimentDetail {
     t_statistic: number;
     /* B statistic */
     b_statistic: number;
-    /* Is significant */
-    is_significant: boolean;
 }
 
 export type VolcanoPoint = {