everything converted to new parameter system

countess/plugins/collate.py

@@ -17,12 +17,8 @@ class CollatePlugin(PandasProcessPlugin):
     version = VERSION
     link = "https://countess-project.github.io/CountESS/included-p  lugins/#collate"
 
-    parameters = {
-        "columns": PerColumnArrayParam(
-            "Columns", ChoiceParam("Role", choices=["—", "Group", "Sort (Asc)", "Sort (Desc)"])
-        ),
-        "limit": IntegerParam("First N records", 0),
-    }
+    columns = PerColumnArrayParam("Columns", ChoiceParam("Role", choices=["—", "Group", "Sort (Asc)", "Sort (Desc)"]))
+    limit = IntegerParam("First N records", 0)
 
     dataframes: List[pd.DataFrame]
 
@@ -37,22 +33,21 @@ def process(self, data: pd.DataFrame, source: str, logger: Logger) -> Iterable:
         return []
 
     def finalize(self, logger: Logger) -> Iterable[pd.DataFrame]:
-        assert isinstance(self.parameters["columns"], PerColumnArrayParam)
         assert self.dataframes
 
         df = pd.concat(self.dataframes)
         input_columns = get_all_columns(df).keys()
-        self.parameters["columns"].set_column_choices(input_columns)
-        column_parameters = list(zip(input_columns, self.parameters["columns"]))
+        self.columns.set_column_choices(input_columns)
+        column_parameters = list(zip(input_columns, self.columns))
         group_cols = [col for col, param in column_parameters if param.value == "Group"]
         sort_cols = {
             col: param.value.endswith("(Asc)") for col, param in column_parameters if param.value.startswith("Sort")
         }
 
         def sort_and_limit(df: pd.DataFrame) -> pd.DataFrame:
             df = df.sort_values(by=list(sort_cols.keys()), ascending=list(sort_cols.values()))
-            if self.parameters["limit"].value > 0:
-                df = df.head(self.parameters["limit"].value)
+            if self.limit > 0:
+                df = df.head(self.limit.value)
             return df
 
         try:

countess/plugins/column.py

@@ -3,7 +3,6 @@
 from countess import VERSION
 from countess.core.logger import Logger
 from countess.core.parameters import (
-    ArrayParam,
     BooleanParam,
     DataTypeOrNoneChoiceParam,
     PerColumnArrayParam,
@@ -13,28 +12,21 @@
 from countess.core.plugins import PandasSimplePlugin
 
 
+class _ColumnMultiParam(TabularMultiParam):
+    rename = StringParam("Name")
+    datatype = DataTypeOrNoneChoiceParam("Column Type")
+    index = BooleanParam("Index?")
+
+
 class ColumnToolPlugin(PandasSimplePlugin):
     name = "DataFrame Column Tool"
     description = "Alter Columns of a DataFrame"
     version = VERSION
 
-    parameters = {
-        "columns": PerColumnArrayParam(
-            "Columns",
-            TabularMultiParam(
-                "Column",
-                {
-                    "rename": StringParam("Name"),
-                    "datatype": DataTypeOrNoneChoiceParam("Column Type"),
-                    "index": BooleanParam("Index?"),
-                },
-            ),
-        )
-    }
+    columns = PerColumnArrayParam("Columns", _ColumnMultiParam("Column"))
 
     def process_dataframe(self, dataframe: pd.DataFrame, logger: Logger) -> pd.DataFrame:
-        assert isinstance(self.parameters["columns"], ArrayParam)
-        column_parameters = list(zip(self.input_columns, self.parameters["columns"]))
+        column_parameters = list(zip(self.input_columns, self.columns))
 
         drop_columns = [column_name for column_name, parameter in column_parameters if parameter.datatype.is_none()]
 

countess/plugins/correlation.py

@@ -16,34 +16,31 @@ class CorrelationPlugin(PandasSimplePlugin):
     version = VERSION
     link = "https://countess-project.github.io/CountESS/included-plugins/#correlation-tool"
 
-    parameters = {
-        "method": ChoiceParam("Method", choices=["pearson", "kendall", "spearman"]),
-        "group": ColumnOrNoneChoiceParam("Group"),
-        "column1": ColumnChoiceParam("Column 1"),
-        "column2": ColumnChoiceParam("Column 2"),
-    }
+    method = ChoiceParam("Method", choices=["pearson", "kendall", "spearman"])
+    group = ColumnOrNoneChoiceParam("Group")
+    column1 = ColumnChoiceParam("Column 1")
+    column2 = ColumnChoiceParam("Column 2")
+
     columns: list[str] = []
     dataframes: list[pd.DataFrame] = []
 
     def prepare(self, sources: list[str], row_limit: Optional[int] = None):
-        assert isinstance(self.parameters["group"], ColumnOrNoneChoiceParam)
-        column1 = self.parameters["column1"].value
-        column2 = self.parameters["column2"].value
+        column1 = self.column1.value
+        column2 = self.column2.value
         self.columns = [column1, column2]
-        if self.parameters["group"].is_not_none():
-            self.columns.append(self.parameters["group"].value)
+        if self.group.is_not_none():
+            self.columns.append(self.group.value)
         self.dataframes = []
 
     def process_dataframe(self, dataframe: pd.DataFrame, logger: Logger) -> None:
         self.dataframes.append(dataframe[self.columns])
 
     def finalize(self, logger: Logger) -> Iterable[pd.DataFrame]:
-        assert isinstance(self.parameters["group"], ColumnOrNoneChoiceParam)
-        column1 = self.parameters["column1"].value
-        column2 = self.parameters["column2"].value
-        groupby = None if self.parameters["group"].is_none() else self.parameters["group"].value
+        column1 = self.column1.value
+        column2 = self.column2.value
+        groupby = None if self.group.is_none() else self.group.value
 
-        method = self.parameters["method"].value
+        method = self.method.value
 
         dataframe = pd.concat(self.dataframes)
         if groupby:

countess/plugins/curve_fit.py

@@ -33,19 +33,15 @@ class CurveFitPlugin(PandasTransformDictToDictPlugin):
 
     version = VERSION
 
-    parameters = {
-        "xaxis": ColumnGroupOrNoneChoiceParam("X Axis", None, []),
-        "yaxis": ColumnGroupChoiceParam("Y Axis", None, []),
-        "function": ChoiceParam("Function", list(FUNCTIONS.keys())[0], list(FUNCTIONS.keys())),
-    }
+    xaxis = ColumnGroupOrNoneChoiceParam("X Axis", None, [])
+    yaxis = ColumnGroupChoiceParam("Y Axis", None, [])
+    function = ChoiceParam("Function", list(FUNCTIONS.keys())[0], list(FUNCTIONS.keys()))
 
     def process_dict(self, data: dict, logger: Logger) -> dict:
-        assert isinstance(self.parameters["xaxis"], ColumnGroupOrNoneChoiceParam)
-        assert isinstance(self.parameters["yaxis"], ColumnGroupChoiceParam)
         xprefix = None
-        if not self.parameters["xaxis"].is_none():
-            xprefix = self.parameters["xaxis"].value
-        yprefix = self.parameters["yaxis"].value
+        if not self.xaxis.is_none():
+            xprefix = self.xaxis.value
+        yprefix = self.yaxis.value
 
         tvals = {k.removeprefix(yprefix) for k in data.keys() if k.startswith(yprefix)}
         if xprefix:
@@ -62,7 +58,7 @@ def process_dict(self, data: dict, logger: Logger) -> dict:
                 yvals.append(yval)
 
         try:
-            function = FUNCTIONS[self.parameters["function"].value]
+            function = FUNCTIONS[self.function.value]
             popt, pcov, *_ = curve_fit(function, xvals, yvals)
 
             r = {f"popt_{n}": v for n, v in enumerate(popt)}

countess/plugins/filter.py

@@ -20,22 +20,26 @@
 
 OPERATORS = ["equals", "greater than", "less than", "contains", "starts with", "ends with", "matches regex"]
 
-class _FilterColumnMultiParam(MultiParam):
+
+class _FilterColumnMultiParam(TabularMultiParam):
     column = ColumnChoiceParam("Column")
     negate = BooleanParam("Negate?")
     operator = ChoiceParam("Operator", OPERATORS[0], OPERATORS)
     value = StringParam("Value")
 
-class _FilterOutputMultiParam(MultiParam):
+
+class _FilterOutputMultiParam(TabularMultiParam):
     output = StringParam("Output Column")
     value = StringParam("Output Value")
     type = DataTypeChoiceParam("Output Type")
 
+
 class FilterMultiParam(MultiParam):
     columns = ArrayParam("Columns", _FilterColumnMultiParam("Column"))
     combine = ChoiceParam("Combine", "All", ["All", "Any"])
     outputs = ArrayParam("Outputs", _FilterOutputMultiParam("Output"))
 
+
 class FilterPlugin(PandasSimplePlugin):
     name = "Filter Plugin"
     description = "Filter rows by simple expressions"

countess/plugins/group_by.py

@@ -18,6 +18,7 @@ class ColumnMultiParam(TabularMultiParam):
     sum = BooleanParam("Sum")
     mean = BooleanParam("Mean")
 
+
 class GroupByPlugin(PandasConcatProcessPlugin):
     """Groups a Pandas Dataframe by an arbitrary column and rolls up rows"""
 
@@ -40,8 +41,7 @@ def process(self, data: pd.DataFrame, source: str, logger: Logger) -> Iterable:
             keep_columns = [
                 col_param.label
                 for col_param in self.columns
-                if any(cp.value for cp in col_param.values())
-                and col_param.label in data.columns
+                if any(cp.value for cp in col_param.values()) and col_param.label in data.columns
             ]
             data = data[keep_columns]
 

countess/plugins/pivot.py

@@ -26,8 +26,7 @@ class PivotPlugin(PandasProcessPlugin):
     version = VERSION
     link = "https://countess-project.github.io/CountESS/included-plugins/#pivot-tool"
 
-    columns = PerColumnArrayParam("Columns",
-         ChoiceParam("Role", "Drop", choices=["Index", "Pivot", "Expand", "Drop"]))
+    columns = PerColumnArrayParam("Columns", ChoiceParam("Role", "Drop", choices=["Index", "Pivot", "Expand", "Drop"]))
     aggfunc = ChoiceParam("Aggregation Function", "sum", choices=["sum", "mean", "min", "max"])
 
     input_columns: Dict[str, np.dtype] = {}

countess/plugins/python.py

@@ -1,7 +1,7 @@
 import builtins
 import math
 import re
-from types import CodeType, FunctionType, ModuleType, NoneType
+from types import FunctionType, ModuleType, NoneType
 from typing import Any
 
 import numpy as np
@@ -50,18 +50,14 @@ class PythonPlugin(PandasTransformDictToDictPlugin):
 
     version = VERSION
 
-    parameters = {
-        "code": TextParam("Python Code"),
-        "dropna": BooleanParam("Drop Null Columns?"),
-    }
+    code = TextParam("Python Code")
+    dropna = BooleanParam("Drop Null Columns?")
 
     code_object = None
     code_globals: dict[str, Any] = {"__builtins__": SAFE_BUILTINS, **MATH_FUNCTIONS, **RE_FUNCTIONS, **NUMPY_IMPORTS}
 
     def process_dict(self, data: dict, logger: Logger):
-        assert isinstance(self.parameters["code"], TextParam)
-        assert isinstance(self.code_object, CodeType)
-
+        assert self.code_object is not None
         try:
             exec(self.code_object, self.code_globals, data)  # pylint: disable=exec-used
         except Exception as exc:  # pylint: disable=broad-exception-caught
@@ -75,7 +71,7 @@ def process_dataframe(self, dataframe: pd.DataFrame, logger: Logger) -> pd.DataF
         b) we don't need to merge afterwards"""
 
         # XXX cache this?
-        self.code_object = compile(self.parameters["code"].value, "<PythonPlugin>", mode="exec")
+        self.code_object = compile(self.code.value, "<PythonPlugin>", mode="exec")
 
         dataframe = dataframe.reset_index(drop=dataframe.index.names == [None])
         series = self.dataframe_to_series(dataframe, logger)
@@ -86,7 +82,7 @@ def process_dataframe(self, dataframe: pd.DataFrame, logger: Logger) -> pd.DataF
                 columns="__filter"
             )
 
-        if self.parameters["dropna"].value:
+        if self.dropna:
             dataframe.dropna(axis=1, how="all", inplace=True)
 
         return dataframe

countess/plugins/score.py

@@ -83,7 +83,6 @@ def process_row(
             return s[0] if s else None
 
     def process_dataframe(self, dataframe: pd.DataFrame, logger: Logger) -> Optional[pd.DataFrame]:
-
         variant_col = self.variant.value
         replicate_col = self.replicate.value
         count_cols = self.columns.get_column_names(dataframe)

countess/plugins/sequence.py

@@ -9,42 +9,39 @@
 
 
 class SequencePlugin(PandasTransformSingleToSinglePlugin):
-    """Manipulate DNA valueuences"""
+    """Manipulate DNA sequences"""
 
     name = "Sequence Tool"
     description = "Manipulate DNA Sequences"
     version = VERSION
     link = "https://countess-project.github.io/CountESS/included-plugins/#valueuence"
 
-    parameters = {
-        "column": ColumnChoiceParam("Input Column"),
-        "invert": BooleanParam("Invert", False),
-        "offset": IntegerParam("Offset", 0),
-        "start": StringParam("Start at ...", ""),
-        "stop": StringParam("Stop at ...", ""),
-        "length": IntegerParam("Max Length", 150),
-        "output": StringParam("Output Column", "sequence"),
-    }
+    column = ColumnChoiceParam("Input Column")
+    invert = BooleanParam("Invert", False)
+    offset = IntegerParam("Offset", 0)
+    start = StringParam("Start at ...", "")
+    stop = StringParam("Stop at ...", "")
+    length = IntegerParam("Max Length", 150)
+    output = StringParam("Output Column", "sequence")
 
     def process_value(self, value: str, logger: Logger) -> Optional[str]:
         if value is None:
             return None
 
-        if self.parameters["invert"].value:
+        if self.invert:
             value = reverse_complement(value)
-        if self.parameters["offset"].value:
-            offset = self.parameters["offset"].value
-            value = value[offset:]
-        if self.parameters["start"].value:
-            offset = value.find(self.parameters["start"].value)
+        if self.offset > 0:
+            value = value[int(self.offset) :]
+        if self.start:
+            offset = value.find(self.start.value)
             if offset >= 0:
                 value = value[offset:]
             else:
                 return None
-        if self.parameters["stop"].value:
-            offset = value.find(self.parameters["stop"].value)
+        if self.stop:
+            offset = value.find(self.stop.value)
             if offset >= 0:
-                value = value[0 : offset + len(self.parameters["stop"].value)]
-        if self.parameters["length"].value:
-            value = value[0 : self.parameters["length"].value]
+                value = value[0 : offset + len(self.stop.value)]
+        if self.length > 0:
+            value = value[0 : int(self.length)]
         return value

countess/plugins/variant.py

@@ -34,11 +34,11 @@ def process_dict(self, data, logger: Logger) -> dict:
 
         reference = self.reference.get_value_from_dict(data)
 
-        r = {}
+        r : dict[str,str] = {}
 
         if self.output:
             try:
-                r[self.output] = find_variant_string(
+                r[self.output.value] = find_variant_string(
                     "g.", reference, sequence, int(self.max_mutations), offset=int(self.offset)
                 )
             except ValueError: