linting

Author: Jhsmit

pyhdx/datasets.py

@@ -1 +1 @@
-from hdxms_datasets import *
+from hdxms_datasets import *  # noqa F403

pyhdx/fileIO.py

@@ -5,16 +5,17 @@
 import os
 import re
 import shutil
+import warnings
 from datetime import datetime
-from io import StringIO, BytesIO
-from pathlib import Path
-from typing import Union, Literal, Tuple, List, TextIO, Optional, TYPE_CHECKING, Any, BinaryIO
 from importlib import import_module
-import torch.nn as nn
-import torch as t
+from io import BytesIO, StringIO
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, BinaryIO, List, Literal, Optional, TextIO, Tuple, Union
+
 import pandas as pd
+import torch as t
+import torch.nn as nn
 import yaml
-import warnings
 
 import pyhdx
 
@@ -217,7 +218,7 @@ def dataframe_to_stringio(
         sio.write(prefix + f'{now.strftime("%Y/%m/%d %H:%M:%S")} ({int(now.timestamp())}) \n')
 
     json_header = {}
-    if include_metadata == True and "metadata" in df.attrs:
+    if include_metadata is True and "metadata" in df.attrs:
         json_header["metadata"] = df.attrs["metadata"]
     elif include_metadata and isinstance(include_metadata, dict):
         json_header["metadata"] = include_metadata
@@ -366,10 +367,6 @@ def load_fitresult(fit_dir: os.PathLike) -> Union[TorchFitResult, TorchFitResult
         result_klass = pyhdx.fitting_torch.TorchFitResult
     elif pth.is_file():
         raise DeprecationWarning("`load_fitresult` only loads from fit result directories")
-        fit_result = csv_to_dataframe(fit_dir)
-        assert isinstance(
-            hdxm, pyhdx.HDXMeasurement
-        ), "No valid HDXMeasurement data object supplied"
     else:
         raise ValueError("Specified fit result path is not a directory")
 

pyhdx/fitting.py

@@ -3,27 +3,27 @@
 from collections import namedtuple
 from dataclasses import dataclass
 from functools import partial
-from typing import Union, Optional, Any, Literal
+from typing import Any, Literal, Optional, Union
 
 import numpy as np
 import pandas as pd
 import torch
 from dask.distributed import Client, worker_client
-from scipy.optimize import Bounds, minimize, OptimizeResult
+from scipy.optimize import Bounds, OptimizeResult, minimize
 from symfit import Fit
 from symfit.core.minimizers import DifferentialEvolution, Powell
 from tqdm.auto import tqdm, trange
 
+from pyhdx.config import cfg
 from pyhdx.fit_models import (
     SingleKineticModel,
     TwoComponentAssociationModel,
     TwoComponentDissociationModel,
 )
 from pyhdx.fitting_torch import DeltaGFit, TorchFitResult
 from pyhdx.local_cluster import DummyClient
-from pyhdx.support import temporary_seed, pbar_decorator, multiindex_astype
-from pyhdx.models import HDXMeasurementSet, HDXTimepoint, HDXMeasurement
-from pyhdx.config import cfg
+from pyhdx.models import HDXMeasurement, HDXMeasurementSet, HDXTimepoint
+from pyhdx.support import multiindex_astype, pbar_decorator, temporary_seed
 
 EmptyResult = namedtuple("EmptyResult", ["chi_squared", "params"])
 er = EmptyResult(np.nan, {k: np.nan for k in ["tau1", "tau2", "r"]})
@@ -187,7 +187,7 @@ def fit_rates_weighted_average(
     if pbar:
         raise NotImplementedError()
     else:
-        inc = lambda: None
+        pass
 
     results = []
 
@@ -385,9 +385,9 @@ def _fit_single_d_update(
     # d_uptake = hdx_t.data["uptake_corrected"].values
     Nr = X.shape[1]  # number of residues / parameters
 
-    if bounds == True:
+    if bounds is True:
         bounds = Bounds(lb=np.zeros(Nr), ub=np.ones(Nr))
-    elif bounds == False:
+    elif bounds is False:
         bounds = None
 
     args = (X, d_uptake, r1)
@@ -561,7 +561,7 @@ def closure():
     iter = trange(epochs) if verbose else range(epochs)
     for epoch in iter:
         optimizer_obj.zero_grad()
-        loss = optimizer_obj.step(closure)
+        loss = optimizer_obj.step(closure)  # noqa
 
         for cb in callbacks:
             cb(epoch, model, optimizer_obj)

pyhdx/plot.py

@@ -17,7 +17,6 @@
 from tqdm import tqdm
 
 from pyhdx.config import cfg
-from pyhdx.fileIO import load_fitresult
 from pyhdx.support import (
     apply_cmap,
     autowrap,
@@ -207,7 +206,7 @@ def residue_time_scatter_figure(
     nrows = figure_kwargs.pop("nrows", int(np.ceil(n_subplots / ncols)))
     figure_width = figure_kwargs.pop("width", cfg.plotting.page_width) / 25.4
     refaspect = figure_kwargs.pop("refaspect", cfg.plotting.residue_scatter_aspect)
-    cbar_width = figure_kwargs.pop("cbar_width", cfg.plotting.cbar_width) / 25.4
+    # cbar_width = figure_kwargs.pop("cbar_width", cfg.plotting.cbar_width) / 25.4
 
     cmap = uplt.Colormap(cmap)  # todo allow None as cmap
     norm = norm or uplt.Norm("linear", vmin=0, vmax=1)
@@ -1654,204 +1653,3 @@ def plot_all(self, **kwargs):
             pbar.set_description(plot_type)
             fig_kwargs = kwargs.get(plot_type, {})
             self.save_figure(plot_type, **fig_kwargs)
-
-
-def plot_fitresults(
-    fitresult_path,
-    reference=None,
-    plots="all",
-    renew=False,
-    cmap_and_norm=None,
-    output_path=None,
-    output_type=".png",
-    **save_kwargs,
-):
-    """
-
-    Parameters
-    ----------
-    fitresult_path
-    plots
-    renew
-    cmap_and_norm: :obj:`dict`, optional
-        Dictionary with cmap and norms to use. If `None`, reverts to defaults.
-        Dict format: {'dG': (cmap, norm), 'ddG': (cmap, norm)}
-
-    output_type: list or str
-
-    Returns
-    -------
-
-    """
-
-    raise DeprecationWarning("This function is deprecated, use FitResultPlot.plot_all instead")
-    # batch results only
-    history_path = fitresult_path / "model_history.csv"
-    output_path = output_path or fitresult_path
-    output_type = list([output_type]) if isinstance(output_type, str) else output_type
-    fitresult = load_fitresult(fitresult_path)
-
-    protein_states = fitresult.output.df.columns.get_level_values(0).unique()
-
-    if isinstance(reference, int):
-        reference_state = protein_states[reference]
-    elif reference in protein_states:
-        reference_state = reference
-    elif reference is None:
-        reference_state = None
-    else:
-        raise ValueError(f"Invalid value {reference!r} for 'reference'")
-
-    # todo needs tidying up
-    cmap_and_norm = cmap_and_norm or {}
-    dG_cmap, dG_norm = cmap_and_norm.get("dG", (None, None))
-    dG_cmap_default, dG_norm_default = default_cmap_norm("dG")
-    ddG_cmap, ddG_norm = cmap_and_norm.get("ddG", (None, None))
-    ddG_cmap_default, ddG_norm_default = default_cmap_norm("ddG")
-    dG_cmap = ddG_cmap or dG_cmap_default
-    dG_norm = dG_norm or dG_norm_default
-    ddG_cmap = ddG_cmap or ddG_cmap_default
-    ddG_norm = ddG_norm or ddG_norm_default
-
-    # check_exists = lambda x: False if renew else x.exists()
-    # todo add logic for checking renew or not
-
-    if plots == "all":
-        plots = [
-            "loss",
-            "rfu_coverage",
-            "rfu_scatter",
-            "dG_scatter",
-            "ddG_scatter",
-            "linear_bars",
-            "rainbowclouds",
-            "peptide_mse",
-        ]
-
-    # def check_update(pth, fname, extensions, renew):
-    #     # Returns True if the target graph should be renewed or not
-    #     if renew:
-    #         return True
-    #     else:
-    #         pths = [pth / (fname + ext) for ext in extensions]
-    #         return any([not pth.exists() for pth in pths])
-
-    # plots = [p for p in plots if check_update(output_path, p, output_type, renew)]
-
-    if "loss" in plots:
-        loss_df = fitresult.losses
-        loss_df.plot()
-
-        mse_loss = loss_df["mse_loss"]
-        reg_loss = loss_df.iloc[:, 1:].sum(axis=1)
-        reg_percentage = 100 * reg_loss / (mse_loss + reg_loss)
-        fig = plt.gcf()
-        ax = plt.gca()
-        ax1 = ax.twinx()
-        reg_percentage.plot(ax=ax1, color="k")
-        ax1.set_xlim(0, None)
-        for ext in output_type:
-            f_out = output_path / ("loss" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-    if "rfu_coverage" in plots:
-        for hdxm in fitresult.hdxm_set:
-            fig, axes, cbar_ax = peptide_coverage_figure(hdxm.data)
-            for ext in output_type:
-                f_out = output_path / (f"rfu_coverage_{hdxm.name}" + ext)
-                plt.savefig(f_out)
-            plt.close(fig)
-
-    # todo rfu_scatter_timepoint
-
-    if "rfu_scatter" in plots:
-        fig, axes, cbar = residue_scatter_figure(fitresult.hdxm_set)
-        for ext in output_type:
-            f_out = output_path / ("rfu_scatter" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-    if "dG_scatter" in plots:
-        fig, axes, cbars = dG_scatter_figure(fitresult.output.df, cmap=dG_cmap, norm=dG_norm)
-        for ext in output_type:
-            f_out = output_path / ("dG_scatter" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-    if "ddG_scatter" in plots:
-        fig, axes, cbars = ddG_scatter_figure(
-            fitresult.output.df, reference=reference, cmap=ddG_cmap, norm=ddG_norm
-        )
-        for ext in output_type:
-            f_out = output_path / ("ddG_scatter" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-    if "linear_bars" in plots:
-        fig, axes = linear_bars_figure(fitresult.output.df)
-        for ext in output_type:
-            f_out = output_path / ("dG_linear_bars" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-        if reference_state:
-            fig, axes = linear_bars_figure(fitresult.output.df, reference=reference)
-            for ext in output_type:
-                f_out = output_path / ("ddG_linear_bars" + ext)
-                plt.savefig(f_out)
-            plt.close(fig)
-
-    if "rainbowclouds" in plots:
-        fig, ax = rainbowclouds_figure(fitresult.output.df)
-        for ext in output_type:
-            f_out = output_path / ("dG_rainbowclouds" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-        if reference_state:
-            fig, axes = rainbowclouds_figure(fitresult.output.df, reference=reference)
-            for ext in output_type:
-                f_out = output_path / ("ddG_rainbowclouds" + ext)
-                plt.savefig(f_out)
-            plt.close(fig)
-
-    if "peptide_mse" in plots:
-        fig, axes, cbars = peptide_mse_figure(fitresult.get_peptide_mse())
-        for ext in output_type:
-            f_out = output_path / ("peptide_mse" + ext)
-            plt.savefig(f_out)
-        plt.close(fig)
-
-    #
-    # if 'history' in plots:
-    #     for h_df, name in zip(history_list, names):
-    #         output_path = fitresult_path / f'{name}history.png'
-    #         if check_exists(output_path):
-    #             break
-    #
-    #         num = len(h_df.columns)
-    #         max_epochs = max([int(c) for c in h_df.columns])
-    #
-    #         cmap = mpl.cm.get_cmap('winter')
-    #         norm = mpl.colors.Normalize(vmin=1, vmax=max_epochs)
-    #         colors = iter(cmap(np.linspace(0, 1, num=num)))
-    #
-    #         fig, axes = uplt.subplots(nrows=1, width=width, aspect=aspect)
-    #         ax = axes[0]
-    #         for key in h_df:
-    #             c = next(colors)
-    #             to_hex(c)
-    #
-    #             ax.scatter(h_df.index, h_df[key] * 1e-3, color=to_hex(c), **scatter_kwargs)
-    #         ax.format(xlabel=r_xlabel, ylabel=dG_ylabel)
-    #
-    #         values = np.linspace(0, max_epochs, endpoint=True, num=num)
-    #         colors = cmap(norm(values))
-    #         tick_labels = np.linspace(0, max_epochs, num=5)
-    #
-    #         cbar = fig.colorbar(colors, values=values, ticks=tick_labels, space=0, width=cbar_width, label='Epochs')
-    #         ax.format(yticklabelloc='None', ytickloc='None')
-    #
-    #         plt.savefig(output_path)
-    #         plt.close(fig)

pyhdx/tol_colors.py

@@ -551,7 +551,7 @@ def __rainbow_discrete(self, lut=None):
                 28,
             ],
         ]
-        if lut == None or lut < 1 or lut > 23:
+        if lut == None or lut < 1 or lut > 23:  # noqa: E711
             lut = 22
         self.cmap = discretemap(self.cname, [clrs[i] for i in indexes[lut - 1]])
         if lut == 23:
@@ -585,7 +585,7 @@ def tol_cmap(colormap=None, lut=None):
     Parameter lut is ignored for all colormaps except 'rainbow_discrete'.
     """
     obj = TOLcmaps()
-    if colormap == None:
+    if colormap == None:  # noqa: E711
         return obj.namelist
     if colormap not in obj.namelist:
         colormap = "rainbow_PuRd"
@@ -617,7 +617,7 @@ def tol_cset(colorset=None):
         "medium-contrast",
         "light",
     )
-    if colorset == None:
+    if colorset == None:  # noqa: E711
         return namelist
     if colorset not in namelist:
         colorset = "bright"