napari-tmidas 0.1.1__py3-none-any.whl

napari_tmidas/__init__.py

@@ -0,0 +1,25 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+from ._reader import napari_get_reader
+from ._sample_data import make_sample_data
+from ._widget import (
+    ExampleQWidget,
+    ImageThreshold,
+    threshold_autogenerate_widget,
+    threshold_magic_widget,
+)
+from ._writer import write_multiple, write_single_image
+
+__all__ = (
+    "napari_get_reader",
+    "write_single_image",
+    "write_multiple",
+    "make_sample_data",
+    "ExampleQWidget",
+    "ImageThreshold",
+    "threshold_autogenerate_widget",
+    "threshold_magic_widget",
+)

napari_tmidas/_reader.py

@@ -0,0 +1,73 @@
+"""
+This module is an example of a barebones numpy reader plugin for napari.
+
+It implements the Reader specification, but your plugin may choose to
+implement multiple readers or even other plugin contributions. see:
+https://napari.org/stable/plugins/guides.html?#readers
+"""
+
+import numpy as np
+
+
+def napari_get_reader(path):
+    """A basic implementation of a Reader contribution.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    function or None
+        If the path is a recognized format, return a function that accepts the
+        same path or list of paths, and returns a list of layer data tuples.
+    """
+    if isinstance(path, list):
+        # reader plugins may be handed single path, or a list of paths.
+        # if it is a list, it is assumed to be an image stack...
+        # so we are only going to look at the first file.
+        path = path[0]
+
+    # if we know we cannot read the file, we immediately return None.
+    if not path.endswith(".npy"):
+        return None
+
+    # otherwise we return the *function* that can read ``path``.
+    return reader_function
+
+
+def reader_function(path):
+    """Take a path or list of paths and return a list of LayerData tuples.
+
+    Readers are expected to return data as a list of tuples, where each tuple
+    is (data, [add_kwargs, [layer_type]]), "add_kwargs" and "layer_type" are
+    both optional.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    layer_data : list of tuples
+        A list of LayerData tuples where each tuple in the list contains
+        (data, metadata, layer_type), where data is a numpy array, metadata is
+        a dict of keyword arguments for the corresponding viewer.add_* method
+        in napari, and layer_type is a lower-case string naming the type of
+        layer. Both "meta", and "layer_type" are optional. napari will
+        default to layer_type=="image" if not provided
+    """
+    # handle both a string and a list of strings
+    paths = [path] if isinstance(path, str) else path
+    # load all files into array
+    arrays = [np.load(_path) for _path in paths]
+    # stack arrays into single array
+    data = np.squeeze(np.stack(arrays))
+
+    # optional kwargs for the corresponding viewer.add_* method
+    add_kwargs = {}
+
+    layer_type = "image"  # optional, default is "image"
+    return [(data, add_kwargs, layer_type)]

napari_tmidas/_sample_data.py

@@ -0,0 +1,22 @@
+"""
+This module is an example of a barebones sample data provider for napari.
+
+It implements the "sample data" specification.
+see: https://napari.org/stable/plugins/guides.html?#sample-data
+
+Replace code below according to your needs.
+"""
+
+from __future__ import annotations
+
+import numpy
+
+
+def make_sample_data():
+    """Generates an image"""
+    # Return list of tuples
+    # [(data1, add_image_kwargs1), (data2, add_image_kwargs2)]
+    # Check the documentation for more information about the
+    # add_image_kwargs
+    # https://napari.org/stable/api/napari.Viewer.html#napari.Viewer.add_image
+    return [(numpy.random.rand(512, 512), {})]

napari_tmidas/_tests/test_reader.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+from napari_tmidas import napari_get_reader
+
+
+# tmp_path is a pytest fixture
+def test_reader(tmp_path):
+    """An example of how you might test your plugin."""
+
+    # write some fake data using your supported file format
+    my_test_file = str(tmp_path / "myfile.npy")
+    original_data = np.random.rand(20, 20)
+    np.save(my_test_file, original_data)
+
+    # try to read it back in
+    reader = napari_get_reader(my_test_file)
+    assert callable(reader)
+
+    # make sure we're delivering the right format
+    layer_data_list = reader(my_test_file)
+    assert isinstance(layer_data_list, list) and len(layer_data_list) > 0
+    layer_data_tuple = layer_data_list[0]
+    assert isinstance(layer_data_tuple, tuple) and len(layer_data_tuple) > 0
+
+    # make sure it's the same as it started
+    np.testing.assert_allclose(original_data, layer_data_tuple[0])
+
+
+def test_get_reader_pass():
+    reader = napari_get_reader("fake.file")
+    assert reader is None

napari_tmidas/_tests/test_sample_data.py

@@ -0,0 +1,7 @@
+# from napari_tmidas import make_sample_data
+
+# add your tests here...
+
+
+def test_something():
+    pass

napari_tmidas/_tests/test_widget.py

@@ -0,0 +1,66 @@
+import numpy as np
+
+from napari_tmidas._widget import (
+    ExampleQWidget,
+    ImageThreshold,
+    threshold_autogenerate_widget,
+    threshold_magic_widget,
+)
+
+
+def test_threshold_autogenerate_widget():
+    # because our "widget" is a pure function, we can call it and
+    # test it independently of napari
+    im_data = np.random.random((100, 100))
+    thresholded = threshold_autogenerate_widget(im_data, 0.5)
+    assert thresholded.shape == im_data.shape
+    # etc.
+
+
+# make_napari_viewer is a pytest fixture that returns a napari viewer object
+# you don't need to import it, as long as napari is installed
+# in your testing environment
+def test_threshold_magic_widget(make_napari_viewer):
+    viewer = make_napari_viewer()
+    layer = viewer.add_image(np.random.random((100, 100)))
+
+    # our widget will be a MagicFactory or FunctionGui instance
+    my_widget = threshold_magic_widget()
+
+    # if we "call" this object, it'll execute our function
+    thresholded = my_widget(viewer.layers[0], 0.5)
+    assert thresholded.shape == layer.data.shape
+    # etc.
+
+
+def test_image_threshold_widget(make_napari_viewer):
+    viewer = make_napari_viewer()
+    layer = viewer.add_image(np.random.random((100, 100)))
+    my_widget = ImageThreshold(viewer)
+
+    # because we saved our widgets as attributes of the container
+    # we can set their values without having to "interact" with the viewer
+    my_widget._image_layer_combo.value = layer
+    my_widget._threshold_slider.value = 0.5
+
+    # this allows us to run our functions directly and ensure
+    # correct results
+    my_widget._threshold_im()
+    assert len(viewer.layers) == 2
+
+
+# capsys is a pytest fixture that captures stdout and stderr output streams
+def test_example_q_widget(make_napari_viewer, capsys):
+    # make viewer and add an image layer using our fixture
+    viewer = make_napari_viewer()
+    viewer.add_image(np.random.random((100, 100)))
+
+    # create our widget, passing in the viewer
+    my_widget = ExampleQWidget(viewer)
+
+    # call our widget method
+    my_widget._on_click()
+
+    # read captured output and check that it's as we expected
+    captured = capsys.readouterr()
+    assert captured.out == "napari has 1 layers\n"

napari_tmidas/_tests/test_writer.py

@@ -0,0 +1,7 @@
+# from napari_tmidas import write_single_image, write_multiple
+
+# add your tests here...
+
+
+def test_something():
+    pass

napari_tmidas/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)

napari_tmidas/_widget.py

@@ -0,0 +1,129 @@
+"""
+This module contains four napari widgets declared in
+different ways:
+
+- a pure Python function flagged with `autogenerate: true`
+    in the plugin manifest. Type annotations are used by
+    magicgui to generate widgets for each parameter. Best
+    suited for simple processing tasks - usually taking
+    in and/or returning a layer.
+- a `magic_factory` decorated function. The `magic_factory`
+    decorator allows us to customize aspects of the resulting
+    GUI, including the widgets associated with each parameter.
+    Best used when you have a very simple processing task,
+    but want some control over the autogenerated widgets. If you
+    find yourself needing to define lots of nested functions to achieve
+    your functionality, maybe look at the `Container` widget!
+- a `magicgui.widgets.Container` subclass. This provides lots
+    of flexibility and customization options while still supporting
+    `magicgui` widgets and convenience methods for creating widgets
+    from type annotations. If you want to customize your widgets and
+    connect callbacks, this is the best widget option for you.
+- a `QWidget` subclass. This provides maximal flexibility but requires
+    full specification of widget layouts, callbacks, events, etc.
+
+References:
+- Widget specification: https://napari.org/stable/plugins/guides.html?#widgets
+- magicgui docs: https://pyapp-kit.github.io/magicgui/
+
+Replace code below according to your needs.
+"""
+
+from typing import TYPE_CHECKING
+
+from magicgui import magic_factory
+from magicgui.widgets import CheckBox, Container, create_widget
+from qtpy.QtWidgets import QHBoxLayout, QPushButton, QWidget
+from skimage.util import img_as_float
+
+if TYPE_CHECKING:
+    import napari
+
+
+# Uses the `autogenerate: true` flag in the plugin manifest
+# to indicate it should be wrapped as a magicgui to autogenerate
+# a widget.
+def threshold_autogenerate_widget(
+    img: "napari.types.ImageData",
+    threshold: "float",
+) -> "napari.types.LabelsData":
+    return img_as_float(img) > threshold
+
+
+# the magic_factory decorator lets us customize aspects of our widget
+# we specify a widget type for the threshold parameter
+# and use auto_call=True so the function is called whenever
+# the value of a parameter changes
+@magic_factory(
+    threshold={"widget_type": "FloatSlider", "max": 1}, auto_call=True
+)
+def threshold_magic_widget(
+    img_layer: "napari.layers.Image", threshold: "float"
+) -> "napari.types.LabelsData":
+    return img_as_float(img_layer.data) > threshold
+
+
+# if we want even more control over our widget, we can use
+# magicgui `Container`
+class ImageThreshold(Container):
+    def __init__(self, viewer: "napari.viewer.Viewer"):
+        super().__init__()
+        self._viewer = viewer
+        # use create_widget to generate widgets from type annotations
+        self._image_layer_combo = create_widget(
+            label="Image", annotation="napari.layers.Image"
+        )
+        self._threshold_slider = create_widget(
+            label="Threshold", annotation=float, widget_type="FloatSlider"
+        )
+        self._threshold_slider.min = 0
+        self._threshold_slider.max = 1
+        # use magicgui widgets directly
+        self._invert_checkbox = CheckBox(text="Keep pixels below threshold")
+
+        # connect your own callbacks
+        self._threshold_slider.changed.connect(self._threshold_im)
+        self._invert_checkbox.changed.connect(self._threshold_im)
+
+        # append into/extend the container with your widgets
+        self.extend(
+            [
+                self._image_layer_combo,
+                self._threshold_slider,
+                self._invert_checkbox,
+            ]
+        )
+
+    def _threshold_im(self):
+        image_layer = self._image_layer_combo.value
+        if image_layer is None:
+            return
+
+        image = img_as_float(image_layer.data)
+        name = image_layer.name + "_thresholded"
+        threshold = self._threshold_slider.value
+        if self._invert_checkbox.value:
+            thresholded = image < threshold
+        else:
+            thresholded = image > threshold
+        if name in self._viewer.layers:
+            self._viewer.layers[name].data = thresholded
+        else:
+            self._viewer.add_labels(thresholded, name=name)
+
+
+class ExampleQWidget(QWidget):
+    # your QWidget.__init__ can optionally request the napari viewer instance
+    # use a type annotation of 'napari.viewer.Viewer' for any parameter
+    def __init__(self, viewer: "napari.viewer.Viewer"):
+        super().__init__()
+        self.viewer = viewer
+
+        btn = QPushButton("Click me!")
+        btn.clicked.connect(self._on_click)
+
+        self.setLayout(QHBoxLayout())
+        self.layout().addWidget(btn)
+
+    def _on_click(self):
+        print("napari has", len(self.viewer.layers), "layers")

napari_tmidas/_writer.py

@@ -0,0 +1,66 @@
+"""
+This module is an example of a barebones writer plugin for napari.
+
+It implements the Writer specification.
+see: https://napari.org/stable/plugins/guides.html?#writers
+
+Replace code below according to your needs.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Union
+
+if TYPE_CHECKING:
+    DataType = Union[Any, Sequence[Any]]
+    FullLayerData = tuple[DataType, dict, str]
+
+
+def write_single_image(path: str, data: Any, meta: dict) -> list[str]:
+    """Writes a single image layer.
+
+    Parameters
+    ----------
+    path : str
+        A string path indicating where to save the image file.
+    data : The layer data
+        The `.data` attribute from the napari layer.
+    meta : dict
+        A dictionary containing all other attributes from the napari layer
+        (excluding the `.data` layer attribute).
+
+    Returns
+    -------
+    [path] : A list containing the string path to the saved file.
+    """
+
+    # implement your writer logic here ...
+
+    # return path to any file(s) that were successfully written
+    return [path]
+
+
+def write_multiple(path: str, data: list[FullLayerData]) -> list[str]:
+    """Writes multiple layers of different types.
+
+    Parameters
+    ----------
+    path : str
+        A string path indicating where to save the data file(s).
+    data : A list of layer tuples.
+        Tuples contain three elements: (data, meta, layer_type)
+        `data` is the layer data
+        `meta` is a dictionary containing all other metadata attributes
+        from the napari layer (excluding the `.data` layer attribute).
+        `layer_type` is a string, eg: "image", "labels", "surface", etc.
+
+    Returns
+    -------
+    [path] : A list containing (potentially multiple) string paths to the saved file(s).
+    """
+
+    # implement your writer logic here ...
+
+    # return path to any file(s) that were successfully written
+    return [path]

napari_tmidas/napari.yaml

@@ -0,0 +1,57 @@
+name: napari-tmidas
+display_name: T-MIDAS
+# use 'hidden' to remove plugin from napari hub search results
+visibility: public
+# see https://napari.org/stable/plugins/technical_references/manifest.html#fields for valid categories
+categories: ["Annotation", "Segmentation", "Acquisition"]
+contributions:
+  commands:
+    - id: napari-tmidas.get_reader
+      python_name: napari_tmidas._reader:napari_get_reader
+      title: Open data with T-MIDAS
+    - id: napari-tmidas.write_multiple
+      python_name: napari_tmidas._writer:write_multiple
+      title: Save multi-layer data with T-MIDAS
+    - id: napari-tmidas.write_single_image
+      python_name: napari_tmidas._writer:write_single_image
+      title: Save image data with T-MIDAS
+    - id: napari-tmidas.make_sample_data
+      python_name: napari_tmidas._sample_data:make_sample_data
+      title: Load sample data from T-MIDAS
+    - id: napari-tmidas.make_container_widget
+      python_name: napari_tmidas:ImageThreshold
+      title: Make threshold Container widget
+    - id: napari-tmidas.make_magic_widget
+      python_name: napari_tmidas:threshold_magic_widget
+      title: Make threshold magic widget
+    - id: napari-tmidas.make_function_widget
+      python_name: napari_tmidas:threshold_autogenerate_widget
+      title: Make threshold function widget
+    - id: napari-tmidas.make_qwidget
+      python_name: napari_tmidas:ExampleQWidget
+      title: Make example QWidget
+  readers:
+    - command: napari-tmidas.get_reader
+      accepts_directories: false
+      filename_patterns: ['*.npy']
+  writers:
+    - command: napari-tmidas.write_multiple
+      layer_types: ['image*','labels*']
+      filename_extensions: []
+    - command: napari-tmidas.write_single_image
+      layer_types: ['image']
+      filename_extensions: ['.npy']
+  sample_data:
+    - command: napari-tmidas.make_sample_data
+      display_name: T-MIDAS
+      key: unique_id.1
+  widgets:
+    - command: napari-tmidas.make_container_widget
+      display_name: Container Threshold
+    - command: napari-tmidas.make_magic_widget
+      display_name: Magic Threshold
+    - command: napari-tmidas.make_function_widget
+      autogenerate: true
+      display_name: Autogenerate Threshold
+    - command: napari-tmidas.make_qwidget
+      display_name: Example QWidget

napari_tmidas-0.1.1.dist-info/LICENSE

@@ -0,0 +1,28 @@
+
+Copyright (c) 2025, Marco Meer
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

napari_tmidas-0.1.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.2
+Name: napari-tmidas
+Version: 0.1.1
+Summary: Tissue Microscopy Image Data Analysis Suite
+Author: Marco Meer
+Author-email: marco.meer@pm.me
+License: 
+        Copyright (c) 2025, Marco Meer
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Bug Tracker, https://github.com/macromeer/napari-tmidas/issues
+Project-URL: Documentation, https://github.com/macromeer/napari-tmidas#README.md
+Project-URL: Source Code, https://github.com/macromeer/napari-tmidas
+Project-URL: User Support, https://github.com/macromeer/napari-tmidas/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: magicgui
+Requires-Dist: qtpy
+Requires-Dist: scikit-image
+Provides-Extra: testing
+Requires-Dist: tox; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-qt; extra == "testing"
+Requires-Dist: napari; extra == "testing"
+Requires-Dist: pyqt5; extra == "testing"
+
+# napari-tmidas
+
+[![License BSD-3](https://img.shields.io/pypi/l/napari-tmidas.svg?color=green)](https://github.com/macromeer/napari-tmidas/raw/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/napari-tmidas.svg?color=green)](https://pypi.org/project/napari-tmidas)
+[![Python Version](https://img.shields.io/pypi/pyversions/napari-tmidas.svg?color=green)](https://python.org)
+[![tests](https://github.com/macromeer/napari-tmidas/workflows/tests/badge.svg)](https://github.com/macromeer/napari-tmidas/actions)
+[![codecov](https://codecov.io/gh/macromeer/napari-tmidas/branch/main/graph/badge.svg)](https://codecov.io/gh/macromeer/napari-tmidas)
+[![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/napari-tmidas)](https://napari-hub.org/plugins/napari-tmidas)
+
+Tissue Microscopy Image Data Analysis Suite
+
+----------------------------------
+
+This [napari] plugin was generated with [copier] using the [napari-plugin-template].
+
+<!--
+Don't miss the full getting started guide to set up your new package:
+https://github.com/napari/napari-plugin-template#getting-started
+
+and review the napari docs for plugin developers:
+https://napari.org/stable/plugins/index.html
+-->
+
+## Installation
+
+You can install `napari-tmidas` via [pip]:
+
+    pip install napari-tmidas
+
+
+
+To install latest development version :
+
+    pip install git+https://github.com/macromeer/napari-tmidas.git
+
+
+## Contributing
+
+Contributions are very welcome. Tests can be run with [tox], please ensure
+the coverage at least stays the same before you submit a pull request.
+
+## License
+
+Distributed under the terms of the [BSD-3] license,
+"napari-tmidas" is free and open source software
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+[napari]: https://github.com/napari/napari
+[copier]: https://copier.readthedocs.io/en/stable/
+[@napari]: https://github.com/napari
+[MIT]: http://opensource.org/licenses/MIT
+[BSD-3]: http://opensource.org/licenses/BSD-3-Clause
+[GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
+[GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
+[Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
+[Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
+[napari-plugin-template]: https://github.com/napari/napari-plugin-template
+
+[file an issue]: https://github.com/macromeer/napari-tmidas/issues
+
+[napari]: https://github.com/napari/napari
+[tox]: https://tox.readthedocs.io/en/latest/
+[pip]: https://pypi.org/project/pip/
+[PyPI]: https://pypi.org/

napari_tmidas-0.1.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+napari_tmidas/__init__.py,sha256=cVpVT4zJ5I9N6YFige0iySIMW3JzE35KKnEy-PFpFx0,592
+napari_tmidas/_reader.py,sha256=A9_hdDxtVkVGmbOsbqgnARCSvpEh7GGPo7ylzmbnu8o,2485
+napari_tmidas/_sample_data.py,sha256=khuv1jemz_fCjqNwEKMFf83Ju0EN4S89IKydsUMmUxw,645
+napari_tmidas/_version.py,sha256=Mmxse1R0ki5tjz9qzU8AQyqUsLt8nTyCAbYQp8R87PU,511
+napari_tmidas/_widget.py,sha256=u9uf9WILAwZg_InhFyjWInY4ej1TV1a59dR8Fe3vNF8,4794
+napari_tmidas/_writer.py,sha256=wbVfHFjjHdybSg37VR4lVmL-kdCkDZsUPDJ66AVLaFQ,1941
+napari_tmidas/napari.yaml,sha256=XRz2siVLEciSqUHv1tlLjX9BB0Sc1jBRB3KyAN2ISgA,2276
+napari_tmidas/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+napari_tmidas/_tests/test_reader.py,sha256=gN_2StATLZYUL56X27ImJTVru_qSoFiY4vtgajcx3H0,975
+napari_tmidas/_tests/test_sample_data.py,sha256=D1HU_C3hWpO3mlSW_7Z94xaYHDtxz0XUrMjQoYop9Ag,104
+napari_tmidas/_tests/test_widget.py,sha256=I_d-Cra_CTcS0QdMItg_HMphvhj0XCx81JnFyCHk9lg,2204
+napari_tmidas/_tests/test_writer.py,sha256=4_MlZM9a5So74J16_4tIOJc6pwTOw9R0-oAE_YioIx4,122
+napari_tmidas-0.1.1.dist-info/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
+napari_tmidas-0.1.1.dist-info/METADATA,sha256=TuiFctic_XaF8TxYPQYuLJOlVTKiF_Qxl0Lh6SiYBb4,5850
+napari_tmidas-0.1.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+napari_tmidas-0.1.1.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
+napari_tmidas-0.1.1.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
+napari_tmidas-0.1.1.dist-info/RECORD,,

napari_tmidas-0.1.1.dist-info/WHEEL

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

napari_tmidas-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+napari-tmidas = napari_tmidas:napari.yaml

napari_tmidas-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+napari_tmidas