TwoPy 0.1.0__py3-none-any.whl

twopy/typing_guards.py

@@ -0,0 +1,255 @@
+"""Runtime guards for narrowing untyped boundary values.
+
+Inputs: objects decoded from HDF5, JSON, YAML, Qt, napari, or similar external
+libraries.
+Outputs: plain Python values whose runtime shape has been checked before type
+narrowing.
+
+These helpers keep ``typing.cast`` localized to the point where runtime
+validation proves a value's contract.
+"""
+
+from collections.abc import Collection
+from typing import SupportsInt, cast
+
+import numpy as np
+import numpy.typing as npt
+
+__all__ = [
+    "int_or_none",
+    "int_tuple_or_none",
+    "require_bool_array",
+    "require_float64_array",
+    "require_int64_array",
+    "string_key_mapping_or_none",
+    "require_string_choice",
+    "require_string_key_mapping",
+    "require_string_key_mapping_values",
+]
+
+
+def int_or_none(value: object) -> int | None:
+    """Return an integer value when conversion is unambiguous.
+
+    Args:
+        value: Candidate integer-like value from external metadata.
+
+    Returns:
+        Plain ``int`` or ``None`` when conversion fails.
+
+    Boolean values are rejected even though ``bool`` subclasses ``int`` because
+    crop bounds and shapes should not silently treat flags as coordinates.
+    """
+    if isinstance(value, bool):
+        return None
+    if not isinstance(value, str | bytes | bytearray) and not hasattr(value, "__int__"):
+        return None
+    try:
+        return int(cast(str | bytes | bytearray | SupportsInt, value))
+    except (TypeError, ValueError):
+        return None
+
+
+def int_tuple_or_none(value: object, *, length: int) -> tuple[int, ...] | None:
+    """Return a fixed-length tuple of integers when every item parses.
+
+    Args:
+        value: Candidate sequence of integer-like values.
+        length: Required tuple length.
+
+    Returns:
+        Integer tuple or ``None`` when the value is not a matching sequence.
+    """
+    if not isinstance(value, tuple | list) or len(value) != length:
+        return None
+
+    parsed: list[int] = []
+    for item in value:
+        parsed_item = int_or_none(item)
+        if parsed_item is None:
+            return None
+        parsed.append(parsed_item)
+    return tuple(parsed)
+
+
+def string_key_mapping_or_none(value: object) -> dict[str, object] | None:
+    """Return a dictionary when every key is text.
+
+    Args:
+        value: Candidate mapping-like object from external metadata.
+
+    Returns:
+        Copy of the dictionary with string keys, or ``None`` when invalid.
+    """
+    if not isinstance(value, dict):
+        return None
+
+    result: dict[str, object] = {}
+    for key, item in value.items():
+        if not isinstance(key, str):
+            return None
+        result[key] = item
+    return result
+
+
+def require_string_key_mapping(value: object, *, name: str) -> dict[str, object]:
+    """Return a dictionary after validating that every key is text.
+
+    Args:
+        value: Candidate dictionary from an external boundary.
+        name: Human-readable value name for error messages.
+
+    Returns:
+        Copy of the dictionary with string keys.
+
+    Raises:
+        ValueError: If ``value`` is not a dictionary with string keys.
+    """
+    result = string_key_mapping_or_none(value)
+    if result is None:
+        msg = f"{name} must be a dictionary with string keys"
+        raise ValueError(msg)
+    return result
+
+
+def require_string_key_mapping_values(
+    value: object,
+    *,
+    name: str,
+) -> dict[str, dict[str, object]]:
+    """Return a dictionary whose values are string-key dictionaries.
+
+    Args:
+        value: Candidate nested dictionary from an external boundary.
+        name: Human-readable value name for error messages.
+
+    Returns:
+        Nested dictionary copied after validating both mapping levels.
+
+    Raises:
+        ValueError: If the top-level value or any nested value is malformed.
+    """
+    outer = require_string_key_mapping(value, name=name)
+    result: dict[str, dict[str, object]] = {}
+    for key, item in outer.items():
+        result[key] = require_string_key_mapping(
+            item,
+            name=f"{name}[{key!r}]",
+        )
+    return result
+
+
+def require_string_choice[TextChoice: str](
+    value: object,
+    *,
+    name: str,
+    allowed: Collection[TextChoice],
+) -> TextChoice:
+    """Return a text value after checking it is one of the allowed choices.
+
+    Args:
+        value: Candidate text value from an external boundary.
+        name: Human-readable value name for error messages.
+        allowed: Valid string values.
+
+    Returns:
+        The selected allowed value narrowed to the literal type of ``allowed``.
+
+    Raises:
+        ValueError: If ``value`` is not one of the allowed strings.
+    """
+    text = str(value)
+    if text in allowed:
+        return cast(TextChoice, text)
+
+    allowed_text = ", ".join(repr(item) for item in sorted(allowed))
+    msg = f"{name} must be one of {allowed_text}; got {text!r}"
+    raise ValueError(msg)
+
+
+def require_float64_array(
+    value: object,
+    *,
+    name: str,
+    ndim: int | None = None,
+) -> npt.NDArray[np.float64]:
+    """Return a NumPy array after validating float64 dtype and rank.
+
+    Args:
+        value: Candidate array value from an external boundary.
+        name: Human-readable dataset name for error messages.
+        ndim: Optional required number of dimensions.
+
+    Returns:
+        ``float64`` NumPy array.
+
+    Raises:
+        ValueError: If dtype or rank does not match.
+    """
+    array = np.asarray(value)
+    _require_array_contract(array, name=name, dtype=np.dtype(np.float64), ndim=ndim)
+    return cast(npt.NDArray[np.float64], array)
+
+
+def require_int64_array(
+    value: object,
+    *,
+    name: str,
+    ndim: int | None = None,
+) -> npt.NDArray[np.int64]:
+    """Return a NumPy array after validating int64 dtype and rank.
+
+    Args:
+        value: Candidate array value from an external boundary.
+        name: Human-readable dataset name for error messages.
+        ndim: Optional required number of dimensions.
+
+    Returns:
+        ``int64`` NumPy array.
+
+    Raises:
+        ValueError: If dtype or rank does not match.
+    """
+    array = np.asarray(value)
+    _require_array_contract(array, name=name, dtype=np.dtype(np.int64), ndim=ndim)
+    return cast(npt.NDArray[np.int64], array)
+
+
+def require_bool_array(
+    value: object,
+    *,
+    name: str,
+    ndim: int | None = None,
+) -> npt.NDArray[np.bool_]:
+    """Return a NumPy array after validating bool dtype and rank.
+
+    Args:
+        value: Candidate array value from an external boundary.
+        name: Human-readable dataset name for error messages.
+        ndim: Optional required number of dimensions.
+
+    Returns:
+        Boolean NumPy array.
+
+    Raises:
+        ValueError: If dtype or rank does not match.
+    """
+    array = np.asarray(value)
+    _require_array_contract(array, name=name, dtype=np.dtype(np.bool_), ndim=ndim)
+    return cast(npt.NDArray[np.bool_], array)
+
+
+def _require_array_contract(
+    array: npt.NDArray[np.generic],
+    *,
+    name: str,
+    dtype: np.dtype[np.generic],
+    ndim: int | None,
+) -> None:
+    """Validate the dtype and rank expected for a persisted array."""
+    if array.dtype != dtype:
+        msg = f"{name} must have dtype {dtype.name}; got {array.dtype}"
+        raise ValueError(msg)
+    if ndim is not None and array.ndim != ndim:
+        msg = f"{name} must have {ndim} dimension(s); got shape {array.shape}"
+        raise ValueError(msg)

twopy-0.1.0.dist-info/METADATA

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: twopy
+Version: 0.1.0
+Summary: Two-photon imaging analysis tool with a napari interface.
+Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
+License-Expression: MIT
+Requires-Python: <3.14,>=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: h5py<4,>=3.16
+Requires-Dist: matplotlib<4,>=3.10
+Requires-Dist: napari[all]<0.8,>=0.7
+Requires-Dist: numpy<3,>=2.3
+Requires-Dist: pre-commit<5,>=4.6
+Requires-Dist: qtpy<3,>=2.4
+Requires-Dist: pyyaml<7,>=6.0.3
+Requires-Dist: ruff>=0.15
+Requires-Dist: scipy<2,>=1.17
+Requires-Dist: tifffile<2027,>=2026.3
+Requires-Dist: ty<0.1,>=0.0.34
+
+# twopy
+
+Two-photon imaging analysis tool for the Clark Lab output format.
+
+## Getting Started
+
+twopy lets you open two-photon recordings, draw ROIs, plot responses in real time,
+process and analyze them, and save them.
+
+When you first load a recording, twopy converts it to a standardized HDF5 format.
+The converted format includes the aligned movie, mean image, stimulus tables,
+photodiode signals, and  recording metadata. Analysis and the GUI both work from
+the converted files, so the original source files remain separate from twopy's outputs.
+
+### Install
+
+Examples use micromamba, but any conda-compatible environment manager should work.
+
+Run this once from the twopy folder to install everything you need:
+
+```sh
+micromamba env create -f environment.yml
+micromamba activate twopy
+micromamba run -n twopy pre-commit install
+cp config.example.yml config.yml
+```
+
+Then edit `config.yml` so the paths match your computer. The example file
+explains each setting in plain language. `config.yml` stays local to your
+machine and is not tracked by git.
+
+If the `twopy` command is missing after setup, refresh the editable install:
+
+```sh
+micromamba run -n twopy python -m pip install -e .
+```
+
+### Start The GUI
+
+Start napari from the twopy environment:
+
+```sh
+micromamba activate twopy
+twopy
+```
+
+Or run it without activating the environment first:
+
+```sh
+micromamba run -n twopy twopy
+```
+
+You can also open a recording directly:
+
+```sh
+twopy /path/to/source/recording
+```
+
+Or direct path to converted HDF5 files:
+
+```sh
+twopy /path/to/recording_data.h5
+```
+
+Inside napari, use the `twopy` panel to choose a recording folder or a
+`recording_data.h5` file. If a source recording has not been converted yet,
+twopy converts it first, then opens the converted files.
+
+Basic GUI flow:
+
+1. Start twopy.
+2. Choose a recording.
+3. Draw or edit ROIs in the `rois` Labels layer.
+4. Click Save ROIs.
+5. Use the response plot panel to update plots from the current ROIs.
+
+## Setup Details
+
+The environment installs twopy as an editable package, so the `twopy` terminal
+command is available after activating the environment. If the environment
+already existed before the command was added, refresh the editable install:
+
+```sh
+micromamba run -n twopy python -m pip install -e .
+```
+
+## Check
+
+```sh
+micromamba run -n twopy pre-commit run --all-files
+```
+
+The installed pre-commit hook runs ruff, ty, and the unit tests before each
+commit.
+
+## Release
+
+PyPI publishing uses GitHub Actions Trusted Publishing. No PyPI API token secret
+is required.
+
+One-time setup in PyPI:
+
+1. Add a trusted publisher for the `twopy` project.
+2. Use owner `gumadeiras`, repository `twopy`, workflow
+   `publish-to-pypi.yml`, and environment `pypi`.
+3. In GitHub, create the `pypi` environment and require manual approval.
+
+Release flow:
+
+1. Update `project.version` in `pyproject.toml`.
+2. Run `micromamba run -n twopy pre-commit run --all-files`.
+3. Commit the version change.
+4. Create a GitHub release whose tag is the same version, with or without a
+   leading `v`.
+5. Publish the release.
+
+The release workflow checks that the tag matches `pyproject.toml`, builds the
+wheel and source distribution, checks package metadata, and publishes to PyPI
+after the `pypi` environment approval.
+
+## Find Recordings
+
+```python
+from twopy import find_recordings
+
+recordings = find_recordings(
+    year=2023,
+    month=10,
+    day=17,
+    genotype="gh146",
+    stimulus="combo_stim",
+    sensor="g6f",
+    cell_type="ALPN",
+    hemisphere="right",
+    person="Gustavo",
+)
+```
+
+`config.yml` controls whether DB queries use mounted files directly or cached
+local copies. The default is `database_access: copy` because database searches
+over the network can be slow, while copying the DB file locally is usually fast.
+
+## Convert Recording
+
+```python
+from pathlib import Path
+
+from twopy import convert_recording_to_twopy
+
+recording = Path("/path/to/recording")
+
+converted = convert_recording_to_twopy(recording)
+print(converted.path)
+print(converted.movie_path)
+```
+
+Conversion writes `recording_data.h5` for metadata, stimulus tables,
+photodiode signals, and the mean image. The large aligned movie is written
+separately to `aligned_movie.h5`. By default the mean image uses the full movie;
+pass `mean_start_frame` and `mean_stop_frame` to use a frame range. By default,
+conversion writes to the location configured by `analysis_output`; pass
+`output_dir` only when you want to override that for a specific call.
+
+`config.yml` also controls analysis output routing. `analysis_output: source`
+writes into `recording/twopy`; a path mirrors the recording directory structure
+under that output root.
+
+## Analyze Converted Data
+
+```python
+from pathlib import Path
+
+import numpy as np
+
+from twopy import (
+    classify_recording_photodiode_events,
+    compute_roi_delta_f_over_f,
+    detect_recording_photodiode_events,
+    extract_background_corrected_roi_traces,
+    load_converted_recording,
+    make_roi_set,
+    map_stimulus_epochs_to_frame_windows,
+    select_epoch_frame_windows,
+)
+
+recording = load_converted_recording(Path("/path/to/recording_data.h5"))
+mask_array = np.zeros((1, *recording.movie.shape[1:]), dtype=bool)
+mask_array[0, :10, :10] = True
+roi_set = make_roi_set(mask_array)
+traces = extract_background_corrected_roi_traces(
+    recording,
+    roi_set,
+    method="movie_global_percentile",
+)
+alignment = detect_recording_photodiode_events(recording)
+timing = classify_recording_photodiode_events(recording, alignment)
+epoch_windows = map_stimulus_epochs_to_frame_windows(recording, alignment)
+interleave_windows = select_epoch_frame_windows(
+    epoch_windows,
+    epoch_name="Gray Interleave",
+)
+dff = compute_roi_delta_f_over_f(
+    traces,
+    interleave_windows,
+    data_rate_hz=float(recording.acquisition_metadata["acq.frameRate"]),
+    fit_mode="robust",
+)
+```
+
+Analysis starts from converted HDF5 files. ROI masks are GUI-independent, trace
+extraction streams movie chunks, background correction stays explicit, and
+stimulus epoch windows come from classified photodiode events instead of
+nominal frame-rate assumptions. `timing.events` keeps the start, transition,
+and end classifications auditable. Analysis trace extraction uses the saved
+alignment-valid spatial crop by default, including `method="none"` when you
+want uncorrected traces through the analysis path. ROI masks remain full-frame;
+pass `spatial_domain="full_frame"` only when that is the intended audit path.
+The lower-level `extract_roi_traces` helper is a full-frame raw primitive. ROI
+dF/F uses corrected ROI fluorescence plus gray interleave windows to fit one
+shared exponential tau and one amplitude per ROI. The default dF/F fit mode is
+`robust`; pass `fit_mode="source_bounds"` when you need original source-bound
+behavior for audit comparisons.
+
+## Open In Napari
+
+From a converted output directory that contains `recording_data.h5`, or from a
+source recording directory:
+
+```sh
+twopy
+```
+
+If converted files are missing and the selected folder has the expected source
+recording files, twopy runs conversion first and then opens the converted HDF5
+files. If no recording is found, `twopy` still opens napari. Choose a recording
+folder or `recording_data.h5` in the `twopy` dock panel; twopy loads it after
+selection.
+
+Or pass a source folder or converted recording explicitly:
+
+```sh
+twopy /path/to/source/recording
+twopy /path/to/recording_data.h5
+```
+
+By default the launcher opens the mean image, the full movie, an editable
+`rois` Labels layer, a top response-plot dock, a `twopy` loading dock, and a left
+Save ROIs dock. Use `--no-movie` to skip the movie preview, or `--movie-start`
+and `--movie-end` to choose a different preview range. Save ROIs writes
+`rois.h5` beside the current recording by default. The response dock can reload
+existing `analysis_outputs.h5` or update plots from the current Labels layer.
+Saving analysis writes `rois.h5`, `analysis_outputs.h5`,
+`exports/csvs/response_summary_trials.csv`, and
+`exports/csvs/response_summary_grouped.csv` beside the converted recording.
+Response plots share one y-axis across epochs and show two seconds before
+stimulus onset and two seconds after stimulus offset by default, when gray
+interleave frames are available in the grouped responses. Epoch plots are laid
+out horizontally. Each saved response trial includes its own `time_seconds`
+vector, so plots use direct response time values rather than inferring time from
+array indices.
+
+```python
+from pathlib import Path
+
+from twopy import (
+    launch_napari,
+    open_recording_in_napari,
+    roi_label_image_from_layer,
+    save_napari_label_rois,
+)
+
+launch_napari(Path("/path/to/recording_data.h5"))
+
+view = open_recording_in_napari(
+    Path("/path/to/recording_data.h5"),
+    movie_frame_range=(0, 200),
+)
+
+# After drawing or editing the rois Labels layer:
+label_image = roi_label_image_from_layer(view.roi_labels_layer)
+roi_set = save_napari_label_rois(label_image, Path("/path/to/rois.h5"))
+```
+
+Napari code is a thin adapter. It loads converted twopy files, displays the
+mean image, optionally displays a bounded movie preview, creates an editable
+ROI Labels layer, and adds small dock widgets for loading folders, saving ROIs,
+and plotting responses. ROI saving writes the current Labels layer through the
+core ROI HDF5 helpers. Response plotting calls the core analysis workflow when
+updating from current ROIs. Pass `roi_set=Path("/path/to/rois.h5")` when
+reopening existing ROIs. Napari code does not read source MATLAB/TIFF files or
+own analysis decisions.

twopy-0.1.0.dist-info/RECORD

@@ -0,0 +1,84 @@
+twopy/__init__.py,sha256=dZ06g_2W0Diu2h41x5xQhm4N2glY4Y-_ZTAjpfr9pvY,5035
+twopy/_segments.py,sha256=bVpeIYkXMVWb9XW0vC4ZGb3v89gRh6f_Ut1wdMNdxU4,1548
+twopy/api.py,sha256=DhN-wFsr9ywwpvm0A1oFuydh5Ov6Fg-6aA8_uIYI1lA,2822
+twopy/config.py,sha256=FH0AAY7AqCBMgYX0CvRFvwf3_NicfWN3BA9B8mVPQQI,6281
+twopy/converted.py,sha256=un70rJBhPtPaSX3RtUEZYR4KvY8n2UStS223rfAY1Yc,22656
+twopy/inspection.py,sha256=iDHhlipW7RzE9cdFT023JoQz5ENWc-etFothbZcnV0o,15759
+twopy/matlab.py,sha256=tIx3RBskSyfWqUut3EX6A0C57_iCiZOJh3f8pPkKOpw,12254
+twopy/photodiode.py,sha256=2MUc-yxKlCFHlr7VLBuDngkGqEIgrKD4scRqj4jjA2U,12147
+twopy/photodiode_classification.py,sha256=yhLBlE1ExV7ufGz9c2AcXvOxg8wScsjecYEaVO5mHrU,15916
+twopy/roi.py,sha256=dGRfpsHi3vdZuNxXirQYpNTLiZE79O-Njy6wbIP2Nso,14756
+twopy/session.py,sha256=MCvg4xkyct9ARFhJRk4rXgJE5q72EpmIammu3drfZFo,5773
+twopy/spatial.py,sha256=-3uUu5cOCxTLi5XbFzgoOBmL65ADwqRI-JMwG6XFBw4,4663
+twopy/stimulus.py,sha256=2qnZVawUKx0QC3ZES0imlSXM-a706Gb6sxUbAfxdnQE,7903
+twopy/synchronization.py,sha256=ltsCW6cDNcUcO_PaYhHbul-vvsrfvezChYhNw8uMvOA,8103
+twopy/typing_guards.py,sha256=-dcYZZ4xK4mEIH7WdKQZnQWndYVW6PX56HvDWDhXEfk,7394
+twopy/analysis/__init__.py,sha256=TfSKtHiK1RTKNbcklPLc2urdhGWGO9Z3vHzVGBr_Sn0,3154
+twopy/analysis/background_subtraction.py,sha256=yPbKGpA7S5tkFLdzvJazc5x08en_wJ3sBmrwa0VO_Yo,24724
+twopy/analysis/dff.py,sha256=1SOLSopTt2z84rdcTAxka19MYr41Tn-fEto-6LYNtXY,18737
+twopy/analysis/epoch_mapping.py,sha256=cJMJ6XxJnJO2WrrCALBbWs3qixtbYqbYNiyj9YCbOfo,7728
+twopy/analysis/motion.py,sha256=bXTlTt_n6oRHBzvo-nfic400VFY4xtnu_KHa8cdOBCQ,2250
+twopy/analysis/persistence.py,sha256=5vD1XW6R3w5IjcB0YgQmMnA87qkIUUj82VbDoQA_RsM,30650
+twopy/analysis/responses.py,sha256=i2TQNOJsUYi0hmLrawAk17MHy7mxaInA9zonU4BHQXU,11691
+twopy/analysis/trials.py,sha256=bN9__XzFPzdemwHoVwLx1u60cIF77NVkZ-RFOk-HxXg,10626
+twopy/analysis/workflow.py,sha256=7QZM1-jalGEbb0xBLMebT_P0iv5PdUxEhULbi5cplJI,17279
+twopy/analysis/response_processing/__init__.py,sha256=nwyg6_HlK7gsz5vQ9k0q30Ng7cTIIwCNSptXYpGuCJQ,1686
+twopy/analysis/response_processing/apply.py,sha256=qNj6qtWN8zddoWA8LY-XHpBorFve7GHofaBFtrd4MRg,10330
+twopy/analysis/response_processing/options.py,sha256=E9J69KUXNXLBBbGMt9d0axRK6FD-U0cEP001d-fIAxo,6828
+twopy/analysis/response_processing/qc.py,sha256=KJg2tK7LyRb2zSW2WEsC6Ol7XnTfZKDAf-yYAyF0078,10136
+twopy/analysis/response_processing/signals.py,sha256=Ny46o9__Lichb8Qov21tFvv2ZM1KYWIUpQUhOan6sI4,6534
+twopy/conversion/__init__.py,sha256=V133Oaq_h8xgKE-7y3vFPgwiI7iH7FhzcFryuS8OTkU,1142
+twopy/conversion/alignment_crop.py,sha256=WZXRBJOd60e32WwFMaPtsPnj2hJeDawTXvyqSla_r64,10452
+twopy/conversion/api.py,sha256=_JKQozpAiGpfQ7gE1dpS2tE77YDWJRzoYZDDne_jEWQ,3958
+twopy/conversion/frame_ranges.py,sha256=LIKegKiBtR4d14e7DCJGCCYAGf0UbhwDGOAZ33XpG3w,1057
+twopy/conversion/hdf5_writing.py,sha256=ZJ2-1VBuzCYuXmqTBIgaDeXCK_yLZSuYzUSGGuYMAXw,12756
+twopy/conversion/matlab_values.py,sha256=ZmRIuZXnHebX8R_O8KfDZZOXwoCxWsutkBt9EPk5gT8,3518
+twopy/conversion/source_loading.py,sha256=TcbNQXufB7sMnnV2ZPnVjRyqSpvH8HScuMXGz0PFpiU,12567
+twopy/conversion/stimulus_code.py,sha256=_20gbcQ1W3GiMixaawavmMUqf-5kb_mJq6l619Pjzzw,7935
+twopy/conversion/types.py,sha256=66OOzbl50xebE3KQIVQiAFZ0nEWE6RdFITtjZZbPPA4,9971
+twopy/database/__init__.py,sha256=DC11J6iEgPrMMEsXOfK3xBXDlj1GWkB07MIF5fXV82o,915
+twopy/database/cache.py,sha256=JJDcMdJTqh3EvbLGCboZMx3NZSEkLHY5X8pKsXkbh8A,4875
+twopy/database/catalog.py,sha256=EzkoUkBYSTyOEfDvywVidFtIkNTD0TEX93teOEpDCyI,2763
+twopy/database/connection.py,sha256=j2U_FMvzgTeAMFUzahA3KI_uepjKkVxbceCdnNLjp3c,756
+twopy/database/generic.py,sha256=G4TaqSpbaQAjiLxqnVloQnTm4fNGyXfQyqGcF7iC3e8,8195
+twopy/database/modeled.py,sha256=Nf4fmgt_Xfv5JT0921OvvJVo72Wtx11iZuVFOl-hItQ,14190
+twopy/database/sql.py,sha256=m26wQroYW2JVp-ckhouxjVKrXlGuOwx6iaCwuYQyIGs,1417
+twopy/database/types.py,sha256=kZA2c3Duv_boiEuxWRCzg5CNkxqwDqea4wwN1b_GuHk,3229
+twopy/napari/__init__.py,sha256=XG3ny3KEz8m6VFUz6ZaKpSNesIo6G9GHgCaQ4wz-3YM,965
+twopy/napari/__main__.py,sha256=NnZzUP0UCWU6xOiCzPoBfGBVfrRYi6jWXVJNZ1wNuK8,250
+twopy/napari/constants.py,sha256=pP_b6W8IPTeoKUsX3bkP74XlNGRhP7-rmZBVpVgPgts,393
+twopy/napari/controls.py,sha256=irmGkgsoRZLJmodrGkYuOHJMD_87B2KA0w8-u_GO1jQ,24917
+twopy/napari/display.py,sha256=0t0VTDqqXY04Xe5RDKi6nYLPmJbEZAdSJFJVierFGK4,5888
+twopy/napari/display_paths.py,sha256=OXnmNOEtYerVtDG_FhkpfUYAaGVoGAlRqQvmxV9tYEM,5930
+twopy/napari/interactive.py,sha256=Mf9kB9u7q6i1Hm6kQR8wJAQ1_U9MI-14TD8NfdNU9jU,10697
+twopy/napari/launcher.py,sha256=G_eUOcvsdUaYag9045veMtdChRcjIGW0R2JhaL9Z58w,5698
+twopy/napari/layout.py,sha256=MLO0YP-gpYP54INOgQRn3pEfYXxntR3_ix19AbGMGoo,4148
+twopy/napari/loading.py,sha256=FLo6yLeRd7DTRiGKryoOwrRpzXKggBjt6I7NoxJecOI,6620
+twopy/napari/movie.py,sha256=BAwniak4TR-mk9gnXlwivfPRMb4jhrhQ3EwvgdO2MEY,2344
+twopy/napari/paths.py,sha256=gFrmtO-YJqjNlpjW6Q6VyP0QV3BZ55qTJdM8q6CJDTM,5309
+twopy/napari/protocols.py,sha256=FnUqCWrDYIW5XrKdHNaE6f75NzxfYW5Ycnw67eBil78,2275
+twopy/napari/responses.py,sha256=Dsu6-U9jG_UI8JZbIV1A2XtUqtl-lT6iOg52F5Qkx4s,3109
+twopy/napari/roi.py,sha256=S4Zb1wRIvrZgF3eWAPOyuBb8XnSjhaZiMectlqLuF3Q,7606
+twopy/napari/session.py,sha256=G12Zf-Bhd3dbPRnKGL8gD1ryaBKiDYf-yehYLaDq_Bs,11866
+twopy/napari/state.py,sha256=OtMZfk2ifdWlC7j3jmkqN1TNAApTmlZ4szGhH5ksgaY,2908
+twopy/napari/text.py,sha256=kHS91G4CyPjMzKcPcqGlT7ASmgl4z4uX1jgQIbu0FME,800
+twopy/napari/types.py,sha256=Hth2EVLTdg1S3OSr4Af4UJBTzFA4yTT2p3jh7PSJskc,1289
+twopy/napari/viewer.py,sha256=5GjpNtqJVeO2glszdUdk7OAMzyqOwq1aFuVm3wCRBG8,14744
+twopy/napari/plotting/__init__.py,sha256=CQW3sf1ujm2ZTXk4xKKhp6ZkabKZw6QsTSJ6iy84Twc,650
+twopy/napari/plotting/data.py,sha256=otS24bVi11VW_5Mvun512oc8kc9ovn3wsFulIeoJTSU,8680
+twopy/napari/plotting/docks.py,sha256=QajHsgFCbuqqc1hdH-wBHukoS-PDR7Q_0E1wj8ZuqiQ,37486
+twopy/napari/plotting/export.py,sha256=Y9hvLAf7IzxE47jFp7kp9lFb_UDiuQ0i8AzUR0TXITE,25617
+twopy/napari/plotting/export_controls.py,sha256=t7jLjQwd8HG5F-Zxyc0TLW0EFXn5m70diNFAawL6IRc,6695
+twopy/napari/plotting/label_visibility.py,sha256=NzMdsiNAem0XNyl_X17qLWUUzGsbFJrKzQ1svxwp9_Q,8175
+twopy/napari/plotting/options.py,sha256=tXqzyCp0cRZGOjm11LCi4JEoN1BToR6TIKMcpKq6tyQ,8147
+twopy/napari/plotting/panels.py,sha256=lj9btXu-w6rHQROThWYH2FFbYsvHILuMzi4jhSK5wmI,3322
+twopy/napari/plotting/widgets.py,sha256=pJUSOVQ0FiBG6qwKShNFruH9SxtfkjesHKo1bjUs0Rs,21874
+twopy/parity/__init__.py,sha256=IfSiTYAP4FVNzgQVVrCtbpVF5SI9vSYlR3yNZN1UWes,1009
+twopy/parity/dff.py,sha256=wBnkZ95kaywT2U7XtoZ5rbG-wD5Ergqs5cnLwVPc6-g,14446
+twopy/parity/roi.py,sha256=Q3deH6xRGCmTXASTlPHQgzH7FhBWkdjRUgh9skyS8j0,4975
+twopy/parity/saved_analysis.py,sha256=Kbpaxh1zapR5XxnHEkin8r4mEZX8kEtonudeZcwI7Dw,5597
+twopy-0.1.0.dist-info/METADATA,sha256=HXTcVoHQZ_2YNXJoy-nG7QiYijSKn11k1W6lH5gzV8A,10173
+twopy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+twopy-0.1.0.dist-info/entry_points.txt,sha256=RnmRKOxEv5ZwLN-dArdSB678gM2iNxbE30VwRpwhp8o,44
+twopy-0.1.0.dist-info/top_level.txt,sha256=8MB6QGpnHMTeTfEE543DOr676HcemeoELujrJkFcvak,6
+twopy-0.1.0.dist-info/RECORD,,

twopy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

twopy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+twopy = twopy.napari:main

twopy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+twopy