[lock]

doc/.gitignore

@@ -0,0 +1,5 @@
+/.quarto/
+**/*.quarto_ipynb
+api/
+objects.json
+_site/

doc/_quarto.yml

@@ -0,0 +1,63 @@
+# In doc/_quarto.yml
+project:
+  type: website
+  output-dir: _site
+  preview:
+    port: 7000
+
+format:
+  html:
+    # code-fold: true
+    # code-summary: "Show the code"
+    theme: 
+      light: flatly
+      dark: darkly
+    css:
+      - api/_styles-quartodoc.css
+      - styles.css
+    fontsize: 1.1em
+    linestretch: 1.7
+    grid:
+      sidebar-width: 300px
+      body-width: 900px
+      margin-width: 300px
+      gutter-width: 1.5rem
+
+website:
+  title: oepyhs2nix
+  sidebar:
+    title: oepyhs2nix
+    style: "docked"
+    search: true
+    type: "dark"
+    tools:
+      - icon: github
+        href: https://whale.am28.uni-tuebingen.de/git/awendt/oephys2nix
+    contents:
+      - text: "Introduction"
+        href: "index.qmd"
+      - section: "Tutorials"
+        contents:
+        - "usage.qmd"
+      - section: "API"
+        href: "api/index.qmd"
+        contents:
+        - "api/index.qmd"
+
+
+quartodoc:
+  package: oephys2nix
+  dir: "api"
+  css: api/_styles-quartodoc.css
+  renderer:
+    style: markdown
+    table_style: description-list
+  sections:
+    - title: cli
+      desc: Terminal client
+      contents:
+        - main
+
+execute:
+  freeze: auto
+

doc/index.qmd

@@ -0,0 +1,60 @@
+---
+title: Terminal helper for converting open-ephys and relacs to one nix file.
+format:
+  html:
+    toc: true
+    css: styles.css
+    toc-title: Contents
+    code-block-bg: true
+    code-block-border-left: "#31BAE9"
+    code-line-numbers: true
+    highlight-style: atom-one
+    link-external-icon: true
+    link-external-newwindow: true
+    eqn-number: true
+---
+
+### 1. General idea
+
+`oepyhs2nix` is a little comand line interface (CLI) for helping converting
+open-ephys recordings and relacs to one nix file. The task is simple at first
+glance, but what isn't. We have two files and one open-ephys recording file and
+a relacs recording and I want to combine them, so I have both neuronal
+recordings and stimuli in one file.
+
+### 2. Installation
+Here my general workflow for installing the package.
+
+```bash
+git clone https://whale.am28.uni-tuebingen.de/git/awendt/oephys2nix
+cd oephys2nix
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+To see the documentation you need to install [quarto](https://quarto.org).
+Please follow the installation instructions for quarto, and install the extra
+dependencies.
+
+```bash
+pip install "[.doc]"
+cd doc
+quartodoc build
+quarto preview
+```
+which should open the documentation at localhost:7000.
+
+### 3. Setup
+![setup](assets/setup.png)
+The recorded data gets transfered to relacs and open-ephys were we have
+different sampling rates. If you start a stimulus a TTL pulse is send from
+relacs to the open-ephys recording controler.
+
+:::{.callout-caution}
+The Folder strucutre should be like two folders with one from relacs and one from open-ephys.
+```bash
+relax_folder/
+open-ephys_folder/
+```
+:::

doc/usage.qmd

@@ -0,0 +1,3 @@
+---
+title: How to use it
+---

oephys2nix/main.py

@@ -7,6 +7,8 @@ from IPython import embed
 from rich.console import Console
 
 from oephys2nix.logging import setup_logging
+from oephys2nix.stimulus_recreation import StimulusToNix
+from oephys2nix.tonix import RawToNix
 
 app = typer.Typer()
 log = logging.getLogger(__name__)
@@ -25,30 +27,25 @@ def main(
         readable=True,
         resolve_path=True,
     ),
-    ttl: bool = typer.Option(
-        default=True, help="For recordings that did not have a ttl pulse"
-    ),
+    ttl: bool = typer.Option(default=True, help="For recordings that did not have a ttl pulse"),
     overwrite: bool = typer.Option(default=True, help="Overwrites nix file"),
-):
-    """
-    Combines open ephys data with relacs data from data_path to a new nix file
-    """
-
+    debug: bool = typer.Option(default=True, help="Shows more information and plots the results"),
+) -> None:
+    """Combines open ephys data with relacs data from data_path to a new nix file."""
     log.info(f"Selected data_path is {data_path}")
     open_ephys_data_paths = list(Path(data_path).rglob("*open-ephys"))
-    relacs_data_paths = list(Path(data_path).rglob("*relacs"))
+    relacs_data_paths = list(Path(data_path).rglob("*relacs/*.nix"))
 
-    if not len(open_ephys_data_paths) == len(relacs_data_paths):
+    if len(open_ephys_data_paths) != len(relacs_data_paths):
         log.error(
-            f"Missmatch in data directory found open-ephys data {len(open_ephys_data_paths)} and relacs data {len(relacs_data_paths)}"
+            f"Missmatch in data directory found open-ephys data {len(open_ephys_data_paths)} "
+            f"and relacs data {len(relacs_data_paths)}"
         )
         log.error("Please check if both are present")
         raise typer.Exit()
 
-    for open_ephys, relacs in zip(
-        open_ephys_data_paths, relacs_data_paths, strict=True
-    ):
-        nix_file_name = relacs.name.split("_")[0] + "-recording.nix"
+    for open_ephys, relacs in zip(open_ephys_data_paths, relacs_data_paths, strict=True):
+        nix_file_name = relacs.parent.name.split("_")[0] + "-recording.nix"
 
         console.print(
             f"Converting [bold cyan]{open_ephys.name}[/bold cyan] and "
@@ -56,20 +53,38 @@ def main(
             f"[green]{nix_file_name}[/green]"
         )
 
-        nix_path = relacs.parent / nix_file_name
+        nix_path = relacs.parent.parent / nix_file_name
 
         if nix_path.exists and nix_path.is_file():
             if overwrite:
                 log.warning("Overwriting nix file")
-                nix_files = nixio.File(str(nix_file_name), nixio.FileMode.Overwrite)
+                nix_file = nixio.File(str(nix_path), nixio.FileMode.Overwrite)
             else:
-                log.error(
-                    "Converted nix file already exits, and Overwrite is not enabled"
-                )
+                log.error("Converted nix file already exits, and Overwrite is not enabled")
                 raise typer.Exit()
         else:
             log.debug("Creating nix file")
-            nix_files = nixio.File(str(nix_file_name), nixio.FileMode.Overwrite)
+            nix_file = nixio.File(str(nix_path), nixio.FileMode.Overwrite)
+
+        nix_file.close()
+
+        log.info("Appending raw data from relacs and open-ephys to new nix-file")
+        to_nix = RawToNix(open_ephys, str(relacs), str(nix_path))
+        to_nix.append_section()
+        to_nix.append_fish_lines()
+        to_nix.append_relacs_lines()
+        to_nix.append_raw_data()
+        to_nix.close()
+        log.info("Finished!")
+
+        log.info("Starting with stimulus recreation")
+        stim = StimulusToNix(open_ephys, str(relacs), str(nix_path))
+        stim.create_repros_automatically()
+        stim.print_table()
+        stim.checks()
+
+        if debug:
+            stim.plot_stimulus()
 
 
 if __name__ == "__main__":

oephys2nix/stimulus_recreation.py

@@ -0,0 +1,522 @@
+import logging
+import pathlib
+import sys
+import tomllib
+
+import matplotlib.pyplot as plt
+import nixio
+import numpy as np
+import rlxnix as rlx
+from IPython import embed
+from neo.io import OpenEphysBinaryIO
+from nixio.exceptions import DuplicateName
+from rich.console import Console
+from rich.table import Table
+from rlxnix.plugins.efish.utils import extract_am
+from scipy import signal
+
+from oephys2nix.logging import setup_logging
+from oephys2nix.metadata import create_dict_from_section, create_metadata_from_dict
+
+log = logging.getLogger(__name__)
+setup_logging(log, level="DEBUG")
+console = Console()
+
+
+class StimulusToNix:
+    def __init__(self, open_ephys_path: pathlib.Path, relacs_nix_path: str, nix_file: str):
+        self.dataset = rlx.Dataset(relacs_nix_path)
+
+        self.relacs_nix_file = nixio.File.open(relacs_nix_path, nixio.FileMode.ReadOnly)
+        self.relacs_block = self.relacs_nix_file.blocks[0]
+        self.relacs_sections = self.relacs_nix_file.sections
+
+        self.neo_data = OpenEphysBinaryIO(open_ephys_path).read(lazy=True)
+        self.fs = self.neo_data[0].segments[0].analogsignals[0].sampling_rate.magnitude
+
+        self.nix_file_path = nix_file
+        self.nix_file = nixio.File(nix_file, nixio.FileMode.ReadWrite)
+        self.block = self.nix_file.blocks[0]
+
+        # Threshold for TTL peak
+        # constants
+        self.threshold = 2
+        self.new_start_jiggle = 0.1
+
+    def _append_relacs_tag_mtags(self):
+        for t in self.relacs_block.tags:
+            log.debug(f"Appending relacs tags {t.name}")
+            tag = self.block.create_tag(f"relacs_{t.name}", t.type, position=t.position)
+            tag.extent = t.extent
+            tag.references.extend(self.block.groups["relacs"].data_arrays)
+
+            sec = self.relacs_sections[f"{t.name}"]
+            d = create_dict_from_section(sec)
+
+            try:
+                new_sec = self.nix_file.create_section(sec.name, sec.type)
+                create_metadata_from_dict(d, new_sec)
+            except DuplicateName:
+                pass
+
+            tag.metadata = self.nix_file.sections[sec.name]
+
+        for t in self.relacs_block.multi_tags:
+            log.debug(f"Appending relacs multi-tags {t.name}")
+            mtag = self.block.create_multi_tag(
+                f"relacs_{t.name}",
+                t.type,
+                positions=t.positions[:],
+                extents=t.extents[:],
+            )
+            mtag.references.extend(self.block.groups["relacs"].data_arrays)
+
+            sec = self.relacs_sections[f"{t.name}"]
+            d = create_dict_from_section(sec)
+            try:
+                new_sec = self.nix_file.create_section(sec.name, sec.type)
+                create_metadata_from_dict(d, new_sec)
+            except DuplicateName:
+                pass
+            mtag.metadata = self.nix_file.sections[sec.name]
+
+    def _find_peak_ttl(self, time_ttl, peaks_ttl, lower, upper):
+        peak = time_ttl[peaks_ttl[(time_ttl[peaks_ttl] > lower) & (time_ttl[peaks_ttl] < upper)]]
+
+        if not peak.size > 0:
+            log.error("No peaks found")
+        elif peak.size > 1:
+            if np.all(np.diff(peak) > 0.5):
+                log.error("Peaks are further aways than 0.5 seconds")
+                log.error(f"Peaks {peak}, Furthest aways: {np.max(peak)}")
+            peak = np.mean(peak)
+        return peak
+
+    def _find_peak_ttl_index(self, time_ttl, peaks_ttl, current_position):
+        new_repro_start_index = peaks_ttl[
+            (time_ttl[peaks_ttl] > current_position - self.new_start_jiggle)
+            & (time_ttl[peaks_ttl] < current_position + self.new_start_jiggle)
+        ]
+
+        if new_repro_start_index.size > 1:
+            log.warning("Multiple current positions taking the last index")
+            new_repro_start_index = new_repro_start_index[-1]
+
+        if np.where(new_repro_start_index == peaks_ttl)[0] + 1 == len(peaks_ttl):
+            return np.array([])
+        else:
+            next_repro_start = peaks_ttl[np.where(new_repro_start_index == peaks_ttl)[0] + 1]
+            start_next_repro = time_ttl[next_repro_start]
+            log.debug(f"Start of new repro/trial {start_next_repro}")
+            return start_next_repro
+
+    @property
+    def _reference_groups(self) -> list[nixio.Group]:
+        return [
+            self.block.groups["neuronal-data"],
+            self.block.groups["efish"],
+            self.block.groups["relacs"],
+        ]
+
+    def _append_mtag(self, repro, positions, extents):
+        try:
+            nix_mtag = self.block.create_multi_tag(
+                f"{repro.name}",
+                "relacs.stimulus",
+                positions=positions,
+                extents=extents,
+            )
+        except DuplicateName:
+            del self.block.multi_tags[repro.name]
+            nix_mtag = self.block.create_multi_tag(
+                f"{repro.name}",
+                "relacs.stimulus",
+                positions=positions,
+                extents=extents,
+            )
+        sec = self.relacs_sections[f"{repro.name}"]
+        d = create_dict_from_section(sec)
+
+        try:
+            new_sec = self.nix_file.create_section(sec.name, sec.type)
+            create_metadata_from_dict(d, new_sec)
+        except DuplicateName:
+            del self.nix_file.sections[sec.name]
+            new_sec = self.nix_file.create_section(sec.name, sec.type)
+            create_metadata_from_dict(d, new_sec)
+
+        nix_mtag.metadata = self.nix_file.sections[repro.name]
+
+        [
+            nix_mtag.references.extend(ref_groups.data_arrays)
+            for ref_groups in self._reference_groups
+            if ref_groups.data_arrays
+        ]
+
+        try:
+            nix_group = self.block.create_group(repro.name, repro.type)
+        except DuplicateName:
+            nix_group = self.nix_file.blocks[0].groups[repro.name]
+        nix_group.multi_tags.append(nix_mtag)
+
+    def _append_tag(self, repro, position, extent):
+        try:
+            nix_tag = self.block.create_tag(
+                f"{repro.name}",
+                "relacs.repro_run",
+                position=np.array(position).flatten(),
+            )
+            nix_tag.extent = extent.flatten()
+        except DuplicateName:
+            del self.block.tags[repro.name]
+            nix_tag = self.block.create_tag(
+                f"{repro.name}",
+                "relacs.repro_run",
+                position=np.array(position).flatten(),
+            )
+            nix_tag.extent = extent.flatten()
+
+        sec = self.relacs_sections[f"{repro.name}"]
+        d = create_dict_from_section(sec)
+
+        try:
+            new_sec = self.nix_file.create_section(sec.name, sec.type)
+            create_metadata_from_dict(d, new_sec)
+        except DuplicateName:
+            del self.nix_file.sections[sec.name]
+            new_sec = self.nix_file.create_section(sec.name, sec.type)
+            create_metadata_from_dict(d, new_sec)
+
+        nix_tag.metadata = self.nix_file.sections[repro.name]
+
+        # NOTE: adding refs to tag
+        [
+            nix_tag.references.extend(ref_groups.data_arrays)
+            for ref_groups in self._reference_groups
+            if ref_groups.data_arrays
+        ]
+        try:
+            nix_group = self.block.create_group(repro.name, repro.type)
+        except DuplicateName:
+            nix_group = self.nix_file.blocks[0].groups[repro.name]
+        nix_group.tags.append(nix_tag)
+
+    def create_repros_automatically(self):
+        ttl_oeph = self.block.data_arrays["ttl-line"][:]
+        time_ttl = np.arange(len(ttl_oeph)) / self.fs
+        time_index = np.arange(len(ttl_oeph))
+
+        peaks_ttl = time_index[
+            (np.roll(ttl_oeph, 1) < self.threshold) & (ttl_oeph > self.threshold)
+        ]
+        # WARNING:Check if peaks are duplicates or near each other
+        close_peaks = np.where(np.diff(peaks_ttl) == 1)[0]
+        if close_peaks.size > 0:
+            peaks_ttl = np.delete(peaks_ttl, close_peaks)
+
+        first_peak = self._find_peak_ttl(
+            time_ttl,
+            peaks_ttl,
+            time_ttl[peaks_ttl[0]] - self.new_start_jiggle,
+            time_ttl[peaks_ttl[0]] + self.new_start_jiggle,
+        )
+
+        current_position = np.asarray(first_peak.reshape(1))
+        for i, repro in enumerate(self.dataset.repro_runs()):
+            log.debug(repro.name)
+            log.debug(f"Current Position {current_position.item()}")
+            if repro.duration < 1.0:
+                log.warning(f"Skipping repro {repro.name} because it is two short")
+                continue
+
+            if repro.stimuli:
+                log.debug("Processing MultiTag")
+                repetition = len(repro.stimuli)
+                extents_mtag = np.zeros((repetition, 1))
+                position_mtags = np.zeros((repetition, 1))
+
+                for trial, stimulus in enumerate(repro.stimuli):
+                    duration_trial = stimulus.duration
+                    extents_mtag[trial] = duration_trial
+                    position_mtags[trial] = current_position
+
+                    current_position = self._find_peak_ttl_index(
+                        time_ttl, peaks_ttl, current_position
+                    )
+
+                # current_position = position_mtags[-1]
+                self._append_mtag(repro, position_mtags, extents_mtag)
+                extent = position_mtags[-1] + extents_mtag[-1] - position_mtags[0]
+                self._append_tag(repro, position_mtags[0], extent)
+
+                if not current_position.size > 0:
+                    log.debug("Checking if it is the last repro")
+                    if i != len(self.dataset.repro_runs()) - 1:
+                        if "Baseline" in self.dataset.repro_runs()[-1].name:
+                            log.debug("Appending last baseline Repro")
+                            last_position = (
+                                self.block.tags[repro.name].position[0]
+                                + self.block.tags[repro.name].extent[0]
+                            )
+                            lastrepro = self.dataset.repro_runs()[-1]
+                            self._append_tag(lastrepro, last_position, lastrepro.duration)
+                        else:
+                            log.error("Last Repro was not appended")
+                            break
+
+                    log.info("Finishing writing")
+                    log.info("Closing nix files")
+                    break
+            else:
+                if i == 0 and "BaselineActivity" in repro.name:
+                    self._append_tag(repro, 0.0, current_position)
+                    continue
+
+                last_repro_name = self.dataset.repro_runs()[i - 1].name
+                last_repro_position = (
+                    self.block.groups[last_repro_name].tags[0].position[0]
+                    + self.block.groups[last_repro_name].tags[0].extent[0]
+                )
+                self._append_tag(
+                    repro,
+                    last_repro_position.reshape(-1, 1),
+                    (current_position - last_repro_position).reshape(-1, 1),
+                )
+        # self.close()
+
+    def create_repros_from_config_file(self):
+        ttl_oeph = self.block.data_arrays["ttl-line"][:]
+        peaks_ttl = signal.find_peaks(
+            ttl_oeph.flatten(),
+            **self.stimulus_config["stimulus"]["peak_detection"],
+        )[0]
+        time_ttl = np.arange(len(ttl_oeph)) / self.cfg.open_ephys.samplerate
+
+        number_of_repros = len(self.stimulus_config["repros"]["name"])
+
+        referencs_groups = [
+            self.block.groups["neuronal-data"],
+            self.block.groups["spike-data"],
+            self.block.groups["efish"],
+        ]
+
+        for repro_index in range(number_of_repros):
+            name = self.stimulus_config["repros"]["name"][repro_index]
+            log.debug(name)
+            start = np.array(self.stimulus_config["repros"]["start"][repro_index])
+            end = np.array(self.stimulus_config["repros"]["end"][repro_index])
+            nix_group = self.block.groups[name]
+            if start.size > 1:
+                start_repro = time_ttl[
+                    peaks_ttl[(time_ttl[peaks_ttl] > start[0]) & (time_ttl[peaks_ttl] < start[1])]
+                ]
+                if start_repro.size > 1:
+                    if np.all(np.diff(start_repro) > 0.005):
+                        log.error("Wrong end point in end of repro")
+                        log.error(f"{name[repro_index]}, {np.max(start_repro)}")
+                        exit(1)
+                    start_repro = np.mean(start_repro)
+                else:
+                    start_repro = start_repro[0]
+            else:
+                start_repro = start[0]
+
+            if end.size > 1:
+                end_repro = time_ttl[
+                    peaks_ttl[(time_ttl[peaks_ttl] > end[0]) & (time_ttl[peaks_ttl] < end[1])]
+                ]
+                if end_repro.size > 1:
+                    if np.all(np.diff(end_repro) > 0.005):
+                        log.error("Wrong end point in end of repro")
+                        log.error(f"{name[repro_index]}, {np.max(end_repro)}")
+                        exit(1)
+                    end_repro = np.mean(end_repro)
+            else:
+                end_repro = end[0]
+
+            nix_tag = self.block.create_tag(
+                f"{nix_group.name}",
+                f"{nix_group.type}",
+                position=[start_repro],
+            )
+            nix_tag.extent = [end_repro - start_repro]
+            nix_tag.metadata = self.nix_file.sections[name]
+
+            # NOTE: adding refs to tag
+            [
+                nix_tag.references.extend(ref_groups.data_arrays)
+                for ref_groups in referencs_groups
+                if ref_groups.data_arrays
+            ]
+            nix_group.tags.append(nix_tag)
+
+            if not self.relacs_block.groups[name].multi_tags:
+                log.debug(f"no multitags in repro {name}, skipping")
+                continue
+
+            start_repro_multi_tag = start_repro.copy()
+            positions = []
+            positions.append(np.array(start_repro))
+            extents = []
+            extents_relacsed_nix = self.relacs_block.groups[name].multi_tags[0].extents[:]
+            extents.append(np.array(extents_relacsed_nix[0]))
+            index_multi_tag = 0
+            while start_repro_multi_tag < end_repro:
+                log.debug(f"{start_repro_multi_tag}")
+
+                start_repro_multi_tag = time_ttl[
+                    peaks_ttl[
+                        (
+                            time_ttl[peaks_ttl]
+                            > start_repro_multi_tag + extents_relacsed_nix[index_multi_tag]
+                        )
+                        & (
+                            time_ttl[peaks_ttl]
+                            < start_repro_multi_tag + extents_relacsed_nix[index_multi_tag] + 2
+                        )
+                    ]
+                ]
+
+                if start_repro_multi_tag.size == 0:
+                    log.debug("Did not find any peaks for new start multi tag")
+                    log.debug(
+                        f"Differenz to end of repro {end_repro - (positions[-1] + extents_relacsed_nix[index_multi_tag])}"
+                    )
+                    break
+
+                if start_repro_multi_tag.size > 1:
+                    if np.all(np.diff(start_repro_multi_tag) > 0.005):
+                        log.error("Wrong end point in end of repro")
+                        log.error(f"Repro_name: {name[repro_index]}")
+                        log.error(f"multitag_index: {index_multi_tag}")
+                        log.error(f"max_value {np.max(start_repro_multi_tag)}")
+                        sys.exit(1)
+                    start_repro_multi_tag = np.mean(start_repro_multi_tag)
+                else:
+                    start_repro_multi_tag = start_repro_multi_tag[0]
+                if end_repro - start_repro_multi_tag < 1:
+                    log.debug("Posssible endpoint detected")
+                    log.debug(f"Differenz to repro end: {end_repro - start_repro_multi_tag}")
+                    break
+
+                positions.append(np.array(start_repro_multi_tag))
+                extents.append(extents_relacsed_nix[index_multi_tag])
+
+            positions = np.array(positions).reshape(len(positions), 1)
+            extents = np.array(extents)
+            if positions.size != extents.size:
+                log.error("Calcualted positions and extents do not match ")
+                log.error(f"Shape positions {positions.shape}, shape extents {extents.shape}")
+            if positions.shape != extents.shape:
+                log.error("Shape of Calculated positions and extents do not match")
+                log.error(f"Shape positions {positions.shape}, shape extents {extents.shape}")
+                embed()
+                sys.exit(1)
+
+            nix_mtag = self.block.create_multi_tag(
+                f"{nix_group.name}",
+                f"{nix_group.type}",
+                positions=positions,
+                extents=extents,
+            )
+            nix_mtag.metadata = self.nix_file.sections[name]
+
+            # NOTE: adding refs to mtag
+            [
+                nix_mtag.references.extend(ref_groups.data_arrays)
+                for ref_groups in referencs_groups
+                if ref_groups.data_arrays
+            ]
+            nix_group.multi_tags.append(nix_mtag)
+
+    def print_table(self):
+        nix_data_set = rlx.Dataset(self.nix_file_path)
+        table = Table("Repro Name", "start", "stop", "duration")
+        for repro_r, repro_n in zip(self.dataset.repro_runs(), nix_data_set.repro_runs()):
+            table.add_row(
+                f"{repro_r.name} -> [red]{repro_n.name}[/red]",
+                f"{repro_r.start_time:.2f} -> [red]{repro_n.start_time:.2f}[/red]",
+                f"{repro_r.stop_time:.2f} -> [red]{repro_n.stop_time:.2f}[/red]",
+                f"{repro_r.duration:.2f} -> [red]{repro_n.duration:.2f}[/red]",
+            )
+
+        console.print(table)
+        nix_data_set.close()
+
+    def checks(self):
+        important_repros = ["FileStimulus", "SAM", "FICurve"]
+        nix_data_set = rlx.Dataset(self.nix_file_path)
+
+        for repro_r, repro_n in zip(self.dataset.repro_runs(), nix_data_set.repro_runs()):
+            if repro_n.name.split("_")[0] not in important_repros:
+                continue
+            if "SAM" in repro_n.name:
+                embed()
+                exit()
+            else:
+                continue
+
+            if "FileStimulus" in repro_n.name:
+                repro_n.stimulus_folder = "/home/alexander/stimuli/whitenoise/"
+                repro_r.stimulus_folder = "/home/alexander/stimuli/whitenoise/"
+                white_noise, stimulus_time = repro_n.load_stimulus(0, 30_000)
+                white_noise_r, stimulus_time_r = repro_n.load_stimulus(0, 20_000)
+
+            stim = repro_n.stimuli[0]
+            stim_r = repro_r.stimuli[0]
+            v, t = stim.trace_data("local-eod")
+            v_r, t_r = stim_r.trace_data("LocalEOD-1")
+            plt.plot(t_r, v_r, "o--", color="tab:blue", label="relacs")
+            plt.plot(t, v, "o--", color="tab:red", label="open-ephys")
+            # plt.plot(stimulus_time, white_noise, "o--", color="tab:orange", label="stimulus")
+            # plt.plot(new_t, new_v, "go--", label="resampled")
+            for i, (s, r) in enumerate(zip(repro_n.stimuli, repro_r.stimuli)):
+                v, t = s.trace_data("local-eod")
+                v_r, t_r = r.trace_data("LocalEOD-1")
+                plt.plot(t_r + (i * r.duration), v_r)
+                plt.plot(t + (i * s.duration), v)
+            plt.legend(loc="upper right")
+            plt.show()
+
+            am = extract_am(v, 30_000)
+            am_r = extract_am(v_r, 20_000)
+
+            plt.plot(t, am - np.mean(am) / np.max(np.abs(am)))
+            plt.plot(t_r, am_r - np.mean(am_r) / np.max(np.abs(am_r)))
+            v_eod, t_eod = repro_n.trace_data("global-eod")
+            v_eodr, t_eodr = repro_n.trace_data("EOD")
+
+    def plot_stimulus(self):
+        ttl_oeph = self.block.data_arrays["ttl-line"][:]
+
+        time_index = np.arange(len(ttl_oeph))
+        peaks_ttl = time_index[(np.roll(ttl_oeph, 1) < 2) & (ttl_oeph > 2)]
+
+        stimulus_oeph = self.block.data_arrays["stimulus"]
+        stimulus = self.relacs_block.data_arrays["GlobalEFieldStimulus"]
+
+        plt.plot(np.arange(stimulus.size) / 20_000.0, stimulus, label="relacs-stimulus")
+        plt.plot(
+            np.arange(len(stimulus_oeph)) / 30_000.0,
+            stimulus_oeph[:],
+            label="open-ephys",
+        )
+        plt.plot(
+            np.arange(len(ttl_oeph)) / 30_000.0,
+            ttl_oeph[:],
+            label="ttl-line",
+        )
+        plt.scatter(
+            np.arange(len(ttl_oeph))[peaks_ttl] / 30_000.0,
+            ttl_oeph[peaks_ttl],
+            label="detected peaks",
+            color="red",
+            zorder=100,
+        )
+        plt.legend(loc="upper right")
+        plt.show()
+
+    def close(self):
+        self.dataset.close()
+        self.nix_file.close()
+        self.relacs_nix_file.close()

oephys2nix/tonix.py

@@ -1,711 +1,138 @@
 import logging
 import pathlib
-import tomllib
 
-import matplotlib.pyplot as plt
 import nixio
 import numpy as np
 import rlxnix as rlx
 from IPython import embed
 from neo.io import OpenEphysBinaryIO
-from nixio.exceptions import DuplicateName
-from scipy import signal
+
+from oephys2nix.logging import setup_logging
+from oephys2nix.metadata import create_dict_from_section, create_metadata_from_dict
 
 log = logging.getLogger(__name__)
 setup_logging(log, level="DEBUG")
 
 
-class CreateNix:
-    def __init__(self, open_ephys_path, relacs_nix_path, nix_file):
+class RawToNix:
+    def __init__(self, open_ephys_path: pathlib.Path, relacs_nix_path: str, nix_file: str):
         self.relacs_nix_file = nixio.File.open(relacs_nix_path, nixio.FileMode.ReadOnly)
         self.dataset = rlx.Dataset(relacs_nix_path)
         self.relacs_block = self.relacs_nix_file.blocks[0]
         self.relacs_sections = self.relacs_nix_file.sections
-
-        self.spike_sorter_path = str(self.recording_path.resolve() / "spikesorter.nix")
-
         self.neo_data = OpenEphysBinaryIO(open_ephys_path).read(lazy=True)
 
-        self.nix_file = nix_file
+        self.nix_file = nixio.File(nix_file, nixio.FileMode.ReadWrite)
+        self.nix_file.create_block("open-ephys.data", "open-ephys.sampled")
         self.block = self.nix_file.blocks[0]
 
-    def _load_config(self):
-        config_path = self.recording_path / "stimulus_config.toml"
-        if not config_path.is_file():
-            log.debug("Stimulus config was not found")
-        with open(config_path, "rb") as config_file:
-            try:
-                config = tomllib.load(config_file)
-                config_file.close()
-                return config
-            except tomllib.TOMLDecodeError as e:
-                config_file.close()
-                raise tomllib.TOMLDecodeError(f"Error parsing TOML file: {e}")
-
-    def _append_relacs_tag_mtags(self):
-        for t in self.relacs_block.tags:
-            log.debug(f"Appending relacs tags {t.name}")
-            tag = self.block.create_tag(f"relacs_{t.name}", t.type, position=t.position)
-            tag.extent = t.extent
-            tag.references.extend(self.block.groups["relacs"].data_arrays)
-
-            sec = self.relacs_sections[f"{t.name}"]
-            d = create_dict_from_section(sec)
-
-            try:
-                new_sec = self.nix_file.create_section(sec.name, sec.type)
-                create_metadata_from_dict(d, new_sec)
-            except DuplicateName:
-                pass
-
-            tag.metadata = self.nix_file.sections[sec.name]
-
-        for t in self.relacs_block.multi_tags:
-            log.debug(f"Appending relacs multi-tags {t.name}")
-            mtag = self.block.create_multi_tag(
-                f"relacs_{t.name}",
-                t.type,
-                positions=t.positions[:],
-                extents=t.extents[:],
+    def append_section(self):
+        sec = self.nix_file.create_section(
+            self.relacs_sections[0].name, self.relacs_sections[0].type
         )
-            mtag.references.extend(self.block.groups["relacs"].data_arrays)
+        d = create_dict_from_section(self.relacs_sections[0])
+        create_metadata_from_dict(d, sec)
+        self.block.metadata = sec
 
-            sec = self.relacs_sections[f"{t.name}"]
-            d = create_dict_from_section(sec)
-            try:
-                new_sec = self.nix_file.create_section(sec.name, sec.type)
-                create_metadata_from_dict(d, new_sec)
-            except DuplicateName:
-                pass
-            mtag.metadata = self.nix_file.sections[sec.name]
-
-    def _find_peak_ttl(self, time_ttl, peaks_ttl, lower, upper):
-        peak = time_ttl[
-            peaks_ttl[(time_ttl[peaks_ttl] > lower) & (time_ttl[peaks_ttl] < upper)]
+    def append_fish_lines(self):
+        efishs = [
+            "ttl-line",
+            "global-eod",
+            "stimulus",
+            "local-eod",
         ]
 
-        if not peak.size > 0:
-            log.error("No peaks found")
-        elif peak.size > 1:
-            if np.all(np.diff(peak) > 0.5):
-                log.error("Peaks are further aways than 0.5 seconds")
-                log.error(f"Peaks {peak}, Furthest aways: {np.max(peak)}")
-            peak = np.mean(peak)
-        return peak
-
-    def _find_peak_ttl_index(self, time_ttl, peaks_ttl, current_position):
-        new_repro_start_index = peaks_ttl[
-            (time_ttl[peaks_ttl] > current_position - 0.1)
-            & (time_ttl[peaks_ttl] < current_position + 0.1)
+        efish_types = [
+            "open-ephys.data.sampled",
+            "open-ephys.data.sampled",
+            "open-ephys.data.sampled",
+            "open-ephys.data.sampled",
         ]
 
-        # if multiple take the last one
-        if new_repro_start_index.size > 1:
-            log.warning("Multiple current positions taking the last index")
-            new_repro_start_index = new_repro_start_index[-1]
+        efish_group = self.block.create_group("efish", "open-ephys.sampled")
 
-        # log.debug(f"Time current repro/trial {time_ttl[new_repro_start_index]}")
-        if np.where(new_repro_start_index == peaks_ttl)[0] + 1 == len(peaks_ttl):
-            return np.array([])
-        else:
-            next_repro_start = peaks_ttl[
-                np.where(new_repro_start_index == peaks_ttl)[0] + 1
-            ]
-            start_next_repro = time_ttl[next_repro_start]
-            log.debug(f"Start of new repro/trial {start_next_repro}")
-            return start_next_repro
+        efish_neo_data = self.neo_data[0].segments[0].analogsignals[1].load()
 
-    def _reference_groups(self) -> list[nixio.Group]:
-        return [
-            self.block.groups["neuronal-data"],
-            # self.block.groups["spike-data"],
-            self.block.groups["efish"],
-            self.block.groups["relacs"],
+        for i in np.arange(len(efishs)):
+            log.debug(f"Appending efish traces {efishs[i]}")
+            efish_neo_data_array = efish_neo_data[:, i]
+            data_array = self.block.create_data_array(
+                f"{efishs[i]}",
+                f"{efish_types[i]}",
+                data=efish_neo_data_array.magnitude.flatten(),
+                label="voltage",
+                unit="V",
+            )
+            data_array.append_sampled_dimension(
+                1 / efish_neo_data.sampling_rate.magnitude, label="time", unit="s"
+            )
+            efish_group.data_arrays.append(data_array)
+
+    def append_relacs_lines(self):
+        relacs = [
+            "V-1",
+            "EOD",
+            "LocalEOD-1",
+            "GlobalEFieldStimulus",
+            "Spikes-1",
+            "Chirps",
+            "LocalBeat-1-1",
         ]
 
-    def _append_mtag(self, repro, positions, extents):
-        try:
-            nix_mtag = self.block.create_multi_tag(
-                f"{repro.name}",
-                "relacs.stimulus",
-                positions=positions,
-                extents=extents,
-            )
-        except DuplicateName:
-            del self.block.multi_tags[repro.name]
-            nix_mtag = self.block.create_multi_tag(
-                f"{repro.name}",
-                "relacs.stimulus",
-                positions=positions,
-                extents=extents,
-            )
-        sec = self.relacs_sections[f"{repro.name}"]
-        d = create_dict_from_section(sec)
-
-        try:
-            new_sec = self.nix_file.create_section(sec.name, sec.type)
-            create_metadata_from_dict(d, new_sec)
-        except DuplicateName:
-            del self.nix_file.sections[sec.name]
-            new_sec = self.nix_file.create_section(sec.name, sec.type)
-            create_metadata_from_dict(d, new_sec)
-
-        nix_mtag.metadata = self.nix_file.sections[repro.name]
-
-        [
-            nix_mtag.references.extend(ref_groups.data_arrays)
-            for ref_groups in self._reference_groups
-            if ref_groups.data_arrays
+        relacs_types = [
+            "relacs.data.sampled.V-1",
+            "relacs.data.sampled.EOD",
+            "relacs.data.sampled.LocalEOD-1",
+            "relacs.data.sampled.GlobalEFieldStimulus",
+            "relacs.data.events.Spikes-1",
+            "relacs.data.events.Chirps",
+            "relacs.data.events.LocalBeat-1-1",
         ]
 
-        try:
-            nix_group = self.block.create_group(repro.name, repro.type)
-        except DuplicateName:
-            nix_group = self.nix_file.blocks[0].groups[repro.name]
-        nix_group.multi_tags.append(nix_mtag)
+        efish_group = self.block.create_group("relacs", "relacs.sampled")
 
-    def _append_tag(self, repro, position, extent):
-        try:
-            nix_tag = self.block.create_tag(
-                f"{repro.name}",
-                "relacs.repro_run",
-                position=np.array(position).flatten(),
+        for i, re in enumerate(relacs):
+            log.debug(f"Appending relacs efish traces {re}")
+            efish_relacs_data_array = self.relacs_block.data_arrays[re]
+            data_array = self.block.create_data_array(
+                f"{re}",
+                f"{relacs_types[i]}",
+                data=efish_relacs_data_array[:],
+                label=efish_relacs_data_array.label,
+                unit=efish_relacs_data_array.unit,
             )
-            nix_tag.extent = extent.flatten()
-        except DuplicateName:
-            del self.block.tags[repro.name]
-            nix_tag = self.block.create_tag(
-                f"{repro.name}",
-                "relacs.repro_run",
-                position=np.array(position).flatten(),
+            if efish_relacs_data_array.dimensions[0].dimension_type == nixio.DimensionType.Sample:
+                data_array.append_sampled_dimension(
+                    efish_relacs_data_array.dimensions[0].sampling_interval,
+                    label="time",
+                    unit="s",
                 )
-            nix_tag.extent = extent.flatten()
-
-        sec = self.relacs_sections[f"{repro.name}"]
-        d = create_dict_from_section(sec)
-
-        try:
-            new_sec = self.nix_file.create_section(sec.name, sec.type)
-            create_metadata_from_dict(d, new_sec)
-        except DuplicateName:
-            del self.nix_file.sections[sec.name]
-            new_sec = self.nix_file.create_section(sec.name, sec.type)
-            create_metadata_from_dict(d, new_sec)
-
-        nix_tag.metadata = self.nix_file.sections[repro.name]
-
-        # NOTE: adding refs to tag
-        [
-            nix_tag.references.extend(ref_groups.data_arrays)
-            for ref_groups in self._reference_groups
-            if ref_groups.data_arrays
-        ]
-        try:
-            nix_group = self.block.create_group(repro.name, repro.type)
-        except DuplicateName:
-            nix_group = self.nix_file.blocks[0].groups[repro.name]
-        nix_group.tags.append(nix_tag)
-
-    def create_repros_automatically(self):
-        ttl_oeph = self.block.data_arrays["ttl-line"][:]
-        time_ttl = np.arange(len(ttl_oeph)) / self.cfg.open_ephys.samplerate
-        time_index = np.arange(len(ttl_oeph))
-        # Threshold for TTL peak
-        threshold = 2
-
-        peaks_ttl = time_index[
-            (np.roll(ttl_oeph, 1) < threshold) & (ttl_oeph > threshold)
-        ]
-        # WARNING:Check if peaks are duplicates or near each other
-        close_peaks = np.where(np.diff(peaks_ttl) == 1)[0]
-        if close_peaks.size > 0:
-            peaks_ttl = np.delete(peaks_ttl, close_peaks)
-
-        # NOTE: Get the first peak from the toml file
-        first_peak = self._find_peak_ttl(
-            time_ttl,
-            peaks_ttl,
-            self.stimulus_config["stimulus"]["start_repro_low"],
-            self.stimulus_config["stimulus"]["start_repro_high"],
+            elif efish_relacs_data_array.dimensions[0].dimension_type == nixio.DimensionType.Range:
+                data_array.append_range_dimension(
+                    np.sort(efish_relacs_data_array.dimensions[0].ticks),
+                    label="time",
+                    unit="s",
                 )
 
-        current_position = np.asarray(first_peak.reshape(1))
-        # NOTE: Start defined by config
-        for i, repro in enumerate(
-            self.dataset.repro_runs()[
-                self.stimulus_config["stimulus"]["repro_number_start"] :
-            ],
-            start=self.stimulus_config["stimulus"]["repro_number_start"],
-        ):
-            log.debug(repro.name)
-            log.debug(f"Current Position {current_position.item()}")
-            if repro.duration < 1.0:
-                log.warning(f"Skipping repro {repro.name} because it is two short")
-                continue
+            efish_group.data_arrays.append(data_array)
 
-            if repro.stimuli:
-                log.debug("Processing MultiTag")
-                repetition = len(repro.stimuli)
-                extents_mtag = np.zeros((repetition, 1))
-                position_mtags = np.zeros((repetition, 1))
+    def append_raw_data(self):
+        gr = self.block.create_group("neuronal-data", "open-epyhs.sampled")
+        raw_neo_data = self.neo_data[0].segments[0].analogsignals[0].load()
 
-                for trial, stimulus in enumerate(repro.stimuli):
-                    duration_trial = stimulus.duration
-                    extents_mtag[trial] = duration_trial
-                    position_mtags[trial] = current_position
-
-                    current_position = self._find_peak_ttl_index(
-                        time_ttl, peaks_ttl, current_position
+        log.debug("Appending raw data")
+        nix_data_array = self.block.create_data_array(
+            name="data",
+            array_type="open-ephys.data.sampled",
+            dtype=nixio.DataType.Int16,
+            data=raw_neo_data,
+            unit="uV",
         )
-
-                # current_position = position_mtags[-1]
-                self._append_mtag(repro, position_mtags, extents_mtag)
-                extent = position_mtags[-1] + extents_mtag[-1] - position_mtags[0]
-                self._append_tag(repro, position_mtags[0], extent)
-
-                if not current_position.size > 0:
-                    log.info("Finishing writing")
-                    log.info("Closing nix files")
-                    self.close()
-                    exit()
-            else:
-                if i == 0 and "BaselineActivity" in repro.name:
-                    self._append_tag(repro, 0.0, current_position)
-                    continue
-
-                last_repro_name = self.dataset.repro_runs()[i - 1].name
-                last_repro_position = (
-                    self.block.groups[last_repro_name].tags[0].position[0]
-                    + self.block.groups[last_repro_name].tags[0].extent[0]
+        nix_data_array.append_sampled_dimension(
+            1 / raw_neo_data.sampling_rate.magnitude, label="time", unit="s"
         )
-                self._append_tag(
-                    repro,
-                    last_repro_position.reshape(-1, 1),
-                    (current_position - last_repro_position).reshape(-1, 1),
-                )
-        self.close()
-        #
-        #
-        #     # NOTE: Create a repro tag
-        #     t = self.block.create_tag(
-        #         f"{repro.name}",
-        #         f"{repro.type}",
-        #         position=current_position,
-        #     )
-        #     t.metadata = repro.metadata
-        #
-        # for i, group in enumerate(
-        #     list(self.relacs_block.groups)[
-        #         self.stimulus_config["stimulus"]["repro_number_start"] :
-        #     ],
-        #     start=self.stimulus_config["stimulus"]["repro_number_start"],
-        # ):
-        #     log.debug(group.name)
-        #     log.debug(current_position)
-        #
-        #     nix_group = self.block.groups[group.name]
-        #     if group.name == "BaselineActivity_1":
-        #         first_peak = 0.0
-        #         current_position = np.array(first_peak).reshape(1)
-        #
-        #     # if no multi_tag exists just a tag
-        #     if not group.multi_tags:
-        #         log.debug(f"Creating Tag {group.name}")
-        #         t = self.block.create_tag(
-        #             f"{nix_group.name}",
-        #             f"{nix_group.type}",
-        #             position=current_position,
-        #         )
-        #         t.metadata = self.nix_file.sections[group.name]
-        #
-        #         # searching for the end of the repro in the ttl channel
-        #         start_next_repro = time_ttl[
-        #             peaks_ttl[
-        #                 (
-        #                     time_ttl[peaks_ttl]
-        #                     > group.tags[0].extent + current_position - 1
-        #                 )
-        #                 & (
-        #                     time_ttl[peaks_ttl]
-        #                     < group.tags[0].extent + current_position + 1
-        #                 )
-        #             ]
-        #         ]
-        #         log.debug(start_next_repro)
-        #         if start_next_repro.size > 1:
-        #             if np.all(np.diff(start_next_repro) > 0.5):
-        #                 log.error("Wrong end point in end of repro")
-        #                 log.error(f"{start_next_repro}, {np.max(start_next_repro)}")
-        #             start_next_repro = np.mean(start_next_repro)
-        #
-        #         if not start_next_repro:
-        #             log.error(f"No Endpoint found for repro {group.name}")
-        #             embed()
-        #             exit()
-        #         t.extent = (start_next_repro - t.position[0]).reshape(1)
-        #         # add references to the tag
-        #         [
-        #             t.references.extend(ref_group.data_arrays)
-        #             for ref_group in referencs_groups
-        #             if ref_group.data_arrays
-        #         ]
-        #         nix_group.tags.append(t)
-        #         current_position = start_next_repro.reshape(1)
-        #
-        #     else:
-        #         # NOTE: If repro has multitags
-        #         log.debug(f"Creating Multi Tag {group.name}")
-        #         test_mul_tags = group.multi_tags[0].positions[:]
-        #         test_position_tag, test_extent_tag = (
-        #             group.tags[0].position[0],
-        #             group.tags[0].extent[0],
-        #         )
-        #         len_mtag = len(
-        #             test_mul_tags[
-        #                 (test_mul_tags >= test_position_tag)
-        #                 & (test_mul_tags <= (test_position_tag + test_extent_tag))
-        #             ]
-        #         )
-        #         extents_mtag = group.multi_tags[0].extents[:][
-        #             (test_mul_tags >= test_position_tag)
-        #             & (test_mul_tags <= (test_position_tag + test_extent_tag))
-        #         ]
-        #         position_mtags = np.zeros((len_mtag, 1))
-        #         position_mtags[0] = current_position
-        #
-        #         for j, extents in enumerate(extents_mtag[1:], start=1):
-        #             next_repro_position = time_ttl[
-        #                 peaks_ttl[
-        #                     (
-        #                         time_ttl[peaks_ttl]
-        #                         > extents + current_position - extents / 2
-        #                     )
-        #                     & (time_ttl[peaks_ttl] < extents + current_position + 2)
-        #                 ]
-        #             ]
-        #             if next_repro_position.size == 0:
-        #                 log.error(f"next start of MultiTag not found")
-        #                 embed()
-        #                 exit()
-        #
-        #             if next_repro_position.size > 1:
-        #                 if np.all(np.diff(next_repro_position) > 0.005):
-        #                     log.error("Wrong end point in end of repro")
-        #                     log.error(
-        #                         f"{next_repro_position}, {np.max(next_repro_position)}"
-        #                     )
-        #                     embed()
-        #                     exit()
-        #                     exit(1)
-        #                 next_repro_position = np.mean(next_repro_position)
-        #                 log.debug(f"{j}, {next_repro_position}")
-        #
-        #             position_mtags[j] = next_repro_position
-        #             current_position = next_repro_position
-        #
-        #         start_next_repro = time_ttl[
-        #             peaks_ttl[
-        #                 (time_ttl[peaks_ttl] > current_position + nix_mtag.extents[-1])
-        #                 & (
-        #                     time_ttl[peaks_ttl]
-        #                     < current_position + nix_mtag.extents[-1] + 2
-        #                 )
-        #             ]
-        #         ]
-        #         if not start_next_repro.size == 0:
-        #             if start_next_repro.size > 1:
-        #                 if np.all(np.diff(start_next_repro) > 0.005):
-        #                     log.error("Wrong end point in end of repro")
-        #                     log.error(f"{start_next_repro}, {np.max(start_next_repro)}")
-        #                     embed()
-        #                     exit(1)
-        #
-        #                 start_next_repro = np.mean(start_next_repro)
-        #
-        #         else:
-        #             log.debug(
-        #                 "No ttl pluse foud for the end of the repro create time point"
-        #             )
-        #             log.debug("Taking the next ttl pulse")
-        #             new_repro_start_index = peaks_ttl[
-        #                 (time_ttl[peaks_ttl] > current_position - 1)
-        #                 & (time_ttl[peaks_ttl] < current_position + 2)
-        #             ]
-        #
-        #             # if multiple take the last one
-        #             if new_repro_start_index.size > 1:
-        #                 new_repro_start_index = new_repro_start_index[-1]
-        #
-        #             log.debug(time_ttl[new_repro_start_index])
-        #             try:
-        #                 next_repro_start = peaks_ttl[
-        #                     np.where(new_repro_start_index == peaks_ttl)[0] + 1
-        #                 ]
-        #             except IndexError:
-        #                 if np.where(new_repro_start_index == peaks_ttl)[0] + 1 == len(
-        #                     peaks_ttl
-        #                 ):
-        #                     log.debug("Finishing writing")
-        #                 self.nix_file.close()
-        #                 self.relacs_nix_file.close()
-        #                 exit(1)
-        #             if next_repro_start.size > 1:
-        #                 log.debug("Start of next Repro has multiple ttl pulse")
-        #                 embed()
-        #                 exit()
-        #
-        #             # check if the time difference is greater and 5 seconds
-        #             if (
-        #                 not time_ttl[next_repro_start] - time_ttl[new_repro_start_index]
-        #                 > 5
-        #             ):
-        #                 log.error("Wrong endpoint for repro")
-        #                 exit(1)
-        #             start_next_repro = time_ttl[next_repro_start]
-        #             log.info(f"Start of new Repro {start_next_repro}")
-        #
-        #         current_position = start_next_repro
-        #
-        #     # NOTE: If SAM or Baseline we dont have to find the next current position
-        #     if (
-        #         group.name.split("_")[0] == "SAM"
-        #         or group.name.split("_")[0] == "BaselineActivity"
-        #         # or group.name.split("_")[0] == "FileStimulus"
-        #     ):
-        #         current_position = current_position.reshape(1)
-        #         log.info(f"Start of new Repro {current_position}")
-        #         continue
-        #
-        #     # peaks_repro_index = peaks_ttl[
-        #     #     (time_ttl[peaks_ttl] > current_position - 1)
-        #     #     & (time_ttl[peaks_ttl] < current_position + 2)
-        #     # ]
-        #     #
-        #     # # if multiple take the last one
-        #     # if peaks_repro_index.size > 1:
-        #     #     peaks_repro_index = peaks_repro_index[-1]
-        #     #
-        #     # log.debug(time_ttl[peaks_repro_index])
-        #     # next_repro_start = peaks_ttl[
-        #     #     np.where(peaks_repro_index == peaks_ttl)[0] + 1
-        #     # ]
-        #     # if next_repro_start.size > 1:
-        #     #     embed()
-        #     #
-        #     # # check if the time difference is greater and 5 seconds
-        #     # if not time_ttl[next_repro_start] - time_ttl[peaks_repro_index] > 5:
-        #     #     log.error("Wrong endpoint for repro")
-        #     #     embed()
-        #     #     exit()
-        #     # current_position = time_ttl[next_repro_start]
-        #     # log.info(f"Start of new Repro {current_position}")
-        #     #
-        #     # current_position = current_position.reshape(1)
-        #
-        # self.nix_file.close()
-        # self.relacs_nix_file.close()
-
-    def create_repros_from_config_file(
-        self,
-    ):
-        ttl_oeph = self.block.data_arrays["ttl-line"][:]
-        peaks_ttl = signal.find_peaks(
-            ttl_oeph.flatten(),
-            **self.stimulus_config["stimulus"]["peak_detection"],
-        )[0]
-        time_ttl = np.arange(len(ttl_oeph)) / self.cfg.open_ephys.samplerate
-
-        number_of_repros = len(self.stimulus_config["repros"]["name"])
-
-        referencs_groups = [
-            self.block.groups["neuronal-data"],
-            self.block.groups["spike-data"],
-            self.block.groups["efish"],
-        ]
-
-        for repro_index in range(number_of_repros):
-            name = self.stimulus_config["repros"]["name"][repro_index]
-            log.debug(name)
-            start = np.array(self.stimulus_config["repros"]["start"][repro_index])
-            end = np.array(self.stimulus_config["repros"]["end"][repro_index])
-            nix_group = self.block.groups[name]
-            if start.size > 1:
-                start_repro = time_ttl[
-                    peaks_ttl[
-                        (time_ttl[peaks_ttl] > start[0])
-                        & (time_ttl[peaks_ttl] < start[1])
-                    ]
-                ]
-                if start_repro.size > 1:
-                    if np.all(np.diff(start_repro) > 0.005):
-                        log.error("Wrong end point in end of repro")
-                        log.error(f"{name[repro_index]}, {np.max(start_repro)}")
-                        exit(1)
-                    start_repro = np.mean(start_repro)
-                else:
-                    start_repro = start_repro[0]
-            else:
-                start_repro = start[0]
-
-            if end.size > 1:
-                end_repro = time_ttl[
-                    peaks_ttl[
-                        (time_ttl[peaks_ttl] > end[0]) & (time_ttl[peaks_ttl] < end[1])
-                    ]
-                ]
-                if end_repro.size > 1:
-                    if np.all(np.diff(end_repro) > 0.005):
-                        log.error("Wrong end point in end of repro")
-                        log.error(f"{name[repro_index]}, {np.max(end_repro)}")
-                        exit(1)
-                    end_repro = np.mean(end_repro)
-            else:
-                end_repro = end[0]
-
-            nix_tag = self.block.create_tag(
-                f"{nix_group.name}",
-                f"{nix_group.type}",
-                position=[start_repro],
-            )
-            nix_tag.extent = [end_repro - start_repro]
-            nix_tag.metadata = self.nix_file.sections[name]
-
-            # NOTE: adding refs to tag
-            [
-                nix_tag.references.extend(ref_groups.data_arrays)
-                for ref_groups in referencs_groups
-                if ref_groups.data_arrays
-            ]
-            nix_group.tags.append(nix_tag)
-
-            if not self.relacs_block.groups[name].multi_tags:
-                log.debug(f"no multitags in repro {name}, skipping")
-                continue
-
-            start_repro_multi_tag = start_repro.copy()
-            positions = []
-            positions.append(np.array(start_repro))
-            extents = []
-            extents_relacsed_nix = (
-                self.relacs_block.groups[name].multi_tags[0].extents[:]
-            )
-            extents.append(np.array(extents_relacsed_nix[0]))
-            index_multi_tag = 0
-            while start_repro_multi_tag < end_repro:
-                log.debug(f"{start_repro_multi_tag}")
-
-                start_repro_multi_tag = time_ttl[
-                    peaks_ttl[
-                        (
-                            time_ttl[peaks_ttl]
-                            > start_repro_multi_tag
-                            + extents_relacsed_nix[index_multi_tag]
-                        )
-                        & (
-                            time_ttl[peaks_ttl]
-                            < start_repro_multi_tag
-                            + extents_relacsed_nix[index_multi_tag]
-                            + 2
-                        )
-                    ]
-                ]
-
-                if start_repro_multi_tag.size == 0:
-                    log.debug("Did not find any peaks for new start multi tag")
-                    log.debug(
-                        f"Differenz to end of repro {end_repro - (positions[-1] + extents_relacsed_nix[index_multi_tag])}"
-                    )
-                    break
-
-                if start_repro_multi_tag.size > 1:
-                    if np.all(np.diff(start_repro_multi_tag) > 0.005):
-                        log.error("Wrong end point in end of repro")
-                        log.error(f"Repro_name: {name[repro_index]}")
-                        log.error(f"multitag_index: {index_multi_tag}")
-                        log.error(f"max_value {np.max(start_repro_multi_tag)}")
-                        exit(1)
-                    start_repro_multi_tag = np.mean(start_repro_multi_tag)
-                else:
-                    start_repro_multi_tag = start_repro_multi_tag[0]
-                if end_repro - start_repro_multi_tag < 1:
-                    log.debug("Posssible endpoint detected")
-                    log.debug(
-                        f"Differenz to repro end: {end_repro - start_repro_multi_tag}"
-                    )
-                    break
-
-                positions.append(np.array(start_repro_multi_tag))
-                extents.append(extents_relacsed_nix[index_multi_tag])
-
-            positions = np.array(positions).reshape(len(positions), 1)
-            extents = np.array(extents)
-            if positions.size != extents.size:
-                log.error("Calcualted positions and extents do not match ")
-                log.error(
-                    f"Shape positions {positions.shape}, shape extents {extents.shape}"
-                )
-            if positions.shape != extents.shape:
-                log.error("Shape of Calculated positions and extents do not match")
-                log.error(
-                    f"Shape positions {positions.shape}, shape extents {extents.shape}"
-                )
-                embed()
-                exit()
-
-            nix_mtag = self.block.create_multi_tag(
-                f"{nix_group.name}",
-                f"{nix_group.type}",
-                positions=positions,
-                extents=extents,
-            )
-            nix_mtag.metadata = self.nix_file.sections[name]
-
-            # NOTE: adding refs to mtag
-            [
-                nix_mtag.references.extend(ref_groups.data_arrays)
-                for ref_groups in referencs_groups
-                if ref_groups.data_arrays
-            ]
-            nix_group.multi_tags.append(nix_mtag)
-
-    def plot_stimulus(self):
-        ttl_oeph = self.block.data_arrays["ttl-line"][:]
-
-        time_index = np.arange(len(ttl_oeph))
-        peaks_ttl = time_index[(np.roll(ttl_oeph, 1) < 2) & (ttl_oeph > 2)]
-
-        stimulus_oeph = self.block.data_arrays["stimulus"]
-        stimulus = self.relacs_block.data_arrays["GlobalEFieldStimulus"]
-
-        plt.plot(np.arange(stimulus.size) / 20_000.0, stimulus, label="relacs-stimulus")
-        plt.plot(
-            np.arange(len(stimulus_oeph)) / 30_000.0,
-            stimulus_oeph[:],
-            label="open-ephys",
-        )
-        plt.plot(
-            np.arange(len(ttl_oeph)) / 30_000.0,
-            ttl_oeph[:],
-            label="ttl-line",
-        )
-        plt.scatter(
-            np.arange(len(ttl_oeph))[peaks_ttl] / 30_000.0,
-            ttl_oeph[peaks_ttl],
-            label="detected peaks",
-            color="red",
-            zorder=100,
-        )
-        plt.legend(loc="upper right")
-        plt.show()
+        gr.data_arrays.append(nix_data_array)
 
     def close(self):
-        self.dataset.close()
         self.nix_file.close()
         self.relacs_nix_file.close()
-
-
-# if __name__ == "__main__":
-#     create_nix = CreateNix()
-#     create_nix.create_repros_automatically()
-#     create_nix.plot_stimulus()
-#     # create_nix.create_repros_from_config_file()

pyproject.toml

@@ -9,8 +9,65 @@ dependencies = [
     "neo>=0.14.2",
     "nixio>=1.5.4",
     "rich>=14.1.0",
+    "rlxnix",
     "scipy>=1.16.2",
     "typer>=0.19.2",
 ]
 [project.scripts]
 oephys2nix = "oephys2nix.main:app"
+
+[project.optional-dependencies]
+docs = [
+    "quartodoc>=0.11.1",
+]
+
+[tool.ruff]
+line-length = 100
+indent-width = 4
+
+[tool.ruff.lint]
+select = [
+    "W", # pycodestyle
+    "E", # pycodestyle
+    "F", # Pyflakes
+    "UP", # pyupgrade
+    "B", # flake8-bugbear
+    "SIM", # flake8-simplify
+    "ANN", # flake8-annotations
+    "A", # flake8-builtins
+    "COM", # flake8-commas
+    "C4", # flake8-comprehensions
+    "EM", # flake8-error-msg
+    "EXE", # flake8-executable
+    "ICN", # flake8-import-conventions
+    "PT", # flake8-pytest-style
+    "Q", # flake8-quotes
+    "RET", # flake8-return
+    "SIM", # flake8-simplify
+    "ARG", # flake8-unused-arguments
+    "PTH", # flake8-use-pathlib
+    "PD", # pandas-vet
+    "PL", # pylint
+    "TRY", # tryceratops
+    "NPY", # numpy-specific
+    "I", # isort
+    "C90", # complexity (McCabe)
+    "N", # pep8-naming
+    "D", # pydocstyle
+]
+ignore = [
+    "COM812", # missing trailing comma
+    "TD002", # missing todo author
+    "TD003", # missing todo link
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
+
+[tool.uv.sources]
+rlxnix = { git = "https://github.com/wendtalexander/relacsed_nix.git", branch = "open-ephys" }

uv.lock

@@ -2,6 +2,94 @@ version = 1
 revision = 2
 requires-python = ">=3.13"
 
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload_time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload_time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload_time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload_time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "beartype"
+version = "0.22.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/96/43ed27f27127155f24f5cf85df0c27fd2ac2ab67d94cecc8f76933f91679/beartype-0.22.2.tar.gz", hash = "sha256:ff3a7df26af8d15fa87f97934f0f6d41bbdadca971c410819104998dd26013d2", size = 1574491, upload_time = "2025-10-04T06:37:56.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/2a/a4773109619010192e72f48e95165b14790413a51f513c879c8d63f67e17/beartype-0.22.2-py3-none-any.whl", hash = "sha256:12077afe3528eba5c5b801f816712f7ff06f6da5509994c79561e29b48bcedb8", size = 1317280, upload_time = "2025-10-04T06:37:53.99Z" },
+]
+
+[[package]]
+name = "black"
+version = "25.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "pytokens" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4b/43/20b5c90612d7bdb2bdbcceeb53d588acca3bb8f0e4c5d5c751a2c8fdd55a/black-25.9.0.tar.gz", hash = "sha256:0474bca9a0dd1b51791fcc507a4e02078a1c63f6d4e4ae5544b9848c7adfb619", size = 648393, upload_time = "2025-09-19T00:27:37.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/99/3acfea65f5e79f45472c45f87ec13037b506522719cd9d4ac86484ff51ac/black-25.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0172a012f725b792c358d57fe7b6b6e8e67375dd157f64fa7a3097b3ed3e2175", size = 1742165, upload_time = "2025-09-19T00:34:10.402Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/18/799285282c8236a79f25d590f0222dbd6850e14b060dfaa3e720241fd772/black-25.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3bec74ee60f8dfef564b573a96b8930f7b6a538e846123d5ad77ba14a8d7a64f", size = 1581259, upload_time = "2025-09-19T00:32:49.685Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ce/883ec4b6303acdeca93ee06b7622f1fa383c6b3765294824165d49b1a86b/black-25.9.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b756fc75871cb1bcac5499552d771822fd9db5a2bb8db2a7247936ca48f39831", size = 1655583, upload_time = "2025-09-19T00:30:44.505Z" },
+    { url = "https://files.pythonhosted.org/packages/21/17/5c253aa80a0639ccc427a5c7144534b661505ae2b5a10b77ebe13fa25334/black-25.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:846d58e3ce7879ec1ffe816bb9df6d006cd9590515ed5d17db14e17666b2b357", size = 1343428, upload_time = "2025-09-19T00:32:13.839Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/46/863c90dcd3f9d41b109b7f19032ae0db021f0b2a81482ba0a1e28c84de86/black-25.9.0-py3-none-any.whl", hash = "sha256:474b34c1342cdc157d307b56c4c65bce916480c4a8f6551fdc6bf9b486a7c4ae", size = 203363, upload_time = "2025-09-19T00:27:35.724Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.10.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload_time = "2025-10-05T04:12:15.808Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload_time = "2025-10-05T04:12:14.03Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload_time = "2025-08-09T07:57:28.46Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/65/ca/2135ac97709b400c7654b4b764daf5c5567c2da45a30cdd20f9eefe2d658/charset_normalizer-3.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:14c2a87c65b351109f6abfc424cab3927b3bdece6f706e4d12faaf3d52ee5efe", size = 205326, upload_time = "2025-08-09T07:56:24.721Z" },
+    { url = "https://files.pythonhosted.org/packages/71/11/98a04c3c97dd34e49c7d247083af03645ca3730809a5509443f3c37f7c99/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41d1fc408ff5fdfb910200ec0e74abc40387bccb3252f3f27c0676731df2b2c8", size = 146008, upload_time = "2025-08-09T07:56:26.004Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f5/4659a4cb3c4ec146bec80c32d8bb16033752574c20b1252ee842a95d1a1e/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1bb60174149316da1c35fa5233681f7c0f9f514509b8e399ab70fea5f17e45c9", size = 159196, upload_time = "2025-08-09T07:56:27.25Z" },
+    { url = "https://files.pythonhosted.org/packages/86/9e/f552f7a00611f168b9a5865a1414179b2c6de8235a4fa40189f6f79a1753/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30d006f98569de3459c2fc1f2acde170b7b2bd265dc1943e87e1a4efe1b67c31", size = 156819, upload_time = "2025-08-09T07:56:28.515Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/95/42aa2156235cbc8fa61208aded06ef46111c4d3f0de233107b3f38631803/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:416175faf02e4b0810f1f38bcb54682878a4af94059a1cd63b8747244420801f", size = 151350, upload_time = "2025-08-09T07:56:29.716Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/a9/3865b02c56f300a6f94fc631ef54f0a8a29da74fb45a773dfd3dcd380af7/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aab0f181c486f973bc7262a97f5aca3ee7e1437011ef0c2ec04b5a11d16c927", size = 148644, upload_time = "2025-08-09T07:56:30.984Z" },
+    { url = "https://files.pythonhosted.org/packages/77/d9/cbcf1a2a5c7d7856f11e7ac2d782aec12bdfea60d104e60e0aa1c97849dc/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabf8315679312cfa71302f9bd509ded4f2f263fb5b765cf1433b39106c3cc9", size = 160468, upload_time = "2025-08-09T07:56:32.252Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/42/6f45efee8697b89fda4d50580f292b8f7f9306cb2971d4b53f8914e4d890/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:bd28b817ea8c70215401f657edef3a8aa83c29d447fb0b622c35403780ba11d5", size = 158187, upload_time = "2025-08-09T07:56:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/70/99/f1c3bdcfaa9c45b3ce96f70b14f070411366fa19549c1d4832c935d8e2c3/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18343b2d246dc6761a249ba1fb13f9ee9a2bcd95decc767319506056ea4ad4dc", size = 152699, upload_time = "2025-08-09T07:56:34.739Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/ad/b0081f2f99a4b194bcbb1934ef3b12aa4d9702ced80a37026b7607c72e58/charset_normalizer-3.4.3-cp313-cp313-win32.whl", hash = "sha256:6fb70de56f1859a3f71261cbe41005f56a7842cc348d3aeb26237560bfa5e0ce", size = 99580, upload_time = "2025-08-09T07:56:35.981Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/8f/ae790790c7b64f925e5c953b924aaa42a243fb778fed9e41f147b2a5715a/charset_normalizer-3.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:cf1ebb7d78e1ad8ec2a8c4732c7be2e736f6e5123a4146c5b89c9d1f585f8cef", size = 107366, upload_time = "2025-08-09T07:56:37.339Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/91/b5a06ad970ddc7a0e513112d40113e834638f4ca1120eb727a249fb2715e/charset_normalizer-3.4.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3cd35b7e8aedeb9e34c41385fda4f73ba609e561faedfae0a9e75e44ac558a15", size = 204342, upload_time = "2025-08-09T07:56:38.687Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ec/1edc30a377f0a02689342f214455c3f6c2fbedd896a1d2f856c002fc3062/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89bc04de1d83006373429975f8ef9e7932534b8cc9ca582e4db7d20d91816db", size = 145995, upload_time = "2025-08-09T07:56:40.048Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e5/5e67ab85e6d22b04641acb5399c8684f4d37caf7558a53859f0283a650e9/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2001a39612b241dae17b4687898843f254f8748b796a2e16f1051a17078d991d", size = 158640, upload_time = "2025-08-09T07:56:41.311Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/e5/38421987f6c697ee3722981289d554957c4be652f963d71c5e46a262e135/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8dcfc373f888e4fb39a7bc57e93e3b845e7f462dacc008d9749568b1c4ece096", size = 156636, upload_time = "2025-08-09T07:56:43.195Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/e4/5a075de8daa3ec0745a9a3b54467e0c2967daaaf2cec04c845f73493e9a1/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b97b8404387b96cdbd30ad660f6407799126d26a39ca65729162fd810a99aa", size = 150939, upload_time = "2025-08-09T07:56:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/02/f7/3611b32318b30974131db62b4043f335861d4d9b49adc6d57c1149cc49d4/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccf600859c183d70eb47e05a44cd80a4ce77394d1ac0f79dbd2dd90a69a3a049", size = 148580, upload_time = "2025-08-09T07:56:46.684Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/61/19b36f4bd67f2793ab6a99b979b4e4f3d8fc754cbdffb805335df4337126/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:53cd68b185d98dde4ad8990e56a58dea83a4162161b1ea9272e5c9182ce415e0", size = 159870, upload_time = "2025-08-09T07:56:47.941Z" },
+    { url = "https://files.pythonhosted.org/packages/06/57/84722eefdd338c04cf3030ada66889298eaedf3e7a30a624201e0cbe424a/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:30a96e1e1f865f78b030d65241c1ee850cdf422d869e9028e2fc1d5e4db73b92", size = 157797, upload_time = "2025-08-09T07:56:49.756Z" },
+    { url = "https://files.pythonhosted.org/packages/72/2a/aff5dd112b2f14bcc3462c312dce5445806bfc8ab3a7328555da95330e4b/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d716a916938e03231e86e43782ca7878fb602a125a91e7acb8b5112e2e96ac16", size = 152224, upload_time = "2025-08-09T07:56:51.369Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8c/9839225320046ed279c6e839d51f028342eb77c91c89b8ef2549f951f3ec/charset_normalizer-3.4.3-cp314-cp314-win32.whl", hash = "sha256:c6dbd0ccdda3a2ba7c2ecd9d77b37f3b5831687d8dc1b6ca5f56a4880cc7b7ce", size = 100086, upload_time = "2025-08-09T07:56:52.722Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7a/36fbcf646e41f710ce0a563c1c9a343c6edf9be80786edeb15b6f62e17db/charset_normalizer-3.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:73dc19b562516fc9bcf6e5d6e596df0b4eb98d87e4f79f3ae71840e6ed21361c", size = 107400, upload_time = "2025-08-09T07:56:55.172Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload_time = "2025-08-09T07:57:26.864Z" },
+]
+
 [[package]]
 name = "click"
 version = "8.3.0"
@@ -120,6 +208,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175, upload_time = "2025-09-29T21:13:24.134Z" },
 ]
 
+[[package]]
+name = "griffe"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ec/d7/6c09dd7ce4c7837e4cdb11dce980cb45ae3cd87677298dc3b781b6bce7d3/griffe-1.14.0.tar.gz", hash = "sha256:9d2a15c1eca966d68e00517de5d69dd1bc5c9f2335ef6c1775362ba5b8651a13", size = 424684, upload_time = "2025-09-05T15:02:29.167Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/b1/9ff6578d789a89812ff21e4e0f80ffae20a65d5dd84e7a17873fe3b365be/griffe-1.14.0-py3-none-any.whl", hash = "sha256:0e9d52832cccf0f7188cfe585ba962d2674b241c01916d780925df34873bceb0", size = 144439, upload_time = "2025-09-05T15:02:27.511Z" },
+]
+
 [[package]]
 name = "h5py"
 version = "3.14.0"
@@ -136,6 +236,63 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/6d/0084ed0b78d4fd3e7530c32491f2884140d9b06365dac8a08de726421d4a/h5py-3.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:ae18e3de237a7a830adb76aaa68ad438d85fe6e19e0d99944a3ce46b772c69b3", size = 2852929, upload_time = "2025-06-06T14:05:47.659Z" },
 ]
 
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload_time = "2024-09-15T18:07:39.745Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload_time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload_time = "2025-04-27T15:29:01.736Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload_time = "2025-04-27T15:29:00.214Z" },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload_time = "2025-01-03T18:51:56.698Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload_time = "2025-01-03T18:51:54.306Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload_time = "2025-08-18T17:03:50.038Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload_time = "2025-08-18T17:03:48.373Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload_time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload_time = "2025-09-08T01:34:57.871Z" },
+]
+
 [[package]]
 name = "kiwisolver"
 version = "1.4.9"
@@ -263,6 +420,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload_time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload_time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload_time = "2025-04-22T14:54:22.983Z" },
+]
+
 [[package]]
 name = "neo"
 version = "0.14.2"
@@ -349,19 +515,28 @@ dependencies = [
     { name = "neo" },
     { name = "nixio" },
     { name = "rich" },
+    { name = "rlxnix" },
     { name = "scipy" },
     { name = "typer" },
 ]
 
+[package.optional-dependencies]
+docs = [
+    { name = "quartodoc" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "matplotlib", specifier = ">=3.10.6" },
     { name = "neo", specifier = ">=0.14.2" },
     { name = "nixio", specifier = ">=1.5.4" },
+    { name = "quartodoc", marker = "extra == 'docs'", specifier = ">=0.11.1" },
     { name = "rich", specifier = ">=14.1.0" },
+    { name = "rlxnix", git = "https://github.com/wendtalexander/relacsed_nix.git?branch=open-ephys" },
     { name = "scipy", specifier = ">=1.16.2" },
     { name = "typer", specifier = ">=0.19.2" },
 ]
+provides-extras = ["docs"]
 
 [[package]]
 name = "packaging"
@@ -372,6 +547,55 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload_time = "2025-04-19T11:48:57.875Z" },
 ]
 
+[[package]]
+name = "pandas"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload_time = "2025-09-29T23:34:51.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload_time = "2025-09-29T23:21:05.024Z" },
+    { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload_time = "2025-09-29T23:21:15.979Z" },
+    { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload_time = "2025-09-29T23:21:27.165Z" },
+    { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload_time = "2025-09-29T23:21:40.532Z" },
+    { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload_time = "2025-09-29T23:21:55.77Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload_time = "2025-09-29T23:22:10.109Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload_time = "2025-09-29T23:25:04.889Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload_time = "2025-09-29T23:22:24.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload_time = "2025-09-29T23:22:37.762Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload_time = "2025-09-29T23:22:51.688Z" },
+    { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload_time = "2025-09-29T23:23:05.042Z" },
+    { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload_time = "2025-09-29T23:23:28.57Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload_time = "2025-09-29T23:24:24.876Z" },
+    { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload_time = "2025-09-29T23:25:52.486Z" },
+    { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload_time = "2025-09-29T23:26:33.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload_time = "2025-09-29T23:27:15.384Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload_time = "2025-09-29T23:27:51.625Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload_time = "2025-09-29T23:28:21.289Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload_time = "2025-09-29T23:28:58.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload_time = "2025-09-29T23:32:27.484Z" },
+    { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload_time = "2025-09-29T23:29:31.47Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload_time = "2025-09-29T23:29:54.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload_time = "2025-09-29T23:30:21.003Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload_time = "2025-09-29T23:30:43.391Z" },
+    { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload_time = "2025-09-29T23:31:10.009Z" },
+    { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload_time = "2025-09-29T23:31:59.173Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload_time = "2023-12-10T22:30:45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload_time = "2023-12-10T22:30:43.14Z" },
+]
+
 [[package]]
 name = "pillow"
 version = "11.3.0"
@@ -427,6 +651,72 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload_time = "2025-07-01T09:15:50.399Z" },
 ]
 
+[[package]]
+name = "platformdirs"
+version = "4.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/e8/21db9c9987b0e728855bd57bff6984f67952bea55d6f75e055c46b5383e8/platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf", size = 21634, upload_time = "2025-08-26T14:32:04.268Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/4b/2028861e724d3bd36227adfa20d3fd24c3fc6d52032f4a93c133be5d17ce/platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85", size = 18654, upload_time = "2025-08-26T14:32:02.735Z" },
+]
+
+[[package]]
+name = "plum-dispatch"
+version = "2.5.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beartype" },
+    { name = "rich" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f4/46/ab3928e864b0a88a8ae6987b3da3b7ae32fe0a610264f33272139275dab5/plum_dispatch-2.5.7.tar.gz", hash = "sha256:a7908ad5563b93f387e3817eb0412ad40cfbad04bc61d869cf7a76cd58a3895d", size = 35452, upload_time = "2025-01-17T20:07:31.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/31/21609a9be48e877bc33b089a7f495c853215def5aeb9564a31c210d9d769/plum_dispatch-2.5.7-py3-none-any.whl", hash = "sha256:06471782eea0b3798c1e79dca2af2165bafcfa5eb595540b514ddd81053b1ede", size = 42612, upload_time = "2025-01-17T20:07:26.461Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.11.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/54/ecab642b3bed45f7d5f59b38443dcb36ef50f85af192e6ece103dbfe9587/pydantic-2.11.10.tar.gz", hash = "sha256:dc280f0982fbda6c38fada4e476dc0a4f3aeaf9c6ad4c28df68a666ec3c61423", size = 788494, upload_time = "2025-10-04T10:40:41.338Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bd/1f/73c53fcbfb0b5a78f91176df41945ca466e71e9d9d836e5c522abda39ee7/pydantic-2.11.10-py3-none-any.whl", hash = "sha256:802a655709d49bd004c31e865ef37da30b540786a46bfce02333e0e24b5fe29a", size = 444823, upload_time = "2025-10-04T10:40:39.055Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.33.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload_time = "2025-04-23T18:33:52.104Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload_time = "2025-04-23T18:31:53.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload_time = "2025-04-23T18:31:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload_time = "2025-04-23T18:31:57.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload_time = "2025-04-23T18:31:59.065Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload_time = "2025-04-23T18:32:00.78Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload_time = "2025-04-23T18:32:02.418Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload_time = "2025-04-23T18:32:04.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload_time = "2025-04-23T18:32:06.129Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload_time = "2025-04-23T18:32:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload_time = "2025-04-23T18:32:10.242Z" },
+    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload_time = "2025-04-23T18:32:12.382Z" },
+    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload_time = "2025-04-23T18:32:14.034Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload_time = "2025-04-23T18:32:15.783Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload_time = "2025-04-23T18:32:18.473Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload_time = "2025-04-23T18:32:20.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload_time = "2025-04-23T18:32:22.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload_time = "2025-04-23T18:32:25.088Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -457,6 +747,60 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload_time = "2024-03-01T18:36:18.57Z" },
 ]
 
+[[package]]
+name = "pytokens"
+version = "0.1.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/5f/e959a442435e24f6fb5a01aec6c657079ceaca1b3baf18561c3728d681da/pytokens-0.1.10.tar.gz", hash = "sha256:c9a4bfa0be1d26aebce03e6884ba454e842f186a59ea43a6d3b25af58223c044", size = 12171, upload_time = "2025-02-19T14:51:22.001Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/e5/63bed382f6a7a5ba70e7e132b8b7b8abbcf4888ffa6be4877698dcfbed7d/pytokens-0.1.10-py3-none-any.whl", hash = "sha256:db7b72284e480e69fb085d9f251f66b3d2df8b7166059261258ff35f50fb711b", size = 12046, upload_time = "2025-02-19T14:51:18.694Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload_time = "2025-03-25T02:25:00.538Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload_time = "2025-03-25T02:24:58.468Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload_time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload_time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload_time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload_time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload_time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload_time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload_time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload_time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload_time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload_time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload_time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload_time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload_time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload_time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload_time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload_time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload_time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload_time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload_time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload_time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload_time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload_time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload_time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload_time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload_time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload_time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload_time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload_time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload_time = "2025-09-25T21:32:56.828Z" },
+]
+
 [[package]]
 name = "quantities"
 version = "0.16.2"
@@ -469,6 +813,58 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/17/0c/b4ee3f929bbe564101f110080dcdd33d1181a6f8a041cc9e21d992509b52/quantities-0.16.2-py3-none-any.whl", hash = "sha256:bd5b1ed422770b7cd8952ccfccaf67a89024ae0ecb31b1eacbc7ff966899ab34", size = 103021, upload_time = "2025-04-11T14:16:10.524Z" },
 ]
 
+[[package]]
+name = "quartodoc"
+version = "0.11.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "black" },
+    { name = "click" },
+    { name = "griffe" },
+    { name = "importlib-metadata" },
+    { name = "importlib-resources" },
+    { name = "plum-dispatch" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sphobjinv" },
+    { name = "tabulate" },
+    { name = "typing-extensions" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ff/b9/0bb44cc62a5d63728d04fd6b1e14bcb64945fabad4aa8c03b9d70315fb06/quartodoc-0.11.1.tar.gz", hash = "sha256:c121626e1a36392d168631f33c4d3e7fd48d185de178859f8eafbda14fbfe92f", size = 778611, upload_time = "2025-06-10T14:50:08.185Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/d9/0b48d4184f9ca6a996c4fac46897a968698c9d1e0f0e43a6906746201323/quartodoc-0.11.1-py3-none-any.whl", hash = "sha256:0776eb8e53d89385e2c9a8ae0ec08e8c307c1410dd1bd78bb28e8b1823dbb6ad", size = 88053, upload_time = "2025-06-10T14:50:06.443Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.36.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload_time = "2025-01-25T08:48:16.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload_time = "2025-01-25T08:48:14.241Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload_time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload_time = "2025-08-18T20:46:00.542Z" },
+]
+
 [[package]]
 name = "rich"
 version = "14.1.0"
@@ -482,6 +878,86 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl", hash = "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f", size = 243368, upload_time = "2025-07-25T07:32:56.73Z" },
 ]
 
+[[package]]
+name = "rlxnix"
+version = "0.7.0"
+source = { git = "https://github.com/wendtalexander/relacsed_nix.git?branch=open-ephys#4e9ceb0d94356092481da7b04fd69cb6dc135c6c" }
+dependencies = [
+    { name = "h5py" },
+    { name = "matplotlib" },
+    { name = "nixio" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "scipy" },
+    { name = "tqdm" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.27.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e9/dd/2c0cbe774744272b0ae725f44032c77bdcab6e8bcf544bffa3b6e70c8dba/rpds_py-0.27.1.tar.gz", hash = "sha256:26a1c73171d10b7acccbded82bf6a586ab8203601e565badc74bbbf8bc5a10f8", size = 27479, upload_time = "2025-08-27T12:16:36.024Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/77/610aeee8d41e39080c7e14afa5387138e3c9fa9756ab893d09d99e7d8e98/rpds_py-0.27.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e4b9fcfbc021633863a37e92571d6f91851fa656f0180246e84cbd8b3f6b329b", size = 361741, upload_time = "2025-08-27T12:13:31.039Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/fc/c43765f201c6a1c60be2043cbdb664013def52460a4c7adace89d6682bf4/rpds_py-0.27.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1441811a96eadca93c517d08df75de45e5ffe68aa3089924f963c782c4b898cf", size = 345574, upload_time = "2025-08-27T12:13:32.902Z" },
+    { url = "https://files.pythonhosted.org/packages/20/42/ee2b2ca114294cd9847d0ef9c26d2b0851b2e7e00bf14cc4c0b581df0fc3/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55266dafa22e672f5a4f65019015f90336ed31c6383bd53f5e7826d21a0e0b83", size = 385051, upload_time = "2025-08-27T12:13:34.228Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e8/1e430fe311e4799e02e2d1af7c765f024e95e17d651612425b226705f910/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d78827d7ac08627ea2c8e02c9e5b41180ea5ea1f747e9db0915e3adf36b62dcf", size = 398395, upload_time = "2025-08-27T12:13:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/82/95/9dc227d441ff2670651c27a739acb2535ccaf8b351a88d78c088965e5996/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae92443798a40a92dc5f0b01d8a7c93adde0c4dc965310a29ae7c64d72b9fad2", size = 524334, upload_time = "2025-08-27T12:13:37.562Z" },
+    { url = "https://files.pythonhosted.org/packages/87/01/a670c232f401d9ad461d9a332aa4080cd3cb1d1df18213dbd0d2a6a7ab51/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c46c9dd2403b66a2a3b9720ec4b74d4ab49d4fabf9f03dfdce2d42af913fe8d0", size = 407691, upload_time = "2025-08-27T12:13:38.94Z" },
+    { url = "https://files.pythonhosted.org/packages/03/36/0a14aebbaa26fe7fab4780c76f2239e76cc95a0090bdb25e31d95c492fcd/rpds_py-0.27.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2efe4eb1d01b7f5f1939f4ef30ecea6c6b3521eec451fb93191bf84b2a522418", size = 386868, upload_time = "2025-08-27T12:13:40.192Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/03/8c897fb8b5347ff6c1cc31239b9611c5bf79d78c984430887a353e1409a1/rpds_py-0.27.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:15d3b4d83582d10c601f481eca29c3f138d44c92187d197aff663a269197c02d", size = 405469, upload_time = "2025-08-27T12:13:41.496Z" },
+    { url = "https://files.pythonhosted.org/packages/da/07/88c60edc2df74850d496d78a1fdcdc7b54360a7f610a4d50008309d41b94/rpds_py-0.27.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4ed2e16abbc982a169d30d1a420274a709949e2cbdef119fe2ec9d870b42f274", size = 422125, upload_time = "2025-08-27T12:13:42.802Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/86/5f4c707603e41b05f191a749984f390dabcbc467cf833769b47bf14ba04f/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a75f305c9b013289121ec0f1181931975df78738cdf650093e6b86d74aa7d8dd", size = 562341, upload_time = "2025-08-27T12:13:44.472Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/92/3c0cb2492094e3cd9baf9e49bbb7befeceb584ea0c1a8b5939dca4da12e5/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:67ce7620704745881a3d4b0ada80ab4d99df390838839921f99e63c474f82cf2", size = 592511, upload_time = "2025-08-27T12:13:45.898Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bb/82e64fbb0047c46a168faa28d0d45a7851cd0582f850b966811d30f67ad8/rpds_py-0.27.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d992ac10eb86d9b6f369647b6a3f412fc0075cfd5d799530e84d335e440a002", size = 557736, upload_time = "2025-08-27T12:13:47.408Z" },
+    { url = "https://files.pythonhosted.org/packages/00/95/3c863973d409210da7fb41958172c6b7dbe7fc34e04d3cc1f10bb85e979f/rpds_py-0.27.1-cp313-cp313-win32.whl", hash = "sha256:4f75e4bd8ab8db624e02c8e2fc4063021b58becdbe6df793a8111d9343aec1e3", size = 221462, upload_time = "2025-08-27T12:13:48.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/2c/5867b14a81dc217b56d95a9f2a40fdbc56a1ab0181b80132beeecbd4b2d6/rpds_py-0.27.1-cp313-cp313-win_amd64.whl", hash = "sha256:f9025faafc62ed0b75a53e541895ca272815bec18abe2249ff6501c8f2e12b83", size = 232034, upload_time = "2025-08-27T12:13:50.11Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/78/3958f3f018c01923823f1e47f1cc338e398814b92d83cd278364446fac66/rpds_py-0.27.1-cp313-cp313-win_arm64.whl", hash = "sha256:ed10dc32829e7d222b7d3b93136d25a406ba9788f6a7ebf6809092da1f4d279d", size = 222392, upload_time = "2025-08-27T12:13:52.587Z" },
+    { url = "https://files.pythonhosted.org/packages/01/76/1cdf1f91aed5c3a7bf2eba1f1c4e4d6f57832d73003919a20118870ea659/rpds_py-0.27.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:92022bbbad0d4426e616815b16bc4127f83c9a74940e1ccf3cfe0b387aba0228", size = 358355, upload_time = "2025-08-27T12:13:54.012Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/6f/bf142541229374287604caf3bb2a4ae17f0a580798fd72d3b009b532db4e/rpds_py-0.27.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:47162fdab9407ec3f160805ac3e154df042e577dd53341745fc7fb3f625e6d92", size = 342138, upload_time = "2025-08-27T12:13:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/77/355b1c041d6be40886c44ff5e798b4e2769e497b790f0f7fd1e78d17e9a8/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb89bec23fddc489e5d78b550a7b773557c9ab58b7946154a10a6f7a214a48b2", size = 380247, upload_time = "2025-08-27T12:13:57.683Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a4/d9cef5c3946ea271ce2243c51481971cd6e34f21925af2783dd17b26e815/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e48af21883ded2b3e9eb48cb7880ad8598b31ab752ff3be6457001d78f416723", size = 390699, upload_time = "2025-08-27T12:13:59.137Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/06/005106a7b8c6c1a7e91b73169e49870f4af5256119d34a361ae5240a0c1d/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f5b7bd8e219ed50299e58551a410b64daafb5017d54bbe822e003856f06a802", size = 521852, upload_time = "2025-08-27T12:14:00.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/3e/50fb1dac0948e17a02eb05c24510a8fe12d5ce8561c6b7b7d1339ab7ab9c/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08f1e20bccf73b08d12d804d6e1c22ca5530e71659e6673bce31a6bb71c1e73f", size = 402582, upload_time = "2025-08-27T12:14:02.034Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/b0/f4e224090dc5b0ec15f31a02d746ab24101dd430847c4d99123798661bfc/rpds_py-0.27.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0dc5dceeaefcc96dc192e3a80bbe1d6c410c469e97bdd47494a7d930987f18b2", size = 384126, upload_time = "2025-08-27T12:14:03.437Z" },
+    { url = "https://files.pythonhosted.org/packages/54/77/ac339d5f82b6afff1df8f0fe0d2145cc827992cb5f8eeb90fc9f31ef7a63/rpds_py-0.27.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d76f9cc8665acdc0c9177043746775aa7babbf479b5520b78ae4002d889f5c21", size = 399486, upload_time = "2025-08-27T12:14:05.443Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/29/3e1c255eee6ac358c056a57d6d6869baa00a62fa32eea5ee0632039c50a3/rpds_py-0.27.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:134fae0e36022edad8290a6661edf40c023562964efea0cc0ec7f5d392d2aaef", size = 414832, upload_time = "2025-08-27T12:14:06.902Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/db/6d498b844342deb3fa1d030598db93937a9964fcf5cb4da4feb5f17be34b/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb11a4f1b2b63337cfd3b4d110af778a59aae51c81d195768e353d8b52f88081", size = 557249, upload_time = "2025-08-27T12:14:08.37Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f3/690dd38e2310b6f68858a331399b4d6dbb9132c3e8ef8b4333b96caf403d/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:13e608ac9f50a0ed4faec0e90ece76ae33b34c0e8656e3dceb9a7db994c692cd", size = 587356, upload_time = "2025-08-27T12:14:10.034Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e3/84507781cccd0145f35b1dc32c72675200c5ce8d5b30f813e49424ef68fc/rpds_py-0.27.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dd2135527aa40f061350c3f8f89da2644de26cd73e4de458e79606384f4f68e7", size = 555300, upload_time = "2025-08-27T12:14:11.783Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/ee/375469849e6b429b3516206b4580a79e9ef3eb12920ddbd4492b56eaacbe/rpds_py-0.27.1-cp313-cp313t-win32.whl", hash = "sha256:3020724ade63fe320a972e2ffd93b5623227e684315adce194941167fee02688", size = 216714, upload_time = "2025-08-27T12:14:13.629Z" },
+    { url = "https://files.pythonhosted.org/packages/21/87/3fc94e47c9bd0742660e84706c311a860dcae4374cf4a03c477e23ce605a/rpds_py-0.27.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8ee50c3e41739886606388ba3ab3ee2aae9f35fb23f833091833255a31740797", size = 228943, upload_time = "2025-08-27T12:14:14.937Z" },
+    { url = "https://files.pythonhosted.org/packages/70/36/b6e6066520a07cf029d385de869729a895917b411e777ab1cde878100a1d/rpds_py-0.27.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:acb9aafccaae278f449d9c713b64a9e68662e7799dbd5859e2c6b3c67b56d334", size = 362472, upload_time = "2025-08-27T12:14:16.333Z" },
+    { url = "https://files.pythonhosted.org/packages/af/07/b4646032e0dcec0df9c73a3bd52f63bc6c5f9cda992f06bd0e73fe3fbebd/rpds_py-0.27.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b7fb801aa7f845ddf601c49630deeeccde7ce10065561d92729bfe81bd21fb33", size = 345676, upload_time = "2025-08-27T12:14:17.764Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/16/2f1003ee5d0af4bcb13c0cf894957984c32a6751ed7206db2aee7379a55e/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe0dd05afb46597b9a2e11c351e5e4283c741237e7f617ffb3252780cca9336a", size = 385313, upload_time = "2025-08-27T12:14:19.829Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cd/7eb6dd7b232e7f2654d03fa07f1414d7dfc980e82ba71e40a7c46fd95484/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b6dfb0e058adb12d8b1d1b25f686e94ffa65d9995a5157afe99743bf7369d62b", size = 399080, upload_time = "2025-08-27T12:14:21.531Z" },
+    { url = "https://files.pythonhosted.org/packages/20/51/5829afd5000ec1cb60f304711f02572d619040aa3ec033d8226817d1e571/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed090ccd235f6fa8bb5861684567f0a83e04f52dfc2e5c05f2e4b1309fcf85e7", size = 523868, upload_time = "2025-08-27T12:14:23.485Z" },
+    { url = "https://files.pythonhosted.org/packages/05/2c/30eebca20d5db95720ab4d2faec1b5e4c1025c473f703738c371241476a2/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf876e79763eecf3e7356f157540d6a093cef395b65514f17a356f62af6cc136", size = 408750, upload_time = "2025-08-27T12:14:24.924Z" },
+    { url = "https://files.pythonhosted.org/packages/90/1a/cdb5083f043597c4d4276eae4e4c70c55ab5accec078da8611f24575a367/rpds_py-0.27.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12ed005216a51b1d6e2b02a7bd31885fe317e45897de81d86dcce7d74618ffff", size = 387688, upload_time = "2025-08-27T12:14:27.537Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/92/cf786a15320e173f945d205ab31585cc43969743bb1a48b6888f7a2b0a2d/rpds_py-0.27.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:ee4308f409a40e50593c7e3bb8cbe0b4d4c66d1674a316324f0c2f5383b486f9", size = 407225, upload_time = "2025-08-27T12:14:28.981Z" },
+    { url = "https://files.pythonhosted.org/packages/33/5c/85ee16df5b65063ef26017bef33096557a4c83fbe56218ac7cd8c235f16d/rpds_py-0.27.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0b08d152555acf1f455154d498ca855618c1378ec810646fcd7c76416ac6dc60", size = 423361, upload_time = "2025-08-27T12:14:30.469Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8e/1c2741307fcabd1a334ecf008e92c4f47bb6f848712cf15c923becfe82bb/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:dce51c828941973a5684d458214d3a36fcd28da3e1875d659388f4f9f12cc33e", size = 562493, upload_time = "2025-08-27T12:14:31.987Z" },
+    { url = "https://files.pythonhosted.org/packages/04/03/5159321baae9b2222442a70c1f988cbbd66b9be0675dd3936461269be360/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c1476d6f29eb81aa4151c9a31219b03f1f798dc43d8af1250a870735516a1212", size = 592623, upload_time = "2025-08-27T12:14:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/39/c09fd1ad28b85bc1d4554a8710233c9f4cefd03d7717a1b8fbfd171d1167/rpds_py-0.27.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ce0cac322b0d69b63c9cdb895ee1b65805ec9ffad37639f291dd79467bee675", size = 558800, upload_time = "2025-08-27T12:14:35.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/d6/99228e6bbcf4baa764b18258f519a9035131d91b538d4e0e294313462a98/rpds_py-0.27.1-cp314-cp314-win32.whl", hash = "sha256:dfbfac137d2a3d0725758cd141f878bf4329ba25e34979797c89474a89a8a3a3", size = 221943, upload_time = "2025-08-27T12:14:36.898Z" },
+    { url = "https://files.pythonhosted.org/packages/be/07/c802bc6b8e95be83b79bdf23d1aa61d68324cb1006e245d6c58e959e314d/rpds_py-0.27.1-cp314-cp314-win_amd64.whl", hash = "sha256:a6e57b0abfe7cc513450fcf529eb486b6e4d3f8aee83e92eb5f1ef848218d456", size = 233739, upload_time = "2025-08-27T12:14:38.386Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/89/3e1b1c16d4c2d547c5717377a8df99aee8099ff050f87c45cb4d5fa70891/rpds_py-0.27.1-cp314-cp314-win_arm64.whl", hash = "sha256:faf8d146f3d476abfee026c4ae3bdd9ca14236ae4e4c310cbd1cf75ba33d24a3", size = 223120, upload_time = "2025-08-27T12:14:39.82Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/dc7931dc2fa4a6e46b2a4fa744a9fe5c548efd70e0ba74f40b39fa4a8c10/rpds_py-0.27.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:ba81d2b56b6d4911ce735aad0a1d4495e808b8ee4dc58715998741a26874e7c2", size = 358944, upload_time = "2025-08-27T12:14:41.199Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/22/4af76ac4e9f336bfb1a5f240d18a33c6b2fcaadb7472ac7680576512b49a/rpds_py-0.27.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:84f7d509870098de0e864cad0102711c1e24e9b1a50ee713b65928adb22269e4", size = 342283, upload_time = "2025-08-27T12:14:42.699Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/15/2a7c619b3c2272ea9feb9ade67a45c40b3eeb500d503ad4c28c395dc51b4/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9e960fc78fecd1100539f14132425e1d5fe44ecb9239f8f27f079962021523e", size = 380320, upload_time = "2025-08-27T12:14:44.157Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/7d/4c6d243ba4a3057e994bb5bedd01b5c963c12fe38dde707a52acdb3849e7/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62f85b665cedab1a503747617393573995dac4600ff51869d69ad2f39eb5e817", size = 391760, upload_time = "2025-08-27T12:14:45.845Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/71/b19401a909b83bcd67f90221330bc1ef11bc486fe4e04c24388d28a618ae/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fed467af29776f6556250c9ed85ea5a4dd121ab56a5f8b206e3e7a4c551e48ec", size = 522476, upload_time = "2025-08-27T12:14:47.364Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/44/1a3b9715c0455d2e2f0f6df5ee6d6f5afdc423d0773a8a682ed2b43c566c/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2729615f9d430af0ae6b36cf042cb55c0936408d543fb691e1a9e36648fd35a", size = 403418, upload_time = "2025-08-27T12:14:49.991Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/4b/fb6c4f14984eb56673bc868a66536f53417ddb13ed44b391998100a06a96/rpds_py-0.27.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b207d881a9aef7ba753d69c123a35d96ca7cb808056998f6b9e8747321f03b8", size = 384771, upload_time = "2025-08-27T12:14:52.159Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/56/d5265d2d28b7420d7b4d4d85cad8ef891760f5135102e60d5c970b976e41/rpds_py-0.27.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:639fd5efec029f99b79ae47e5d7e00ad8a773da899b6309f6786ecaf22948c48", size = 400022, upload_time = "2025-08-27T12:14:53.859Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/e9/9f5fc70164a569bdd6ed9046486c3568d6926e3a49bdefeeccfb18655875/rpds_py-0.27.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fecc80cb2a90e28af8a9b366edacf33d7a91cbfe4c2c4544ea1246e949cfebeb", size = 416787, upload_time = "2025-08-27T12:14:55.673Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/64/56dd03430ba491db943a81dcdef115a985aac5f44f565cd39a00c766d45c/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42a89282d711711d0a62d6f57d81aa43a1368686c45bc1c46b7f079d55692734", size = 557538, upload_time = "2025-08-27T12:14:57.245Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/36/92cc885a3129993b1d963a2a42ecf64e6a8e129d2c7cc980dbeba84e55fb/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:cf9931f14223de59551ab9d38ed18d92f14f055a5f78c1d8ad6493f735021bbb", size = 588512, upload_time = "2025-08-27T12:14:58.728Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/10/6b283707780a81919f71625351182b4f98932ac89a09023cb61865136244/rpds_py-0.27.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f39f58a27cc6e59f432b568ed8429c7e1641324fbe38131de852cd77b2d534b0", size = 555813, upload_time = "2025-08-27T12:15:00.334Z" },
+    { url = "https://files.pythonhosted.org/packages/04/2e/30b5ea18c01379da6272a92825dd7e53dc9d15c88a19e97932d35d430ef7/rpds_py-0.27.1-cp314-cp314t-win32.whl", hash = "sha256:d5fa0ee122dc09e23607a28e6d7b150da16c662e66409bbe85230e4c85bb528a", size = 217385, upload_time = "2025-08-27T12:15:01.937Z" },
+    { url = "https://files.pythonhosted.org/packages/32/7d/97119da51cb1dd3f2f3c0805f155a3aa4a95fa44fe7d78ae15e69edf4f34/rpds_py-0.27.1-cp314-cp314t-win_amd64.whl", hash = "sha256:6567d2bb951e21232c2f660c24cf3470bb96de56cdcb3f071a83feeaff8a2772", size = 230097, upload_time = "2025-08-27T12:15:03.961Z" },
+]
+
 [[package]]
 name = "scipy"
 version = "1.16.2"
@@ -551,6 +1027,41 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload_time = "2024-12-04T17:35:26.475Z" },
 ]
 
+[[package]]
+name = "sphobjinv"
+version = "2.3.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "certifi" },
+    { name = "jsonschema" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/77/9a/4887ebe7b46f4669a896dc286a3ac559101d2ceadbbea4614472960c2222/sphobjinv-2.3.1.3.tar.gz", hash = "sha256:a1d51e4cf3d968b9e0d3ed1cbccea0071e5e5795f24a2d7401a4e37d6bd75717", size = 268835, upload_time = "2025-05-26T15:18:16.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/f9/f48a8f489c8ae8930f12c558b4dd26da96791837747fca87e9da2643f12d/sphobjinv-2.3.1.3-py3-none-any.whl", hash = "sha256:41fc39f6f740a707cfe5b24c1a3a4a6e4ddbdd6429a59bf21f0b5ef1fddf932a", size = 50812, upload_time = "2025-05-26T15:18:10.636Z" },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload_time = "2022-10-06T17:21:48.54Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload_time = "2022-10-06T17:21:44.262Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload_time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload_time = "2024-11-24T20:12:19.698Z" },
+]
+
 [[package]]
 name = "typer"
 version = "0.19.2"
@@ -574,3 +1085,63 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload_time = "2025-08-25T13:49:24.86Z" },
 ]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload_time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload_time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload_time = "2025-03-23T13:54:43.652Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload_time = "2025-03-23T13:54:41.845Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload_time = "2025-06-18T14:07:41.644Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload_time = "2025-06-18T14:07:40.39Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload_time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload_time = "2024-11-01T14:06:42.952Z" },
+    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload_time = "2024-11-01T14:06:45.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload_time = "2024-11-01T14:06:47.324Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload_time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload_time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload_time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload_time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload_time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload_time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload_time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload_time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload_time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload_time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload_time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload_time = "2025-06-08T17:06:38.034Z" },
+]