sclab 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

sclab/utils/_write_excel.py

@@ -0,0 +1,510 @@
+import math
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Literal, Sequence
+
+import numpy as np
+import pandas as pd
+
+_column_format_type = Literal[
+    "text", "bold", "number", "scientific", "percentage", "nodecimal", "boolean"
+]
+
+
+def write_excel(
+    dataframes: pd.DataFrame | dict[str, pd.DataFrame],
+    file_path: str | Path,
+    sortby: str | list[str] | None = None,
+    sort_ascending: bool | list[bool] = None,
+    autofilter: bool = True,
+    guess_formats: bool = True,
+    guess_widths: bool = True,
+    column_formats: dict[str, _column_format_type] | None = None,
+    column_widths: dict[str, int] | None = None,
+    verbose: bool = False,
+) -> None:
+    """
+    Write pandas DataFrame(s) to an Excel file with enhanced formatting and styling.
+
+    This function provides advanced Excel writing capabilities including automatic format detection,
+    column width adjustment, conditional formatting, and table headers with autofilter.
+
+    Parameters
+    ----------
+    dataframes : pandas.DataFrame or dict[str, pandas.DataFrame]
+        Single DataFrame or dictionary of DataFrames where keys are sheet names.
+    file_path : str or pathlib.Path
+        Path where the Excel file will be saved.
+    sortby : str or None, optional
+        Column name to sort the data by. If specified, applies 3-color scale conditional formatting
+        to the sorted column. Default is None.
+    sort_ascending : bool, optional
+        Sort order when sortby is specified. Default is True.
+    autofilter : bool, optional
+        Whether to add filter buttons to column headers. Default is True.
+    guess_formats : bool, optional
+        Whether to automatically detect and apply appropriate formats based on column data types.
+        Default is True.
+    guess_widths : bool, optional
+        Whether to automatically estimate and apply column widths based on column name/contents.
+        Default is True.
+    column_formats : dict[str, str] or None, optional
+        Custom format specifications for columns. Keys are column names, values are format types:
+        "text", "bold", "number", "scientific", "percentage", "nodecimal", or "boolean".
+        Default is None.
+    column_widths : dict[str, int] or None, optional
+        Custom width specifications for columns. Keys are column names, values are widths in
+        Excel units. Default is None.
+    verbose : bool, optional
+        Whether to print detailed information about column formatting. Default is False.
+
+    Returns
+    -------
+    None
+
+    Notes
+    -----
+    - If a single DataFrame is provided, it will be written to 'Sheet1'
+    - Percentage columns get conditional formatting based on their values
+    - The function validates file writability and format specifications before proceeding
+    - Column formats and widths are either explicitly specified or automatically detected
+    """
+    if not isinstance(sortby, list):
+        sortby = [sortby]
+
+    if sort_ascending is None:
+        sort_ascending = [True]
+
+    if not isinstance(sort_ascending, list):
+        sort_ascending = [sort_ascending]
+
+    if column_formats is None:
+        column_formats = {}
+    else:
+        _validate_column_formats(column_formats)
+
+    if column_widths is None:
+        column_widths = {}
+    else:
+        _validate_column_widths(column_widths)
+
+    if not isinstance(dataframes, dict):
+        dataframes = {"Sheet1": dataframes}
+
+    file_path = Path(file_path)
+
+    if not _is_writable(file_path):
+        print(f"File {file_path} is not writable. Please make sure it's not in use.")
+        return
+
+    with pd.ExcelWriter(file_path) as writer:
+        for sheet_name, df in dataframes.items():
+            df = df.reset_index()
+
+            _sortby = [c for c in sortby if c in df.columns]
+            _sort_ascending = [a for a in sort_ascending if a]
+            if not _sort_ascending:
+                _sort_ascending = True
+            if _sortby:
+                df = df.sort_values(by=_sortby, ascending=_sort_ascending)
+
+            df.to_excel(
+                writer, sheet_name=sheet_name, index=False, startrow=1, header=False
+            )
+            max_row, max_col = df.shape
+
+            workbook = writer.book
+            formats = _get_formats_dict(workbook)
+
+            worksheet = writer.sheets[sheet_name]
+
+            for i, col in enumerate(df.columns):
+                if col in column_formats:
+                    column_format = column_formats[col]
+                elif guess_formats:
+                    column_format = _guess_column_format(df[col])
+                else:
+                    column_format = "noformat"
+
+                if col in column_widths:
+                    column_width = column_widths[col]
+                elif guess_widths:
+                    try:
+                        column_width = _guess_column_width(df[col], column_format)
+                    except ValueError:
+                        column_width = 10
+                else:
+                    column_width = 10
+
+                fmt = formats[column_format]
+                worksheet.set_column(i, i, column_width, fmt)
+
+                if verbose:
+                    _print_column_info(
+                        i, sheet_name, col, column_format, column_width, max_col
+                    )
+
+                if column_format == "percentage":
+                    fmt = _make_percentage_conditional_format()
+                    worksheet.conditional_format(0, i, max_row, i, fmt)
+
+                if column_format == "boolean":
+                    fmt = _make_cell_color_conditional_format(
+                        "==", "TRUE", formats["cellGreen"]
+                    )
+                    worksheet.conditional_format(0, i, max_row, i, fmt)
+
+                # if col in sortby:
+                #     fmt = _make_3_color_scale_conditional_format(df[col])
+                #     worksheet.conditional_format(0, i, max_row, i, fmt)
+
+                if m := re.match(
+                    r"^number_(Blue|Green|Red)(Blue|Green|Red)\|?([\-\+\d.]+)?,?([\-\+\d.]+)?,?([\-\+\d.]+)?$",
+                    column_format,
+                ):
+                    min_color = m.group(1)
+                    max_color = m.group(2)
+
+                    if m.group(3):
+                        min_value = float(m.group(3))
+                    else:
+                        min_value = None
+
+                    if m.group(4):
+                        mid_value = float(m.group(4))
+                    else:
+                        mid_value = None
+
+                    if m.group(5):
+                        max_value = float(m.group(5))
+                    else:
+                        max_value = None
+
+                    fmt = _make_3_color_scale_conditional_format(
+                        df[col],
+                        min_color=min_color,
+                        mid_color="White",
+                        max_color=max_color,
+                        min_value=min_value,
+                        mid_value=mid_value,
+                        max_value=max_value,
+                    )
+                    worksheet.conditional_format(0, i, max_row, i, fmt)
+
+                if m := re.match(
+                    r"^number_(Blue|Green|Red)(_desc)?\|?([\-\+\d.]+)?,?([\-\+\d.]+)?$",
+                    column_format,
+                ):
+                    desc = m.group(2) == "_desc"
+                    if desc:
+                        min_color = "White"
+                        max_color = m.group(1)
+                    else:
+                        min_color = m.group(1)
+                        max_color = "White"
+
+                    if m.group(3):
+                        min_value = float(m.group(3))
+                    else:
+                        min_value = None
+
+                    if m.group(4):
+                        max_value = float(m.group(4))
+                    else:
+                        max_value = None
+
+                    fmt = _make_2_color_scale_conditional_format(
+                        df[col],
+                        min_color=min_color,
+                        max_color=max_color,
+                        min_value=min_value,
+                        max_value=max_value,
+                    )
+                    # print(col, df[col].dtype, df[col].iloc[:5].to_list(), fmt)
+                    worksheet.conditional_format(0, i, max_row, i, fmt)
+
+                if column_format == "3color":
+                    fmt = _make_3_color_scale_conditional_format(df[col])
+                    worksheet.conditional_format(0, i, max_row, i, fmt)
+
+            _write_table_header(df.columns, worksheet, formats["header_format"])
+
+            if autofilter:
+                worksheet.autofilter(0, 0, max_row - 1, max_col - 1)
+
+
+def _color(color: str):
+    match color:
+        case "Blue":
+            return "#B3CDE3"
+        case "Green":
+            return "#B3E3B3"
+        case "Red":
+            return "#FFB3B3"
+        case "White":
+            return "#F7F7F7"
+        case _:
+            raise ValueError(f"Invalid color: {color}")
+
+
+def _validate_column_formats(column_formats: dict[str, str]):
+    assert isinstance(column_formats, dict), "column_formats must be a dict"
+    for col, fmt in column_formats.items():
+        if re.match(
+            r"^number_(Blue|Green|Red)(Blue|Green|Red)?(_desc)?\|?([\-\+\d.]+)?,?([\-\+\d.]+)?,?([\-\+\d.]+)?$",
+            fmt,
+        ):
+            continue
+        else:
+            assert fmt in (
+                "text",
+                "bold",
+                "number",
+                "scientific",
+                "percentage",
+                "nodecimal",
+                "boolean",
+            ), f"Unknown format: {fmt}"
+
+
+def _validate_column_widths(column_widths: dict[str, int]):
+    assert isinstance(column_widths, dict), "column_widths must be a dict"
+    for col, width in column_widths.items():
+        assert isinstance(width, int | float), f"Invalid column width: {width}"
+        assert width > 0, f"Invalid column width: {width}"
+
+
+def _is_writable(file_path: str | Path) -> None:
+    file_path = Path(file_path)
+
+    if file_path.exists() and file_path.is_file():
+        try:
+            with open(file_path, "a"):
+                return True
+        except PermissionError:
+            return False
+
+    return True
+
+
+def _get_formats_dict(workbook):
+    return defaultdict(
+        lambda: workbook.add_format(),
+        **{
+            "noformat": workbook.add_format(),
+            "header_format": workbook.add_format(
+                {
+                    "bold": True,
+                    "text_wrap": True,
+                    "valign": "top",
+                    "fg_color": "#FCFCFC",
+                    "border": 1,
+                }
+            ),
+            "text": workbook.add_format({"font_name": "Calibri", "font_size": 11}),
+            "bold": workbook.add_format({"bold": True}),
+            "number": workbook.add_format({"num_format": "0.00"}),
+            "scientific": workbook.add_format({"num_format": "0.00E+00"}),
+            "percentage": workbook.add_format({"num_format": "0.00%"}),
+            "nodecimal": workbook.add_format({"num_format": "0"}),
+            "boolean": workbook.add_format(
+                {
+                    "bold": True,
+                    "valign": "center",
+                    "align": "center",
+                    "font_name": "Monospace",
+                    "font_size": 11,
+                }
+            ),
+            **{
+                f"cell{color}": workbook.add_format(
+                    {
+                        "bg_color": _color(color),
+                    }
+                )
+                for color in ["Blue", "Green", "Red", "White"]
+            },
+        },
+    )
+
+
+def _guess_column_format(column: pd.Series) -> str:
+    if pd.api.types.is_bool_dtype(column):
+        return "boolean"
+
+    if pd.api.types.is_numeric_dtype(column):
+        if pd.api.types.is_float_dtype(column):
+            eps = np.finfo(column.dtype).eps
+
+            if (column % 1 == 0).all():
+                return "nodecimal"
+
+            if np.log10(column.abs() + eps).max() > 6:
+                return "scientific"
+
+            if np.log10(column.abs() + eps).min() < -3:
+                return "scientific"
+
+            return "number"
+
+        return "nodecimal"
+
+    return "text"
+
+
+def _guess_column_width(
+    column: pd.Series,
+    column_format: str,
+    step: int = 6,
+    min_width: int = 10,
+    max_width: int = 75,
+) -> int:
+    # widths should be multiple of 5, minimum 10 and maximum 75
+    colname = str(column.name)
+    colname_len = len(colname)
+    if len(column) == 0:
+        return _round_width(colname_len, step, min_width, max_width)
+
+    match column_format:
+        case "text":
+            max_len = int(column.str.len().max())
+            return _round_width(max(max_len, colname_len), step, min_width, max_width)
+
+        case "number" | "nodecimal" | "scientific" | "boolean":
+            return _round_width(colname_len, step, min_width, max_width)
+
+        case x if re.match("^number_.*", x):
+            return _round_width(colname_len, step, min_width, max_width)
+
+        case "percentage":
+            return _round_width(max(min_width, colname_len), step, min_width, max_width)
+
+        case _:
+            raise ValueError(f"Unknown format: {column_format}")
+
+
+def _round_width(value: float, step: int, min_width: int, max_width: int) -> int:
+    out = math.ceil(value * 1.4)
+    return int(max(min_width, min(max_width, out)))
+
+
+def _print_column_info(i, sheet_name, col, column_format, column_width, max_col):
+    if i == 0:
+        print()
+        print("-" * 55)
+        print(f"| Sheet Name: {sheet_name:<39} |")
+        print("-" * 55)
+        print(f"| {'Column':<20} | {'Format':<20} | {'Width':>5} |")
+        print("-" * 55)
+    print(f"| {col[:20]:>20} | {column_format:>20} | {column_width:>5} |")
+    if i == max_col - 1:
+        print("-" * 55)
+
+
+def _make_percentage_conditional_format():
+    return {
+        "type": "data_bar",
+        "bar_color": "#76C1E1",  # Light blue for the bar color
+        "min_type": "num",  # Define minimum as a numeric value
+        "min_value": 0,  # Minimum percentage (0%)
+        "max_type": "num",  # Define maximum as a numeric value
+        "max_value": 1,  # Maximum percentage (100%)
+    }
+
+
+def _make_cell_color_conditional_format(criteria, value, fmt):
+    return {
+        "type": "cell",
+        "criteria": criteria,
+        "value": value,
+        "format": fmt,
+    }
+
+
+def _make_3_color_scale_conditional_format(
+    series: pd.Series,
+    scale: float = 1.5,
+    min_color: str = "Blue",  # soft blue
+    mid_color: str = "White",  # off-white
+    max_color: str = "Red",  # soft red
+    min_value: int | float | None = None,
+    mid_value: int | float | None = None,
+    max_value: int | float | None = None,
+):
+    values = series.loc[np.isfinite(series)]
+
+    if min_value is None and mid_value is None and max_value is None:
+        bound = values.quantile([0, 1]).abs().max() * scale
+        min_value = -bound
+        mid_value = 0
+        max_value = bound
+
+    if min_value is None:
+        min_value = values.min()
+
+    if max_value is None:
+        max_value = values.max()
+
+    if mid_value is None:
+        mid_value = (values.max() + values.min()) / 2
+
+    if not min_color.startswith("#"):
+        min_color = _color(min_color)
+
+    if not mid_color.startswith("#"):
+        mid_color = _color(mid_color)
+
+    if not max_color.startswith("#"):
+        max_color = _color(max_color)
+
+    return {
+        "type": "3_color_scale",
+        "min_type": "num",  # Can be "num", "percent", or "percentile"
+        "min_value": min_value,
+        "min_color": min_color,
+        "mid_type": "num",
+        "mid_value": mid_value,
+        "mid_color": mid_color,
+        "max_type": "num",
+        "max_value": max_value,
+        "max_color": max_color,
+    }
+
+
+def _make_2_color_scale_conditional_format(
+    series: pd.Series,
+    min_color: str = "#F7F7F7",
+    max_color: str = "#B3E3B3",
+    min_value: int | float | None = None,
+    max_value: int | float | None = None,
+):
+    values = series.loc[np.isfinite(series)]
+
+    if min_value is None:
+        min_value = values.quantile(0.05)
+
+    if max_value is None:
+        max_value = values.quantile(0.95)
+
+    if not min_color.startswith("#"):
+        min_color = _color(min_color)
+
+    if not max_color.startswith("#"):
+        max_color = _color(max_color)
+
+    return {
+        "type": "2_color_scale",
+        "min_type": "num",
+        "min_value": min_value,
+        "min_color": min_color,
+        "max_type": "num",
+        "max_value": max_value,
+        "max_color": max_color,
+    }
+
+
+def _write_table_header(column_names: Sequence[str], worksheet, header_format):
+    # Write the column headers with the defined format.
+    for col_num, value in enumerate(column_names):
+        worksheet.write(0, col_num, value, header_format)

{sclab-0.2.5.dist-info → sclab-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sclab
-Version: 0.2.5
+Version: 0.3.1
 Summary: sclab
 Author-email: Argenis Arriojas <ArriojasMaldonado001@umb.edu>
 Requires-Python: >=3.10,<3.13
@@ -14,16 +14,19 @@ License-File: LICENSE
 Requires-Dist: anndata
 Requires-Dist: anywidget
 Requires-Dist: ipywidgets
-Requires-Dist: itables
+Requires-Dist: itables<2.4
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2.2
 Requires-Dist: pandas
 Requires-Dist: plotly<6.0
 Requires-Dist: requests
+Requires-Dist: ripser>=0.6.12
 Requires-Dist: scikit-learn
 Requires-Dist: svgpathtools
 Requires-Dist: tqdm
 Requires-Dist: jupyterlab>=4.3.6 ; extra == "jupyter"
+Requires-Dist: anndata2ri>=1.3 ; extra == "r"
+Requires-Dist: rpy2>=3.5 ; extra == "r"
 Requires-Dist: scanpy[leiden, skmisc]>=1.10 ; extra == "scanpy"
 Requires-Dist: pytest>=8.3.4 ; extra == "test"
 Project-URL: Bug Tracker, https://github.com/umbibio/sclab/issues
@@ -32,6 +35,7 @@ Project-URL: Documentation, https://github.com/umbibio/sclab/docs
 Project-URL: Homepage, https://github.com/umbibio/sclab
 Project-URL: Repository, https://github.com/umbibio/sclab.git
 Provides-Extra: jupyter
+Provides-Extra: r
 Provides-Extra: scanpy
 Provides-Extra: test
 

sclab-0.3.1.dist-info/RECORD

@@ -0,0 +1,82 @@
+sclab/__init__.py,sha256=8CMvbWDJrjAoC3ycfq28IKCXtE7xhAm_iORs4Jj6yi8,132
+sclab/_io.py,sha256=5ISxIPbE233UiOt3QEs9fkLO8DLLEe5HrMnZoR-KLYE,2662
+sclab/_methods_registry.py,sha256=RcffyRuuLzHqsnAdbBL4W1GmZx80d9AxdGjUnx1mbNg,1704
+sclab/_sclab.py,sha256=P7rR82jPPNRp4K9s_GBK0Qcd3xYt7Qc4Zsd-rxiVAK8,9133
+sclab/dataset/__init__.py,sha256=f9PoXIMAPnC3Var1ODr3mXkotW6u6NRPQvlgcWYXk54,143
+sclab/dataset/_dataset.py,sha256=wsbWnBHnlGJ779RV1Vv7RfxlEzHCfUZKNT3FTI1mu9g,14248
+sclab/dataset/_exceptions.py,sha256=g8RJL8PiRmD4--PkOs5CZth_qeaduvieMlKJNkrUIYA,45
+sclab/dataset/plotter/__init__.py,sha256=pdWhAywnoc1_nnIcD-qNW0U364-yo4k5DwP79y9NVgA,129
+sclab/dataset/plotter/_controls.py,sha256=NBDdtY1wQbIEvE_WToigR5bEEoi3z30_67T_dLSOSIo,20295
+sclab/dataset/plotter/_plotter.py,sha256=EXwk6KSM7FOyLLJ8HCgIB_2m730t0kHsVKWfQOxL6kA,37023
+sclab/dataset/plotter/_utils.py,sha256=ANm_R9PJd33-QJtZzqXCN5pJ_XrJ7AA4AvSHaDRbOMA,11595
+sclab/dataset/processor/__init__.py,sha256=v8Qbusb6h8oSndv9q-12vzHrz5BDF3N2LCkQG9KC19I,104
+sclab/dataset/processor/_processor.py,sha256=ink2eqi7hMt4DunHD4U1KqkKNQd23yJiDOgsmgZTsb8,41684
+sclab/dataset/processor/_results_panel.py,sha256=p2xmHgoYfpkPXj-SjRGTmAPAwL1VC8I70iFD_o-90AE,2342
+sclab/dataset/processor/step/__init__.py,sha256=j8j4oU9NMdWHn6kVjft7Klm6xme8M6wzebxJj_zNehg,179
+sclab/dataset/processor/step/_basic_processor_step.py,sha256=7NKC4W-I_EU3QBPi5BL9-NwAF_h6_oWl1l_kEk6gSAg,3640
+sclab/dataset/processor/step/_processor_step_base.py,sha256=DpbL4F53W1YPI_xHuQ0T3gcvDGwwKG2Xp-n8DkMUf90,4133
+sclab/event/__init__.py,sha256=unkfpmoxitPVZvWcc9YhkUwcXODdcd9cw_toVXVIDMU,126
+sclab/event/_broker.py,sha256=W4GgoBhJS1LxGQv8TYFg71o5jUQPO8BDLrKzahDUyEM,7121
+sclab/event/_client.py,sha256=Kx7pza-CzLySR0JBBneiZQAjtllUnjWKNKSfw3K2ZQE,2362
+sclab/event/_utils.py,sha256=LehiFhn7dopNEaTFERJhs6fiVgXCBvseRxWTSWc6u-k,456
+sclab/examples/__init__.py,sha256=uSu4DMfF2K7xlZbLC_CmANyS3D56khGLMSVt6x9XXiI,68
+sclab/examples/processor_steps/__init__.py,sha256=_b9nLeZhyVex17lk8Vvy44eXbvKhygrPOZXpaM1jfSo,575
+sclab/examples/processor_steps/_cluster.py,sha256=olbri3HWPBU8p__r9kP9tgWaJoUJ2bK48pmHfdvf11c,1120
+sclab/examples/processor_steps/_differential_expression.py,sha256=uEToPiACCgo42oZidAw5DFgWVcDnChWzVRlVzn53K34,11567
+sclab/examples/processor_steps/_doublet_detection.py,sha256=eFQtRsdvBWJ_v3HH08v-KbjYius-fj1pg1HBm0mjADg,2114
+sclab/examples/processor_steps/_gene_expression.py,sha256=io_U53TQ3bpclGZ7xjuQHws4Lei5_nMpWTKbvD2zqs0,4216
+sclab/examples/processor_steps/_integration.py,sha256=40nIM19VnBALMQXYO9XpYczH7gEcpIUb-DLdYraxzxs,3444
+sclab/examples/processor_steps/_neighbors.py,sha256=jGpoPtlN8nlcsOqUOiqTPQgGzbpToLAVR1By2SHBo5U,2949
+sclab/examples/processor_steps/_pca.py,sha256=kULbPPTAMqAgECyycmpf5dpU-FYPJSLbTO-UEkOb5mo,4798
+sclab/examples/processor_steps/_preprocess.py,sha256=kKqOQWyBC3BFLYVsCWRPwaXHeuWG1s69puvwhDQK5Eg,6809
+sclab/examples/processor_steps/_qc.py,sha256=3e5TTGPNWbGPJBX0Sx18np8qcrgPznUuJJ-DwCrRZ0U,3684
+sclab/examples/processor_steps/_umap.py,sha256=Mzxj4LiZfh3WT5lS_BO_lTleC5jMoUm5_km_gvzU_I8,1402
+sclab/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/gui/components/__init__.py,sha256=X0-cGJmII76qpWHEBe49miS2gPw3esMAwp61z23w_1Q,161
+sclab/gui/components/_guided_pseudotime.py,sha256=sxI0jmZxD4fxV9CsTJONhINWzIL--YF3nDg0nku2yp8,17670
+sclab/gui/components/_transfer_metadata.py,sha256=o9t9bQ7tr3G2-vFptUu1IiMxGhvMq-QJb_lF7AsDhQQ,6236
+sclab/methods/__init__.py,sha256=d_n5SCyzwMEBZttXwnhgkx2FnD7AxhAK9yBre6Rynfk,1215
+sclab/preprocess/__init__.py,sha256=zGt-TIDRx3qoKDpFxqnZ9yf2AfP4HBy8ZZSFLx-rGj0,547
+sclab/preprocess/_cca.py,sha256=etDk1s3rKX-r0nkRuUaLTJ7NyalauCpWXyKRq1_EwTc,4400
+sclab/preprocess/_cca_integrate.py,sha256=14Tu6TyH7wfZYAM2EsII1R92PTxfhaYbGx4bLWlMLP0,2706
+sclab/preprocess/_filter_obs.py,sha256=uYlcljuaq85G44Si8oxrNRcCCX2nFRdT3RN3ArqnwaY,1166
+sclab/preprocess/_harmony.py,sha256=wpFQXpr13BvljT04I_Rw5JdBvhzvAuinkrRs152CfvQ,13747
+sclab/preprocess/_harmony_integrate.py,sha256=cKN_MyYq9FtwgQZyhgxiFNTZl36YuKLQdEoc7ky-ea4,1737
+sclab/preprocess/_normalize_weighted.py,sha256=h86rQakNoXoRKOepAEoBbBtHV_F-VMG2-uW_LcaSdWs,1587
+sclab/preprocess/_subset.py,sha256=8Vc5jty8WzIf8NZ1mleqNJLAp5CRWvEXGVevlT6ekNk,7066
+sclab/preprocess/_transfer_metadata.py,sha256=HA11JHHpq4ueFTeXlU4K3kHDDUzcUjyvfxpzdPBRNTo,4307
+sclab/preprocess/_transform.py,sha256=n2xHJR3T-rRxZneCFH2oMw9RaQcGGBfHpOu1-YP1c1E,2312
+sclab/preprocess/_utils.py,sha256=dLeS_fIvQGZZfesEtbJKtnPmqjqy3fmyTC4GewRD3Fc,3078
+sclab/scanpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/scanpy/_compat.py,sha256=VEdW4lWLtKmgLSrikRnfvYOz9EOa7e_iDt4Q88X9JKQ,2109
+sclab/scanpy/_settings.py,sha256=UVcJExVHsf_nvyZ5kTrBHPkddHCz7ARCzqAdZAM_A5E,16736
+sclab/scanpy/logging.py,sha256=VwSPeKjpXeopdcgEAlWDz2Wv4IGAAUv8GyMNpMART-0,8453
+sclab/scanpy/readwrite.py,sha256=yixHonShUZ2Ms3Sv3UXw_VXlY00XDApvmyN2mZWFAcs,37025
+sclab/scanpy/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/scanpy/plotting/_rcmod.py,sha256=pc53dasHh2RFfTHVTbTb8v1z8vW032zjvum-WQLgjXA,1970
+sclab/scanpy/plotting/palettes.py,sha256=zHTM_CVfKazb32YreRx0-INllFssZP5rY_B7JTeaBhA,4782
+sclab/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/tools/cellflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/tools/cellflow/density_dynamics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/tools/cellflow/density_dynamics/_density_dynamics.py,sha256=xzmeIAHLV5xIVERpWMClZViDpJcge_dPsx6GWI0j0R8,11038
+sclab/tools/cellflow/pseudotime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/tools/cellflow/pseudotime/_pseudotime.py,sha256=RiwbOduu0InNdh2Rp8DUXG6-r5wL_vVUGTyTkwnYhTY,9842
+sclab/tools/cellflow/pseudotime/timeseries.py,sha256=ZuMAm9LOKksJy2FzsQg3rdYKtLm1G0rbgO6dOdQuIV0,6326
+sclab/tools/cellflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sclab/tools/cellflow/utils/density_nd.py,sha256=wwYoXOcF2CRxOArW_CQxJjWDE90wiui4NO7EIBG2RGM,6648
+sclab/tools/cellflow/utils/interpolate.py,sha256=HnpYEBdc4KSPC4QYOglJ2MpipLx3a5ENJQ8uhMnuwRc,9755
+sclab/tools/cellflow/utils/smoothen.py,sha256=yg2_zBrYKGRmXZY8C3pKmX3xGm0GGMI365IKqhgCmP0,3738
+sclab/tools/cellflow/utils/times.py,sha256=lV5ZRjCdBaYELGJ1pGdEBeA0w-WD77lOzPC6R7_kUxo,1811
+sclab/tools/differential_expression/__init__.py,sha256=KKaDzeGGgE1LxnC5aBcPQYcVX_e2h8qAbfMPQVvYlSA,87
+sclab/tools/differential_expression/_pseudobulk_edger.py,sha256=WWqKEA8I1I_YsgjafeznX3tyZoXyu0HV13QkxiYGFgQ,10538
+sclab/tools/differential_expression/_pseudobulk_helpers.py,sha256=raQ0DBBrmrxBbGTKhOyZpZLmeJRX_tWcn3_mzuQctkw,8424
+sclab/tools/doublet_detection/__init__.py,sha256=zWyAPScrHVRaBqWaizVsm2H3oi6yr0OQ5gF-fGY2ZrA,63
+sclab/tools/doublet_detection/_scrublet.py,sha256=koi6MRUS1lWVvdpeNbzpR8njqVFrWEuWoKNMFXQLFec,1953
+sclab/tools/labeling/__init__.py,sha256=o-FJWonGNr2h_pB0o3YfnGl_y1kKU06_rYLmTt8ktlQ,57
+sclab/tools/labeling/sctype.py,sha256=jCsCFnqUgb_s1nTSK-N_5pEL_ZvZw-zUo12fUy9RLfs,8164
+sclab/utils/__init__.py,sha256=Py3dPN9ptMs6D-f7IGYisoxOS2YuX0O1oyw75nci3Os,72
+sclab/utils/_write_excel.py,sha256=DBZg9Kx7Ex6VqFrZFDZbSgvzMtu84iEwKo4nI3I2AT0,17017
+sclab-0.3.1.dist-info/licenses/LICENSE,sha256=LO7qldZoHIo9hc-HMBqclBh5800kZ9US9xTbLAQdHpg,1523
+sclab-0.3.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+sclab-0.3.1.dist-info/METADATA,sha256=ZFKIgYqmj_ukAhQlAntHDbhap1-kd3k_fy59FwXHgoE,4437
+sclab-0.3.1.dist-info/RECORD,,

sclab-0.2.5.dist-info/RECORD

@@ -1,45 +0,0 @@
-sclab/__init__.py,sha256=wkce6wEC7pfIGHWjYbTJ0_ZAoXv1zRmeOrtEvuBUp8E,132
-sclab/_io.py,sha256=5ISxIPbE233UiOt3QEs9fkLO8DLLEe5HrMnZoR-KLYE,2662
-sclab/_methods_registry.py,sha256=RcffyRuuLzHqsnAdbBL4W1GmZx80d9AxdGjUnx1mbNg,1704
-sclab/_sclab.py,sha256=-ukFb0bWX5MPZsKnoXBJ9SvKyQpuTK4VUCzmWYnAVNM,9062
-sclab/dataset/__init__.py,sha256=f9PoXIMAPnC3Var1ODr3mXkotW6u6NRPQvlgcWYXk54,143
-sclab/dataset/_dataset.py,sha256=dJeiEfo-f6eM866-d53H6FUF9IR-OK4vwDojSq_og0Q,14248
-sclab/dataset/_exceptions.py,sha256=g8RJL8PiRmD4--PkOs5CZth_qeaduvieMlKJNkrUIYA,45
-sclab/dataset/plotter/__init__.py,sha256=pdWhAywnoc1_nnIcD-qNW0U364-yo4k5DwP79y9NVgA,129
-sclab/dataset/plotter/_controls.py,sha256=NBDdtY1wQbIEvE_WToigR5bEEoi3z30_67T_dLSOSIo,20295
-sclab/dataset/plotter/_plotter.py,sha256=EXwk6KSM7FOyLLJ8HCgIB_2m730t0kHsVKWfQOxL6kA,37023
-sclab/dataset/plotter/_utils.py,sha256=ANm_R9PJd33-QJtZzqXCN5pJ_XrJ7AA4AvSHaDRbOMA,11595
-sclab/dataset/processor/__init__.py,sha256=v8Qbusb6h8oSndv9q-12vzHrz5BDF3N2LCkQG9KC19I,104
-sclab/dataset/processor/_processor.py,sha256=H8smeuHPnJVToSxEgGNHUpyNwKYqP-Itp5jMVIgnjbc,41104
-sclab/dataset/processor/_results_panel.py,sha256=p2xmHgoYfpkPXj-SjRGTmAPAwL1VC8I70iFD_o-90AE,2342
-sclab/dataset/processor/step/__init__.py,sha256=j8j4oU9NMdWHn6kVjft7Klm6xme8M6wzebxJj_zNehg,179
-sclab/dataset/processor/step/_basic_processor_step.py,sha256=7NKC4W-I_EU3QBPi5BL9-NwAF_h6_oWl1l_kEk6gSAg,3640
-sclab/dataset/processor/step/_processor_step_base.py,sha256=DpbL4F53W1YPI_xHuQ0T3gcvDGwwKG2Xp-n8DkMUf90,4133
-sclab/event/__init__.py,sha256=unkfpmoxitPVZvWcc9YhkUwcXODdcd9cw_toVXVIDMU,126
-sclab/event/_broker.py,sha256=W4GgoBhJS1LxGQv8TYFg71o5jUQPO8BDLrKzahDUyEM,7121
-sclab/event/_client.py,sha256=Kx7pza-CzLySR0JBBneiZQAjtllUnjWKNKSfw3K2ZQE,2362
-sclab/event/_utils.py,sha256=LehiFhn7dopNEaTFERJhs6fiVgXCBvseRxWTSWc6u-k,456
-sclab/examples/__init__.py,sha256=uSu4DMfF2K7xlZbLC_CmANyS3D56khGLMSVt6x9XXiI,68
-sclab/examples/processor_steps/__init__.py,sha256=ymEOSOlQANfMcyjUQxFEzzzjoZFv8IejfnEFUfPqwKg,500
-sclab/examples/processor_steps/_cluster.py,sha256=olbri3HWPBU8p__r9kP9tgWaJoUJ2bK48pmHfdvf11c,1120
-sclab/examples/processor_steps/_differential_expression.py,sha256=uEToPiACCgo42oZidAw5DFgWVcDnChWzVRlVzn53K34,11567
-sclab/examples/processor_steps/_gene_expression.py,sha256=io_U53TQ3bpclGZ7xjuQHws4Lei5_nMpWTKbvD2zqs0,4216
-sclab/examples/processor_steps/_integration.py,sha256=Vzl2AdLJmnagPWtNYuqW-AmKbQ8jfRSKdui_DpQX1-8,2729
-sclab/examples/processor_steps/_neighbors.py,sha256=sEhLuuY-dCdwzqIarHpFVgM4tE1bW9Qa18xHOWA84Bk,2206
-sclab/examples/processor_steps/_pca.py,sha256=vit15FqHhWC-VSLSViduFt9V7dwakVvdnDOHxzJHiw0,4585
-sclab/examples/processor_steps/_preprocess.py,sha256=pDPAzcqbHyX2zKrGY7HHNYCzrM-wI6VL7YGwUrkq9os,6172
-sclab/examples/processor_steps/_qc.py,sha256=KPWKxytu5YLXQ42uXe3ARKE36jqj5uidLhtyR-_TVBY,3238
-sclab/examples/processor_steps/_umap.py,sha256=Mzxj4LiZfh3WT5lS_BO_lTleC5jMoUm5_km_gvzU_I8,1402
-sclab/methods/__init__.py,sha256=gqqKIvai7E30IA5f4OnYZcyu5xUDF03GzYDkAZNhzr4,823
-sclab/scanpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sclab/scanpy/_compat.py,sha256=VEdW4lWLtKmgLSrikRnfvYOz9EOa7e_iDt4Q88X9JKQ,2109
-sclab/scanpy/_settings.py,sha256=UVcJExVHsf_nvyZ5kTrBHPkddHCz7ARCzqAdZAM_A5E,16736
-sclab/scanpy/logging.py,sha256=VwSPeKjpXeopdcgEAlWDz2Wv4IGAAUv8GyMNpMART-0,8453
-sclab/scanpy/readwrite.py,sha256=yixHonShUZ2Ms3Sv3UXw_VXlY00XDApvmyN2mZWFAcs,37025
-sclab/scanpy/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sclab/scanpy/plotting/_rcmod.py,sha256=pc53dasHh2RFfTHVTbTb8v1z8vW032zjvum-WQLgjXA,1970
-sclab/scanpy/plotting/palettes.py,sha256=zHTM_CVfKazb32YreRx0-INllFssZP5rY_B7JTeaBhA,4782
-sclab-0.2.5.dist-info/licenses/LICENSE,sha256=LO7qldZoHIo9hc-HMBqclBh5800kZ9US9xTbLAQdHpg,1523
-sclab-0.2.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-sclab-0.2.5.dist-info/METADATA,sha256=q_ELS5JEz0AuZ9kaN0yHVFM2cHb4pUJ6iXbiMfJHom4,4299
-sclab-0.2.5.dist-info/RECORD,,