toulligqc 2.2.3__tar.gz → 2.3__tar.gz

{toulligqc-2.2.3/toulligqc.egg-info → toulligqc-2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: toulligqc
-Version: 2.2.3
+Version: 2.3
 Summary: A post sequencing QC tool for Oxford Nanopore sequencers
 Home-page: https://github.com/GenomicParisCentre/toulligQC
 Author: Genomic Paris Centre team

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/common.py

@@ -18,6 +18,14 @@
 # Maintainer: Laurent Jourdren
 # Since version 2.2
 
+import numpy as np
+from packaging import version
+
+def is_numpy_1_24():
+    """
+    This function checks if Numpy version is later then 1.20
+    """
+    return version.parse(np.__version__) >= version.parse("1.20")
 
 def format_duration(t):
     """

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/plotly_graph_common.py

@@ -535,7 +535,9 @@ def _barcode_boxplot_graph(graph_name, df, barcode_selection, pass_color, fail_c
 
 
 def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, result_directory):
-    labels = count_sorted.index.values.tolist()
+    read_count_sorted = count_sorted[0]
+    base_count_sorted = count_sorted[1]
+    labels = read_count_sorted.index.values.tolist()
 
     fig = go.Figure()
 
@@ -546,9 +548,9 @@ def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, resu
         pie_marker = dict(line=dict(width=line_width, color='#808080'))
         bar_colors = color_palette[0]
 
-    # Pie chart
+    # reads Pie chart
     fig.add_trace(go.Pie(labels=labels,
-                         values=count_sorted,
+                         values=read_count_sorted,
                          hoverinfo='label+percent',
                          textinfo='percent',
                          textfont_size=14,
@@ -557,9 +559,29 @@ def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, resu
                          hovertemplate='<b>%{label}</b><br>%{percent:.1%} (%{value:,})<extra></extra>',
                          visible=True
                          ))
-    # Histogram
+    # Bases Pie chart
+    fig.add_trace(go.Pie(labels=labels,
+                         values=base_count_sorted,
+                         hoverinfo='label+percent',
+                         textinfo='percent',
+                         textfont_size=14,
+                         marker=pie_marker,
+                         textposition='inside',
+                         hovertemplate='<b>%{label}</b><br>%{percent:.1%} (%{value:,})<extra></extra>',
+                         visible=True
+                         ))
+    # Reads Histogram
+    fig.add_trace(go.Bar(x=labels,
+                         y=read_count_sorted,
+                         marker_color=bar_colors,
+                         marker_line_color='gray',
+                         marker_line_width=line_width,
+                         hovertemplate='<b>%{x}</b><br>%{y:,}<extra></extra>',
+                         visible=False
+                         ))
+    # Bases Histogram
     fig.add_trace(go.Bar(x=labels,
-                         y=count_sorted,
+                         y=base_count_sorted,
                          marker_color=bar_colors,
                          marker_line_color='gray',
                          marker_line_width=line_width,
@@ -571,7 +593,7 @@ def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, resu
     fig.update_layout(
         **_title(graph_name),
         **default_graph_layout,
-        **_legend('Barcodes'),
+        **_legend('Barcodes',args=dict(y=0.75)),
         uniformtext_minsize=12,
         uniformtext_mode='hide',
         xaxis={'visible': False},
@@ -584,32 +606,48 @@ def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, resu
         updatemenus=[
             dict(
                 type="buttons",
-                direction="left",
+                direction="down",
                 buttons=list([
                     dict(
-                        args=[{'visible': [True, False]},
+                        args=[{'visible': [False, True, False, False]},
                               {'xaxis': {'visible': False},
                                'yaxis': {'visible': False},
                                'plot_bgcolor': 'white'}],
-                        label="Pie chart",
+                        label="Reads Pie chart",
                         method="update"
                     ),
                     dict(
-                        args=[{'visible': [False, True]},
+                        args=[{'visible': [False, False, False, True]},
+                              {**_xaxis('Barcodes', dict(visible=True)),
+                               **_yaxis('Base count', dict(visible=True)),
+                               'plot_bgcolor': plotly_background_color}],
+                        label="Reads Histogram",
+                        method="update"
+                    ),
+                    dict(
+                        args=[{'visible': [True, False, False, False]},
+                              {'xaxis': {'visible': False},
+                               'yaxis': {'visible': False},
+                               'plot_bgcolor': 'white'}],
+                        label="Bases Pie chart",
+                        method="update"
+                    ),
+                    dict(
+                        args=[{'visible': [False, False, True, False]},
                               {**_xaxis('Barcodes', dict(visible=True)),
                                **_yaxis('Read count', dict(visible=True)),
                                'plot_bgcolor': plotly_background_color}],
-                        label="Histogram",
+                        label="Bases Histogram",
                         method="update"
                     )
                 ]),
-                pad={"r": 20, "t": 20, "l": 20, "b": 20},
+                pad={"r": 20, "t": 20, "l": 40, "b": 20},
                 showactive=True,
                 x=1.0,
                 xanchor="left",
                 y=1.25,
                 yanchor="top"
-            ),
+            )
         ]
     )
 
@@ -618,11 +656,13 @@ def _pie_chart_graph(graph_name, count_sorted, color_palette, one_d_square, resu
     else:
         count_col_name = 'Read count'
 
-    barcode_table = pd.DataFrame({"Barcode arrangement (%)": count_sorted / sum(count_sorted) * 100,
-                                  count_col_name: count_sorted})
+    barcode_table = pd.DataFrame({"Barcode arrangement (%)": read_count_sorted / sum(read_count_sorted) * 100,
+                                  count_col_name: read_count_sorted,
+                                 "Base count": base_count_sorted})
     barcode_table.sort_index(inplace=True)
     pd.options.display.float_format = percent_format_str.format
     barcode_table[count_col_name] = barcode_table[count_col_name].astype(int).apply(lambda x: _format_int(x))
+    barcode_table["Base count"] = barcode_table["Base count"].astype(int).apply(lambda x: _format_int(x))
     table_html = _dataFrame_to_html(barcode_table)
 
     div, output_file = _create_and_save_div(fig, result_directory, graph_name)
@@ -987,53 +1027,202 @@ def _quality_multiboxplot(graph_name, result_directory, df, onedsquare=False):
     return graph_name, output_file, table_html, div
 
 
-def _scatterplot(graph_name, dataframe_dict, result_directory, onedsquare=False):
+def _twod_density_char(graph_name, dataframe_dict, result_directory, onedsquare=False):
     read_pass_length = dataframe_dict["pass.reads.sequence.length"]
     read_pass_qscore = dataframe_dict["pass.reads.mean.qscore"]
     read_fail_length = dataframe_dict["fail.reads.sequence.length"]
     read_fail_qscore = dataframe_dict["fail.reads.mean.qscore"]
 
-    # If more than 10.000 reads, interpolate data
-    npoints, sigma = interpolation_points(read_pass_length, 'scatterplot')
-    if (len(read_pass_length) + len(read_fail_length)) > npoints:
-        pass_ratio = len(read_pass_length) / (len(read_pass_length) + len(read_fail_length))
-        pass_data = _interpolate(read_pass_length, int(npoints * pass_ratio), y=read_pass_qscore, interp_type="nearest")
-        fail_data = _interpolate(read_fail_length, int(npoints * (1 - pass_ratio)), y=read_fail_qscore,
-                                 interp_type="nearest")
-    else:
-        pass_data = [read_pass_length, read_pass_qscore]
-        fail_data = [read_fail_length, read_fail_qscore]
+    all_length = dataframe_dict['all.reads.sequence.length']
+    all_qscore = dataframe_dict['all.reads.mean.qscore']
+
+    prefix = '1D² ' if onedsquare else ''
+    graph_name = prefix + graph_name
+    npoint = 50000
+
     fig = go.Figure()
+    
+    idx_pass = np.random.choice(read_pass_length.index, min(npoint, len(read_pass_length)), replace=False)
+    idx_fail = np.random.choice(read_fail_length.index, min(npoint, len(read_fail_length)), replace=False)
+    idx_all = np.random.choice(all_length.index, min(npoint, len(all_length)), replace=False)
+
+    pass_color = toulligqc_colors['pass']
+    fail_color = toulligqc_colors['fail']
+    all_color = toulligqc_colors['all']
+
+
+    fig.add_trace(go.Histogram2dContour(
+            x = all_length[idx_all],
+            y = all_qscore[idx_all],
+            colorscale = [[0, 'white'], [0.5, 'khaki'], [1.0, all_color]], 
+            reversescale = False,
+            xaxis = 'x',
+            yaxis = 'y',
+            colorbar = dict(
+            title = '<b>Legend</b>',
+            len = 0.4
+        )
+        ))
 
-    fig.add_trace(go.Scatter(x=pass_data[0],
-                             y=pass_data[1],
-                             name="Pass reads",
-                             marker_color=toulligqc_colors['pass'],
-                             mode="markers"
-                             ))
+    fig.add_trace(go.Histogram2dContour(
+            x = read_pass_length[idx_pass],
+            y = read_pass_qscore[idx_pass],
+            colorscale = [[0, 'white'], [0.5, 'honeydew'], [1.0, pass_color]], 
+            reversescale = False,
+            xaxis = 'x',
+            yaxis = 'y',
+            colorbar = dict(
+            title = '<b>Legend</b>',
+            len = 0.4
+        ),
+        visible=False
+        ))
 
-    fig.add_trace(go.Scatter(x=fail_data[0],
-                             y=fail_data[1],
-                             name="Fail reads",
-                             marker_color=toulligqc_colors['fail'],
-                             mode="markers"
-                             ))
+    fig.add_trace(go.Histogram2dContour(
+            x = read_fail_length[idx_fail],
+            y = read_fail_qscore[idx_fail],
+            colorscale = [[0, 'white'], [0.5, 'coral'], [1.0, fail_color]],
+            reversescale = False,
+            xaxis = 'x',
+            yaxis = 'y',
+            colorbar = dict(
+            title = '<b>Legend</b>',
+            len = 0.4,
+        ),
+        visible=False
+        ))
+    
+    max_x_range = max(np.percentile(read_pass_length, 99), np.percentile(read_fail_length, 99))
+    max_y_range = max(np.percentile(read_pass_qscore, 99.8), np.percentile(read_fail_qscore, 99.8))
+    fig.update_xaxes(range=[0, max_x_range])
+    fig.update_yaxes(range=[0, max_y_range])
+
+    fig.add_trace(go.Histogram(
+            y = all_qscore[idx_all],
+            xaxis = 'x2',
+            opacity = 0.5,
+            marker = dict(
+                color = all_color
+            )
+        ))
+
+    fig.add_trace(go.Histogram(
+            x = all_length[idx_all],
+            yaxis = 'y2',
+            opacity = 0.5,
+            marker = dict(
+                color = all_color
+            )
+            ))
+
+    fig.add_trace(go.Histogram(
+            y = read_pass_qscore[idx_pass],
+            xaxis = 'x2',
+            marker = dict(
+                color = pass_color
+            ),
+            visible=False
+        ))
+
+    fig.add_trace(go.Histogram(
+            x = read_pass_length[idx_pass],
+            yaxis = 'y2',
+            marker = dict(
+                color = pass_color
+            ),
+            visible=False
+            ))
+    
+    fig.add_trace(go.Histogram(
+            y = read_fail_qscore[idx_fail],
+            xaxis = 'x2',
+            marker = dict(
+                color = fail_color
+            ),
+            visible=False
+        ))
+    fig.add_trace(go.Histogram(
+            x = read_fail_length[idx_fail],
+            yaxis = 'y2',
+            marker = dict(
+                color = fail_color
+            ),
+            visible=False
+        ))
 
-    prefix = '1D² ' if onedsquare else ''
     fig.update_layout(
+        autosize = False,
+        xaxis = dict(
+            zeroline = False,
+            domain = [0,0.85],
+            showgrid = False,
+            title = '<b>Sequence length</b>'
+        ),
+        yaxis = dict(
+            zeroline = False,
+            domain = [0,0.85],
+            showgrid = False,
+            title = '<b>PHRED score</b>'
+        ),
+        xaxis2 = dict(
+            zeroline = False,
+            domain = [0.85,1],
+            showgrid = False,
+            visible = False
+        ),
+        yaxis2 = dict(
+            zeroline = False,
+            domain = [0.85,1],
+            showgrid = False,
+            visible = False
+        ),
+        height = 600,
+        width = 1000,
+        bargap = 0,
+        paper_bgcolor="#FFFFFF", 
+        plot_bgcolor="#FFFFFF",
+        hovermode = 'closest',
+        showlegend = False,
         **_title(graph_name),
-        **default_graph_layout,
-        **_legend(prefix + 'Read type'),
-        **_xaxis('Sequence length (bp)'),
-        **_yaxis('PHRED score', dict(fixedrange=False)),
+
     )
-    # Trim x axis to avoid negative values
-    max_val = max(max(read_fail_length), max(read_pass_length))
 
-    fig.update_xaxes(range=[0, max_val])
+    # Add buttons
+    fig.update_layout(
+        updatemenus=[
+            dict(
+                type="buttons",
+                direction="down",
+                buttons=list([
+                    dict(
+                        args=[{'visible': [True, False, False, True, True, False, False, False, False]}, {'hovermode': False}],
+                        label="all reads",
+                        method="restyle"
+                    ),
+                    dict(
+                        args=[{'visible': [False, True, False, False, False, True, True, False, False]}, {'hovermode': 'x'}],
+                        label="Pass reads",
+                        method="restyle"
+                    ),
+                    dict(
+                        args=[{'visible': [False, False, True, False, False, False, False, True, True]}, {'hovermode': False}],
+                        label="Fail reads",
+                        method="restyle"
+                    )
+                ]),
+                pad={"r": 20, "t": 20, "l": 20, "b": 20},
+                showactive=True,
+                x=1.0,
+                xanchor="left",
+                y=1.25,
+                yanchor="top"
+            ),
+        ]
+    )
 
     table_html = None
     div, output_file = _create_and_save_div(fig, result_directory, graph_name)
+
     return graph_name, output_file, table_html, div
 
 

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/plotly_graph_generator.py

@@ -36,7 +36,7 @@ from toulligqc.plotly_graph_common import _phred_score_density
 from toulligqc.plotly_graph_common import _pie_chart_graph
 from toulligqc.plotly_graph_common import _quality_multiboxplot
 from toulligqc.plotly_graph_common import _read_length_distribution
-from toulligqc.plotly_graph_common import _scatterplot
+from toulligqc.plotly_graph_common import _twod_density_char
 from toulligqc.plotly_graph_common import _smooth_data
 from toulligqc.plotly_graph_common import _title
 from toulligqc.plotly_graph_common import _transparent_colors
@@ -366,14 +366,14 @@ def allphred_score_frequency(dataframe_dict, result_directory):
                                 result_directory=result_directory)
 
 
-def all_scatterplot(dataframe_dict, result_directory):
+def twod_density(dataframe_dict, result_directory):
     """
     Plot the scatter plot representing the relation between the phred score and the sequence length in log
     """
 
     graph_name = "Correlation between read length and PHRED score"
-
-    return _scatterplot(graph_name, dataframe_dict, result_directory)
+    
+    return _twod_density_char(graph_name, dataframe_dict, result_directory)
 
 
 def _compute_channel_map(df):
@@ -604,10 +604,11 @@ def barcode_percentage_pie_chart_pass(dataframe_dict, barcode_selection, result_
 
     graph_name = "Pass barcoded reads distribution"
 
-    count_sorted = dataframe_dict["read.pass.barcoded"]
+    read_count_sorted = dataframe_dict["read.pass.barcoded"]
+    base_count_sorted = dataframe_dict["base.pass.barcoded"]
 
     return _pie_chart_graph(graph_name=graph_name,
-                            count_sorted=count_sorted,
+                            count_sorted=[read_count_sorted, base_count_sorted],
                             color_palette=toulligqc_colors['pie_chart_palette'],
                             one_d_square=False,
                             result_directory=result_directory)
@@ -621,10 +622,11 @@ def barcode_percentage_pie_chart_fail(dataframe_dict, barcode_selection, result_
 
     graph_name = "Fail barcoded reads distribution"
 
-    count_sorted = dataframe_dict["read.fail.barcoded"]
+    read_count_sorted = dataframe_dict["read.fail.barcoded"]
+    base_count_sorted = dataframe_dict["base.fail.barcoded"]
 
     return _pie_chart_graph(graph_name=graph_name,
-                            count_sorted=count_sorted,
+                            count_sorted=[read_count_sorted, base_count_sorted],
                             color_palette=toulligqc_colors['pie_chart_palette'],
                             one_d_square=False,
                             result_directory=result_directory)

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/plotly_graph_onedsquare_generator.py

@@ -34,7 +34,7 @@ from toulligqc.plotly_graph_common import _phred_score_density
 from toulligqc.plotly_graph_common import _pie_chart_graph
 from toulligqc.plotly_graph_common import _quality_multiboxplot
 from toulligqc.plotly_graph_common import _read_length_distribution
-from toulligqc.plotly_graph_common import _scatterplot
+from toulligqc.plotly_graph_common import _twod_density_char
 from toulligqc.plotly_graph_common import _title
 from toulligqc.plotly_graph_common import _transparent_colors
 from toulligqc.plotly_graph_common import _xaxis
@@ -207,14 +207,14 @@ def dsqr_allphred_score_frequency(result_dict, dataframe_dict_1dsqr, result_dire
                                 result_directory=result_directory)
 
 
-def scatterplot_1dsqr(dataframe_dict_1dsqr, result_directory):
+def twod_density(dataframe_dict, result_directory):
     """
     Plot the scatter plot representing the relation between the phred score and the sequence length in log
     """
 
     graph_name = "Correlation between 1D² read length and PHRED score"
 
-    return _scatterplot(graph_name, dataframe_dict_1dsqr, result_directory, onedsquare=True)
+    return _twod_density_char(graph_name, dataframe_dict, result_directory, onedsquare = True)
 
 
 #
@@ -228,10 +228,11 @@ def barcode_percentage_pie_chart_1dsqr_pass(dataframe_dict_1dsqr, barcode_select
 
     graph_name = "1D² read pass barcode distribution"
 
-    count_sorted = dataframe_dict_1dsqr["read.pass.barcoded"]
+    read_count_sorted = dataframe_dict_1dsqr["read.pass.barcoded"]
+    base_count_sorted = dataframe_dict_1dsqr["base.pass.barcoded"]
 
     return _pie_chart_graph(graph_name=graph_name,
-                            count_sorted=count_sorted,
+                            count_sorted=[read_count_sorted, base_count_sorted],
                             color_palette=toulligqc_colors['pie_chart_palette'],
                             one_d_square=True,
                             result_directory=result_directory)
@@ -245,10 +246,11 @@ def barcode_percentage_pie_chart_1dsqr_fail(dataframe_dict_1dsqr, barcode_select
 
     graph_name = "1D² read fail barcode distribution"
 
-    count_sorted = dataframe_dict_1dsqr["read.fail.barcoded"]
+    read_count_sorted = dataframe_dict_1dsqr["read.fail.barcoded"]
+    base_count_sorted = dataframe_dict_1dsqr["base.fail.barcoded"]
 
     return _pie_chart_graph(graph_name=graph_name,
-                            count_sorted=count_sorted,
+                            count_sorted=[read_count_sorted, base_count_sorted],
                             color_palette=toulligqc_colors['pie_chart_palette'],
                             one_d_square=True,
                             result_directory=result_directory)

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/sequencing_summary_common.py

@@ -98,6 +98,17 @@ def series_cols_boolean_elements(dataframe, column_name1: str, column_name2: str
     return dataframe[column_name1].loc[dataframe[column_name2] == bool(boolean)]
 
 
+def df_cols_boolean_elements(dataframe, column_name1: list, column_name2: str, boolean: bool) -> pd.Series:
+    """
+    Returns a Panda's Series object with the number of values of different columns filtered by a boolean
+    :param dataframe: dataframe_1d
+    :param column_name1: 1st column to filter
+    :param column_name2: 2nd column to filter
+    :param boolean: access columns of dataframe by boolean array
+    """
+    return dataframe[column_name1].loc[dataframe[column_name2] == bool(boolean)]
+
+
 def sorted_series_boolean_elements_divided(dataframe, column_name1: str, column_name2: str, boolean: bool,
                                            denominator: int):
     """
@@ -130,6 +141,22 @@ def extract_barcode_info(extractor, result_dict, barcode_selection, dataframe_di
         if element not in barcodes_found and element != 'other barcodes':
             sys.stderr.write("Warning: The barcode {} doesn't exist in input data\n".format(element))
 
+
+    # Get barcodes frequency by Bases
+    df_base_pass_barcode = series_cols_boolean_elements(df, ["barcode_arrangement",  "sequence_length"],
+                                                                "passes_filtering", True)
+
+    dataframe_dict["base.pass.barcoded"] = _barcode_bases(extractor, barcode_selection, result_dict,
+                                                             "base.pass.barcoded",
+                                                              df_base_pass_barcode)
+
+    df_base_fail_barcode = series_cols_boolean_elements(df, ["barcode_arrangement",  "sequence_length"],
+                                                                "passes_filtering", False)
+
+    dataframe_dict["base.fail.barcoded"] = _barcode_bases(extractor, barcode_selection, result_dict,
+                                                             "base.fail.barcoded",
+                                                              df_base_fail_barcode) 
+
     # Get barcodes frequency by read type
     series_read_pass_barcode = series_cols_boolean_elements(df, "barcode_arrangement",
                                                             "passes_filtering", True)
@@ -294,6 +321,53 @@ def _barcode_frequency(extractor, barcode_selection, result_dict, entry: str, df
     return count_sorted
 
 
+def _barcode_bases(extractor, barcode_selection, result_dict, entry: str, df_filtered) -> pd.Series:
+    """
+    Count bases by values of barcode_selection, computes sum of counts by barcode_selection, and sum of unclassified counts.
+    Regroup all non used barcodes in index "other"
+    Compute all frequency values for each number of barcoded bases
+    :param result_dict: result dictionary with statistics
+    :param entry: entry about barcoded counts
+    :param prefix: key prefix
+    :return: Series with all barcodes (used, non used, and unclassified) frequencies
+    """
+    # Regroup all barcoded and sum all read lengths in df
+    all_barcode_count = df_filtered.groupby('barcode_arrangement')['sequence_length'].sum()
+
+    # Retain only existing barcodes from barcode_selection list
+    barcodes_found = set(df_filtered['barcode_arrangement'].unique())
+    barcode_selection_existing = [x for x in barcode_selection if x in barcodes_found]
+
+    # Sort by list of barcode_selection
+    count_sorted = all_barcode_count.sort_index()[barcode_selection_existing]
+    # Replace all NaN values to zero
+    count_sorted.fillna(0, downcast='int16', inplace=True)
+
+    # Compute sum of all used barcodes without barcode 'unclassified'
+    set_result_value(extractor, result_dict, entry + '.count', sum(count_sorted.drop("unclassified")))
+
+    # Replace entry name ie read.pass/fail.barcode with read.pass/fail.non.used.barcodes.count
+    non_used_barcodes_count_key = entry.replace(".barcoded", ".non.used.barcodes.count")
+
+    # Compute all reads of barcodes that are not in the barcode_selection list
+    other_barcode_count = sum(all_barcode_count) - sum(count_sorted)
+    set_result_value(extractor, result_dict, non_used_barcodes_count_key, other_barcode_count)
+
+    # Create Series for all non-used barcode counts and rename index array with "other"
+    other_all_barcode_count = pd.Series(other_barcode_count, index=['other barcodes'])
+
+    # Append Series of non-used barcode counts to the Series of barcode_selection counts
+    count_sorted = count_sorted.append(other_all_barcode_count).sort_index()
+
+    # Compute frequency for all barcode counts and save into dataframe_dict
+    for barcode in count_sorted.to_dict():
+         frequency_value = count_sorted[barcode] * 100 / sum(count_sorted)
+         set_result_value(extractor, result_dict, entry.replace(".barcoded", ".") + barcode + ".frequency",
+                          frequency_value)
+
+    return count_sorted
+
+
 def log_task(quiet, msg, start_time, end_time):
     if not quiet:
         delta = end_time - start_time

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/sequencing_summary_extractor.py

@@ -42,7 +42,7 @@ from toulligqc.sequencing_summary_common import set_result_value
 from toulligqc.sequencing_summary_common import log_task
 from toulligqc.sequencing_summary_common import add_image_to_result
 from toulligqc.sequencing_summary_common import read_first_line_file
-
+from toulligqc.common import is_numpy_1_24
 
 class SequencingSummaryExtractor:
     """
@@ -280,8 +280,7 @@ class SequencingSummaryExtractor:
         add_image_to_result(self.quiet, images, time.time(), pgg.read_quality_multiboxplot(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.allphred_score_frequency(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.plot_performance(self.dataframe_1d, self.images_directory))
-
-        add_image_to_result(self.quiet, images, time.time(), pgg.all_scatterplot(self.dataframe_dict, self.images_directory))
+        add_image_to_result(self.quiet, images, time.time(), pgg.twod_density(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.sequence_length_over_time(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.phred_score_over_time(self.dataframe_dict, result_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.speed_over_time(self.dataframe_dict, self.images_directory))
@@ -345,7 +344,7 @@ class SequencingSummaryExtractor:
         sequencing_summary_datatypes = {
             'channel': np.int16,
             'start_time': np.float64,
-            'passes_filtering': np.bool,
+            'passes_filtering': np.bool_ if is_numpy_1_24 else np.bool,
             'sequence_length_template': np.uint32,
             'mean_qscore_template': np.float32,
             'duration': np.float32}

{toulligqc-2.2.3 → toulligqc-2.3}/toulligqc/sequencing_summary_onedsquare_extractor.py

@@ -44,6 +44,7 @@ from toulligqc.sequencing_summary_common import log_task
 from toulligqc.sequencing_summary_common import add_image_to_result
 from toulligqc.sequencing_summary_common import read_first_line_file
 from toulligqc.sequencing_summary_extractor import SequencingSummaryExtractor as SSE
+from toulligqc.common import is_numpy_1_24
 
 
 class OneDSquareSequencingSummaryExtractor(SSE):
@@ -285,8 +286,8 @@ class OneDSquareSequencingSummaryExtractor(SSE):
         add_image_to_result(self.quiet, images, time.time(), pgg2.dsqr_read_quality_multiboxplot(result_dict, self.dataframe_dict_1dsqr, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.allphred_score_frequency(self.dataframe_dict, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg2.dsqr_allphred_score_frequency(result_dict, self.dataframe_dict_1dsqr, self.images_directory))
-        add_image_to_result(self.quiet, images, time.time(), pgg.all_scatterplot(self.dataframe_dict, self.images_directory))
-        add_image_to_result(self.quiet, images, time.time(), pgg2.scatterplot_1dsqr(self.dataframe_dict_1dsqr, self.images_directory))
+        add_image_to_result(self.quiet, images, time.time(), pgg.twod_density(self.dataframe_dict, self.images_directory))
+        add_image_to_result(self.quiet, images, time.time(), pgg2.twod_density(self.dataframe_dict_1dsqr, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg.plot_performance(self.sse.dataframe_1d, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg2.sequence_length_over_time_dsqr(self.dataframe_dict_1dsqr, self.images_directory))
         add_image_to_result(self.quiet, images, time.time(), pgg2.phred_score_over_time_dsqr(result_dict, self.dataframe_dict_1dsqr, self.images_directory))
@@ -346,7 +347,7 @@ class OneDSquareSequencingSummaryExtractor(SSE):
         ]
 
         sequencing_summary_datatypes = {
-            'passes_filtering': np.bool,
+            'passes_filtering': np.bool_ if is_numpy_1_24 else np.bool,
             'sequence_length': np.uint32,
             'mean_qscore': np.float32,
             'start_time1': np.float64,

toulligqc-2.3/toulligqc/version.py

@@ -0,0 +1 @@
+__version__ = '2.3'

{toulligqc-2.2.3 → toulligqc-2.3/toulligqc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: toulligqc
-Version: 2.2.3
+Version: 2.3
 Summary: A post sequencing QC tool for Oxford Nanopore sequencers
 Home-page: https://github.com/GenomicParisCentre/toulligQC
 Author: Genomic Paris Centre team

toulligqc-2.2.3/toulligqc/version.py

@@ -1 +0,0 @@
-__version__ = '2.2.3'