ModDotPlot 1.0.0__cp38-abi3-win_amd64.whl

moddotplot/__init__.py

@@ -0,0 +1,29 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'moddotplot.libs'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-moddotplot-1.0.0')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-moddotplot-1.0.0')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch

moddotplot/__main__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+from contextlib import redirect_stderr, redirect_stdout
+import os
+import sys
+
+
+def _run(arguments):
+    from moddotplot.moddotplot import main as run_moddotplot
+
+    return run_moddotplot(arguments)
+
+
+def main(arguments=None):
+    """Load the CLI under quiet redirection to cover import-time output."""
+
+    raw_arguments = list(sys.argv[1:] if arguments is None else arguments)
+    if "--quiet" not in raw_arguments:
+        return _run(raw_arguments)
+
+    with open(os.devnull, "w", encoding="utf-8") as sink:
+        with redirect_stdout(sink), redirect_stderr(sink):
+            return _run(raw_arguments)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

moddotplot/annotations.py

@@ -0,0 +1,113 @@
+"""Shared BED annotation parsing and interval-selection helpers."""
+
+import numpy as np
+import pandas as pd
+
+DEFAULT_ANNOTATION_COLOR = "#4C72B0"
+BED_COLUMNS = [
+    "chrom",
+    "start",
+    "end",
+    "name",
+    "score",
+    "strand",
+    "thickStart",
+    "thickEnd",
+    "itemRgb",
+]
+
+
+def read_annotation_bed(filepath):
+    """Read the BED3-BED9 subset used by ModDotPlot annotations."""
+
+    try:
+        dataframe = pd.read_csv(filepath, sep="\t", comment="#", header=None, dtype=str)
+    except pd.errors.EmptyDataError:
+        return pd.DataFrame(columns=BED_COLUMNS[:3])
+
+    if not 3 <= dataframe.shape[1] <= len(BED_COLUMNS):
+        raise ValueError(
+            "Invalid BED file: expected between 3 and 9 tab-separated columns."
+        )
+
+    dataframe.columns = BED_COLUMNS[: dataframe.shape[1]]
+    dataframe["chrom"] = dataframe["chrom"].astype(str)
+
+    for column in ("start", "end"):
+        try:
+            values = pd.to_numeric(dataframe[column], errors="raise")
+        except (TypeError, ValueError) as error:
+            raise ValueError(
+                f"Invalid BED file: '{column}' must contain only integers."
+            ) from error
+        if values.isna().any() or not np.all(np.isfinite(values)):
+            raise ValueError(
+                f"Invalid BED file: '{column}' must contain only finite integers."
+            )
+        if np.any(values % 1 != 0):
+            raise ValueError(
+                f"Invalid BED file: '{column}' must contain only integers."
+            )
+        dataframe[column] = values.astype(np.int64)
+
+    if (dataframe["start"] < 0).any():
+        raise ValueError("Invalid BED file: 'start' must be non-negative.")
+    if (dataframe["end"] <= dataframe["start"]).any():
+        raise ValueError(
+            "Invalid BED file: 'end' must be greater than 'start' for every interval."
+        )
+
+    return dataframe
+
+
+def read_annotation_beds(filepaths):
+    """Read and combine one or more annotation BED files."""
+
+    frames = [read_annotation_bed(filepath) for filepath in filepaths]
+    if not frames:
+        return pd.DataFrame(columns=BED_COLUMNS[:3])
+    return pd.concat(frames, ignore_index=True, sort=False)
+
+
+def annotation_color(value, fallback=DEFAULT_ANNOTATION_COLOR):
+    """Return an RGB tuple for a BED ``itemRgb`` value."""
+
+    if value is None or pd.isna(value):
+        return fallback
+
+    fields = [field.strip() for field in str(value).split(",")]
+    if len(fields) != 3:
+        return fallback
+
+    try:
+        channels = tuple(int(field) for field in fields)
+    except ValueError:
+        return fallback
+    if any(channel < 0 or channel > 255 for channel in channels):
+        return fallback
+    return tuple(channel / 255 for channel in channels)
+
+
+def visible_annotation_intervals(
+    bed_df, chrom, region_start, region_end, fallback=DEFAULT_ANNOTATION_COLOR
+):
+    """Select and clip BED intervals to a plotted genomic region."""
+
+    if region_end <= region_start:
+        raise ValueError("Annotation region end must be greater than its start.")
+    if bed_df.empty:
+        return []
+
+    intervals = []
+    matching = bed_df[bed_df["chrom"] == str(chrom)]
+    has_item_rgb = "itemRgb" in matching.columns
+    for row in matching.itertuples(index=False):
+        interval_start = int(row.start)
+        interval_end = int(row.end)
+        clipped_start = max(interval_start, region_start)
+        clipped_end = min(interval_end, region_end)
+        if clipped_end <= clipped_start:
+            continue
+        rgb = getattr(row, "itemRgb", None) if has_item_rgb else None
+        intervals.append((clipped_start, clipped_end, annotation_color(rgb, fallback)))
+    return intervals