multiqc-pivot 0.1.0__py3-none-any.whl

multiqc_pivot/config.py

@@ -0,0 +1,107 @@
+"""Settings for the `sample_pivot` block of a MultiQC configuration."""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import field_validator
+from pydantic import model_validator
+
+GROUP_CAPTURE = "group"
+"""The named capture the group pattern must define; its value names the folded row."""
+
+
+def _compile(pattern: str, where: str) -> re.Pattern[str]:
+    try:
+        return re.compile(pattern)
+    except re.error as exc:
+        raise ValueError(f"{where} is not a valid regular expression: {pattern!r} ({exc})") from exc
+
+
+class Level(BaseModel):
+    """
+    One kind of sample name and what happens to the rows that carry it.
+
+    A level with neither `label` nor `table` folds its columns onto the group row as they are. A
+    level with a `label` renames its columns after the label, folds them onto the group row and
+    keeps the original row underneath. A level with a `table` moves its rows out of General
+    Statistics into a table of that name, keeping whatever grouping they already had.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
+
+    match: str
+    label: str | None = None
+    table: str | None = None
+
+    @field_validator("match")
+    @classmethod
+    def _match_compiles(cls, value: str) -> str:
+        return _compile(value, "match").pattern
+
+    @model_validator(mode="after")
+    def _label_or_table(self) -> Level:
+        if self.label is not None and self.table is not None:
+            raise ValueError("a level may set label or table, not both")
+        if self.label is not None:
+            captures = dict.fromkeys(self.pattern.groupindex, "")
+            try:
+                _ = self.label.format(**captures)
+            except (KeyError, IndexError) as exc:
+                message = f"label {self.label!r} uses a capture that match {self.match!r} lacks"
+                raise ValueError(f"{message} ({exc})") from exc
+        return self
+
+    @property
+    def pattern(self) -> re.Pattern[str]:
+        """The compiled `match` expression."""
+        return re.compile(self.match)
+
+
+class TableSettings(BaseModel):
+    """How a table that receives rows moved out of General Statistics presents itself."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
+
+    description: str = ""
+
+
+class SamplePivotConfig(BaseModel):
+    """The `sample_pivot` block of a MultiQC configuration."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
+
+    group: str
+    levels: list[Level] = Field(min_length=1)
+    column_title: str = "{Label} {title}"
+    label_order: list[str] = Field(default_factory=list)
+    tables: dict[str, TableSettings] = Field(default_factory=dict)
+
+    @field_validator("group")
+    @classmethod
+    def _group_has_capture(cls, value: str) -> str:
+        if GROUP_CAPTURE not in _compile(value, "group").groupindex:
+            raise ValueError(
+                f"group must contain a named capture (?P<{GROUP_CAPTURE}>...): {value!r}"
+            )
+        return value
+
+    @field_validator("column_title")
+    @classmethod
+    def _column_title_placeholders(cls, value: str) -> str:
+        try:
+            _ = value.format(label="", Label="", title="")
+        except (KeyError, IndexError) as exc:
+            raise ValueError(
+                f"column_title may only use {{label}}, {{Label}} and {{title}}: {value!r} ({exc})"
+            ) from exc
+        return value
+
+    @property
+    def group_pattern(self) -> re.Pattern[str]:
+        """The compiled `group` expression."""
+        return re.compile(self.group)

multiqc_pivot/pivot.py

@@ -0,0 +1,245 @@
+"""Fold related General Statistics rows into one row per group."""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from dataclasses import field
+
+from multiqc.plots.table_object import ColumnDict
+from multiqc.plots.table_object import ColumnKeyT
+from multiqc.plots.table_object import ExtValueT
+from multiqc.plots.table_object import InputRow
+from multiqc.types import ColumnKey
+from multiqc.types import SampleGroup
+from multiqc.types import SampleName
+from multiqc.types import SectionKey
+
+from multiqc_pivot.config import SamplePivotConfig
+
+log = logging.getLogger("multiqc")
+
+RowData = dict[ColumnKeyT, ExtValueT | None]
+SectionRows = dict[SampleGroup, list[InputRow]]
+SectionHeaders = dict[ColumnKey, ColumnDict]
+Rows = dict[SectionKey, SectionRows]
+Headers = dict[SectionKey, SectionHeaders]
+
+PLACEMENT_BLOCK = 10_000
+"""Pivoted columns for the n-th label are placed at n times this value plus a running index.
+
+MultiQC orders General Statistics columns by their placement (1000 unless a module says otherwise),
+so every label forms one contiguous block after all of the columns that were not pivoted.
+"""
+
+
+@dataclass
+class Table:
+    """Rows moved out of General Statistics, keyed the same way General Statistics is."""
+
+    rows: Rows = field(default_factory=dict)
+    headers: Headers = field(default_factory=dict)
+
+    def add(
+        self, section: SectionKey, group: SampleGroup, row: InputRow, headers: SectionHeaders
+    ) -> None:
+        """Move a row in, keeping its section and group."""
+        self.rows.setdefault(section, {}).setdefault(group, []).append(row)
+        if section not in self.headers:
+            self.headers[section] = dict(headers)
+
+
+@dataclass
+class PivotResult:
+    """What General Statistics becomes, plus any tables split off from it."""
+
+    rows: Rows
+    headers: Headers
+    tables: dict[str, Table]
+
+
+@dataclass(frozen=True)
+class Moved:
+    """The row belongs in a secondary table."""
+
+    table: str
+
+
+@dataclass(frozen=True)
+class Folded:
+    """The row belongs on a group's row, under a label unless it is the group's own row."""
+
+    group: str
+    label: str | None = None
+
+
+Route = Moved | Folded
+
+
+def classify(name: str, settings: SamplePivotConfig) -> Route | None:
+    """
+    Decide where a sample's row goes from the first level that matches its name.
+
+    Returns None when no level matches, or when a level matches but the group pattern does not; the
+    latter is logged, since it usually means the group pattern is too narrow.
+    """
+    for level in settings.levels:
+        match = level.pattern.search(name)
+        if match is None:
+            continue
+        if level.table is not None:
+            return Moved(level.table)
+        group = settings.group_pattern.search(name)
+        if group is None:
+            log.warning(
+                f"sample_pivot: {name!r} matches {level.match!r} but not the group; left as is"
+            )
+            return None
+        label = level.label.format(**match.groupdict()) if level.label is not None else None
+        return Folded(group.group("group"), label)
+    return None
+
+
+def slug(text: str) -> str:
+    """Lower-case a label to letters, digits and single underscores."""
+    return re.sub(r"[^a-z0-9]+", "_", text.lower()).strip("_")
+
+
+def capitalise(text: str) -> str:
+    """Upper-case the first character only."""
+    return text[:1].upper() + text[1:]
+
+
+class Placement:
+    """
+    Hands out column placements that cluster pivoted columns by label.
+
+    Labels follow the configured order; labels missing from it come afterwards in order of first
+    appearance.
+    """
+
+    def __init__(self, order: list[str]) -> None:
+        """Start from the configured label order."""
+        self._order: list[str] = list(order)
+        self._count: int = 0
+
+    def next(self, label: str) -> float:
+        """The placement for the next pivoted column of a label."""
+        if label not in self._order:
+            self._order.append(label)
+        self._count += 1
+        return float(PLACEMENT_BLOCK * (self._order.index(label) + 1) + self._count)
+
+
+def pivoted_header(
+    header: ColumnDict,
+    key: ColumnKey,
+    label: str,
+    settings: SamplePivotConfig,
+    placement: Placement,
+) -> ColumnDict:
+    """Copy a column header under a labelled title and a placement inside the label's block."""
+    copy = header.copy()
+    copy["title"] = settings.column_title.format(
+        label=label, Label=capitalise(label), title=header.get("title", key)
+    )
+    copy["placement"] = placement.next(label)
+    return copy
+
+
+@dataclass
+class SectionPivot:
+    """Rebuilds one General Statistics section a row at a time."""
+
+    headers: SectionHeaders
+    settings: SamplePivotConfig
+    placement: Placement
+    new_headers: SectionHeaders = field(init=False)
+    _kept: SectionRows = field(default_factory=dict)
+    _group_rows: dict[str, RowData] = field(default_factory=dict)
+    _sub_rows: dict[str, list[InputRow]] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Start from the module's own headers; pivoted columns are added alongside them."""
+        self.new_headers = dict(self.headers)
+
+    def keep(self, group: SampleGroup, row: InputRow) -> None:
+        """Leave a row where it was."""
+        self._kept.setdefault(group, []).append(row)
+
+    def fold(self, group: str, row: InputRow) -> None:
+        """Put a row's declared columns onto the group row as they are; the row itself goes away."""
+        target = self._group_rows.setdefault(group, {})
+        for key, value in row.data.items():
+            if key in self.headers:
+                _fold(target, key, value, group)
+
+    def fold_labelled(self, group: str, label: str, row: InputRow) -> None:
+        """
+        Rename a row's declared columns after the label and put them onto the group row.
+
+        The row itself stays beneath the group row, carrying the same renamed columns.
+        """
+        target = self._group_rows.setdefault(group, {})
+        renamed: RowData = {}
+        for key, value in row.data.items():
+            if key not in self.headers:
+                continue
+            new_key = ColumnKey(f"{key}__{slug(label)}")
+            if new_key not in self.new_headers:
+                self.new_headers[new_key] = pivoted_header(
+                    self.headers[key], key, label, self.settings, self.placement
+                )
+            renamed[new_key] = value
+            _fold(target, new_key, value, group)
+        self._sub_rows.setdefault(group, []).append(InputRow(sample=row.sample, data=renamed))
+
+    def finish(self) -> SectionRows:
+        """The rebuilt rows, each group row first with its folded rows beneath."""
+        for name in dict.fromkeys([*self._group_rows, *self._sub_rows]):
+            group = SampleGroup(name)
+            first = InputRow(sample=SampleName(name), data=self._group_rows.get(name, {}))
+            self._kept[group] = [first, *self._sub_rows.get(name, []), *self._kept.get(group, [])]
+        return self._kept
+
+
+def pivot(rows: Rows, headers: Headers, settings: SamplePivotConfig) -> PivotResult:
+    """
+    Rebuild General Statistics with one row per group.
+
+    Rows that match a labelled level have their declared columns renamed after the label and copied
+    onto the group's row; the original rows stay beneath it so the group can still be expanded.
+    Rows that match an unlabelled level are folded onto the group's row as they are. Rows that match
+    a level with a table are moved into that table with their grouping intact. Rows that match no
+    level, and columns a module did not declare a header for, are left alone.
+    """
+    placement = Placement(settings.label_order)
+    out_rows: Rows = {}
+    out_headers: Headers = {}
+    tables: dict[str, Table] = {}
+    for section, rows_by_group in rows.items():
+        section_headers = headers.get(section, {})
+        pivoted = SectionPivot(section_headers, settings, placement)
+        for group, members in rows_by_group.items():
+            for row in members:
+                route = classify(str(row.sample), settings)
+                if route is None:
+                    pivoted.keep(group, row)
+                elif isinstance(route, Moved):
+                    table = tables.setdefault(route.table, Table())
+                    table.add(section, group, row, section_headers)
+                elif route.label is None:
+                    pivoted.fold(route.group, row)
+                else:
+                    pivoted.fold_labelled(route.group, route.label, row)
+        out_rows[section] = pivoted.finish()
+        out_headers[section] = pivoted.new_headers
+    return PivotResult(out_rows, out_headers, tables)
+
+
+def _fold(target: RowData, key: ColumnKeyT, value: ExtValueT | None, group: str) -> None:
+    if key in target and target[key] != value:
+        log.warning(f"sample_pivot: group '{group}' has two values for '{key}'; keeping the first")
+        return
+    target[key] = value

multiqc_pivot/plugin.py

@@ -0,0 +1,89 @@
+"""The functions MultiQC calls through the `multiqc.hooks.v1` entry points."""
+
+from __future__ import annotations
+
+import importlib.metadata
+import logging
+from typing import TYPE_CHECKING
+from typing import cast
+
+from multiqc_pivot.config import SamplePivotConfig
+from multiqc_pivot.config import TableSettings
+
+if TYPE_CHECKING:
+    from multiqc.base_module import BaseMultiqcModule
+
+    from multiqc_pivot.pivot import Table
+
+log = logging.getLogger("multiqc")
+
+PACKAGE = "multiqc-pivot"
+CONFIG_KEY = "sample_pivot"
+"""The top-level key of a MultiQC configuration that holds this plugin's settings."""
+
+
+def execution_start() -> None:
+    """Record the plugin version among the report's software versions."""
+    from multiqc import config
+
+    version = importlib.metadata.version(PACKAGE)
+    config.software_versions.setdefault(PACKAGE, {})[PACKAGE] = [version]
+    log.info(f"Loaded {PACKAGE} {version}")
+
+
+def after_modules() -> None:
+    """Regroup General Statistics as the `sample_pivot` block asks, if the configuration has one."""
+    from multiqc import config
+    from multiqc import report
+
+    from multiqc_pivot.pivot import pivot
+
+    raw = getattr(config, CONFIG_KEY, None)
+    if not raw:
+        return
+    settings = SamplePivotConfig.model_validate(raw)
+    result = pivot(report.general_stats_data, report.general_stats_headers, settings)
+    report.general_stats_data.clear()
+    report.general_stats_data.update(result.rows)
+    report.general_stats_headers.clear()
+    report.general_stats_headers.update(result.headers)
+    for name in reversed(list(result.tables)):
+        module = table_module(name, settings.tables.get(name, TableSettings()), result.tables[name])
+        if module is not None:
+            report.modules.insert(0, module)
+    groups = {group for section in result.rows.values() for group in section}
+    tables = f" and {len(result.tables)} extra table(s)" if result.tables else ""
+    log.info(f"sample_pivot: General Statistics now has {len(groups)} rows{tables}")
+
+
+def table_module(name: str, settings: TableSettings, table: Table) -> BaseMultiqcModule | None:
+    """
+    Wrap rows moved out of General Statistics in a module holding a single table section.
+
+    The module carries the name and description so the report shows them once; the section itself
+    is untitled. Returns None when the table would be empty.
+    """
+    from multiqc.base_module import BaseMultiqcModule
+    from multiqc.plots import table as table_plot
+    from multiqc.plots.table_object import SectionT
+    from multiqc.types import Anchor
+    from multiqc.types import SectionKey
+
+    from multiqc_pivot.pivot import slug
+
+    anchor = slug(name)
+    plot = table_plot.plot_with_sections(
+        data=cast(dict[SectionKey, SectionT], table.rows),
+        headers=table.headers,
+        pconfig={
+            "id": f"{anchor}_table",
+            "title": name,
+            "save_file": True,
+            "raw_data_fn": f"multiqc_{anchor}",
+        },
+    )
+    if plot is None:
+        return None
+    module = BaseMultiqcModule(name=name, anchor=Anchor(anchor), info=settings.description)
+    module.add_section(anchor=Anchor(f"{anchor}_section"), plot=plot)
+    return module

multiqc_pivot-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.5
+Name: multiqc-pivot
+Version: 0.1.0
+Summary: A MultiQC plugin that folds related samples into one General Statistics row per group with labelled metric columns.
+Project-URL: homepage, https://github.com/clintval/multiqc-pivot
+Project-URL: repository, https://github.com/clintval/multiqc-pivot
+Project-URL: Bug Tracker, https://github.com/clintval/multiqc-pivot/issues
+Author-email: Clint Valentine <valentine.clint@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: multiqc<2,>=1.35
+Requires-Dist: pydantic>=2
+Description-Content-Type: text/markdown
+
+# multiqc-pivot
+
+[![CI](https://github.com/clintval/multiqc-pivot/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/clintval/multiqc-pivot/actions/workflows/tests.yml?query=branch%3Amain)
+[![Python Versions](https://img.shields.io/badge/python-3.10_|_3.11_|_3.12_|_3.13-blue)](https://github.com/clintval/multiqc-pivot)
+[![basedpyright](https://img.shields.io/badge/basedpyright-checked-42b983)](https://docs.basedpyright.com/latest/)
+[![mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)
+
+A [MultiQC](https://multiqc.info) plugin that folds related samples into one General Statistics row per group.
+
+## Installation
+
+```console
+pip install multiqc-pivot
+```
+## Introduction
+
+MultiQC gives every sample its own row.
+When one subject yields several samples that are measured by different methods, say a tumour and a normal, or two tissues and a paired-genotype check, the General Statistics table ends up with a block of half-empty rows per subject.
+MultiQC's own [sample grouping](https://docs.seqera.io/multiqc/reports/customisation#sample-grouping) only fills the group's row for the handful of modules that know how to merge their metrics.
+
+This plugin runs after every module has reported and rebuilds the table:
+
+1. Rows for one group fold into a single row, and every folded column is prefixed by which method it came from.
+2. The original rows stay beneath the group row, so they still can be viewed.
+3. Rows for a level that does not belong in the table, such as per-library read QC, move out into their own table under General Statistics with whatever grouping they already had.
+4. Hover text, color scales, formats and hidden-by-default state carry over from the module that produced each column.
+
+## Example
+
+The report below comes from the [test fixtures](tests/data/report) and the [configuration](tests/data/multiqc_config.yml) shown in the usage section:
+
+![General Statistics with one row per subject and a Library statistics table beneath it](docs/pivot.png)
+
+```yaml
+sample_pivot:
+  group: '^(?P<group>[^. ]+)\.'
+  levels:
+    - match: '\.subject$'
+    - match: '\.(?P<analyte>tissueA|tissueB)$'
+      label: '{analyte}'
+    - match: '\.(?P<analyte>tissueA|tissueB) \(filtered\)$'
+      label: '{analyte} (filtered)'
+    - match: '\.library\.'
+      table: Library statistics
+  label_order: [tissueA, tissueB, tissueB (filtered)]
+  tables:
+    Library statistics:
+      description: Per-library read QC.
+```
+
+## Usage
+
+Add a `sample_pivot` block to any MultiQC config, for example with `--config my_config.yml`.
+
+So, with these sample names:
+
+```text
+101.subject
+101.tissueA
+101.tissueB
+101.tissueB (filtered data, though)
+101.tissueA.library.L1
+101.tissueA.library.L2
+```
+
+This configuration produces one row named `101` carrying `Concordance`, `TissueA Median`, `TissueB Median`, `TissueB (filtered) % Aligned` and so on, and moves the library rows into a separate table:
+
+```yaml
+sample_pivot:
+  group: '^(?P<group>[^. ]+)\.'
+  levels:
+    - match: '\.subject$'
+    - match: '\.(?P<analyte>tissueA|tissueB)$'
+      label: '{analyte}'
+    - match: '\.(?P<analyte>tissueA|tissueB) \(filtered\)$'
+      label: '{analyte} (filtered)'
+    - match: '\.library\.'
+      table: Library statistics
+  label_order: [tissueA, tissueB, tissueB (filtered)]
+  tables:
+    Library statistics:
+      description: Per-library read QC; read pairs nest under their library.
+```
+
+### YAML Configuration Reference
+
+| Key | Meaning |
+| --- | --- |
+| `group` | A regular expression searched in every matched sample name. Its `(?P<group>...)` capture names the folded row. Required. |
+| `levels` | An ordered list; the first level whose `match` is found in a sample name wins. Required. |
+| `levels[].match` | A regular expression searched in the sample name. Named captures are available to `label`. |
+| `levels[].label` | A format string built from the captures of `match`. Columns of matching rows are renamed with it and folded onto the group row; the row itself stays beneath. Omit it, and omit `table`, to fold the row's columns onto the group row unchanged. |
+| `levels[].table` | The name of a table that receives matching rows instead of General Statistics. Rows keep their grouping, so paired reads stay nested under their library. |
+| `column_title` | How a pivoted column is titled. `{label}` is the label as written, `{Label}` has its first letter upper-cased, `{title}` is the module's title. Default `{Label} {title}`. |
+| `label_order` | Labels in the order their column blocks should appear. Labels not listed follow in order of first appearance. |
+| `tables` | Presentation of the tables named by `levels[].table`, currently a `description` each. |
+
+> [!TIP]
+> A sample that matches no level is left where it was. 
+> A sample that matches a level but not `group` is left alone as well, with a warning in the log.
+> Columns that a module did not declare a header for are dropped from folded rows, as MultiQC would have dropped them anyway.
+
+### Limitations
+
+1. Sample names are matched after MultiQC has cleaned them, so you must write patterns against the names you see in an un-pivoted report.
+2. Only one level of nesting exists in a MultiQC table. Rows moved into a secondary table keep the nesting they already had; rows folded into a group row become its children, and cannot nest further.
+3. Two rows in the same group that resolve to the same label collide. The first value is kept and a warning is logged, so make labels specific enough to tell such rows apart.
+
+## Development and Testing
+
+See the [contributing guide](./CONTRIBUTING.md) for more information.

multiqc_pivot-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+multiqc_pivot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multiqc_pivot/config.py,sha256=WmUrKIAoyIQ1Nub0IwhgzXQMo26AT7dl9f5GQlfXrS4,3680
+multiqc_pivot/pivot.py,sha256=87Ra1rr-6PBJ3iM2TE0ILB-gtO8smSaXbvLAZeMRzvk,9029
+multiqc_pivot/plugin.py,sha256=m21v8ERzw-LCOsJnUruPpNYEVByBnEDjDpFWi7kLCMs,3215
+multiqc_pivot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multiqc_pivot-0.1.0.dist-info/METADATA,sha256=Uj_ktuQ5M1BV_LxyDXpuD2ZtyDNrxtpmZnV8YhIqyhU,7130
+multiqc_pivot-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+multiqc_pivot-0.1.0.dist-info/entry_points.txt,sha256=RmzBZvimOvwqgzyH3Mo3Lv0Fpcoyrx3tFBi3PqGP1yg,125
+multiqc_pivot-0.1.0.dist-info/licenses/LICENSE,sha256=s5pKbH2BYYoyLu52QqVnqHytR4BVo3F_TOFbJQcRbzI,1071
+multiqc_pivot-0.1.0.dist-info/RECORD,,

multiqc_pivot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

multiqc_pivot-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[multiqc.hooks.v1]
+after_modules = multiqc_pivot.plugin:after_modules
+execution_start = multiqc_pivot.plugin:execution_start

multiqc_pivot-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2026 Clint Valentine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.