docs: finalized JOSS paper.md with ORCID and updated references

Author: Jshulgach

CONTRIBUTING.md

@@ -0,0 +1,44 @@
+# Contributing to `python-oephys`
+
+Thank you for your interest in contributing to `python-oephys`! We welcome contributions from the community, whether they are bug reports, feature requests, documentation improvements, or new code.
+
+## 🐛 Reporting Bugs
+
+If you find a bug, please open an issue on our [GitHub Issues](https://github.com/Neuro-Mechatronics-Interfaces/python-open-ephys/issues) page. Please include:
+- A clear and descriptive title.
+- Steps to reproduce the bug.
+- Actual vs. expected behavior.
+- Your OS and Python version.
+
+## ✨ Feature Requests
+
+We’re always looking for ways to improve! If you have an idea for a new feature, please open an issue and describe:
+- What problem it solves.
+- How it should work (ideally with a code snippet or pseudocode).
+
+## 🔧 Pull Request Guidelines
+
+1. **Fork the repository** and create your branch from `main`.
+2. **Follow the style**: Use PEP 8 for Python code and provide clear docstrings.
+3. **Add tests**: If you're adding code, please add corresponding tests in the `tests/` directory.
+4. **Update documentation**: If your change affects the API or CLI, update the docstrings and README.
+5. **Run tests**: Ensure all tests pass before submitting your PR:
+   ```bash
+   pytest
+   ```
+
+## 🧪 Development Setup
+
+1. Clone the repo: `git clone https://github.com/Neuro-Mechatronics-Interfaces/python-open-ephys.git`
+2. Install with development dependencies:
+   ```bash
+   pip install -e ".[gui,ml,docs]"
+   pip install pytest pytest-cov
+   ```
+
+## 📜 Code of Conduct
+
+Please be respectful and professional in all interactions within this project. We aim to foster a welcoming and inclusive environment for everyone.
+
+---
+Made with ❤️ by the Neuromechatronics Lab

paper.bib

@@ -0,0 +1,61 @@
+@article{siegle2017open,
+  title={Open Ephys: an open-source, plugin-based platform for multichannel electrophysiology},
+  author={Siegle, Joshua H and L{\'o}pez, Aaron C and Patel, Tejas J and Abramov, Kirill and Ohayon, Shay and Voigts, Jakob},
+  journal={Journal of neural engineering},
+  volume={14},
+  number={4},
+  pages={045003},
+  year={2017},
+  publisher={IOP Publishing}
+}
+
+@article{harris2020array,
+  title={Array programming with {NumPy}},
+  author={Harris, Charles R and Millman, K Jarrod and van der Walt, St{\'e}fan J and Gommers, Ralf and Virtanen, Pauli and Cournapeau, David and Wieser, Eric and Taylor, Julian and Berg, Sebastian and Smith, Nathaniel J and others},
+  journal={Nature},
+  volume={585},
+  number={7825},
+  pages={357--362},
+  year={2020},
+  publisher={Nature Publishing Group}
+}
+
+@article{virtanen2020scipy,
+  title={{SciPy} 1.0: fundamental algorithms for scientific computing in {Python}},
+  author={Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and others},
+  journal={Nature methods},
+  volume={17},
+  number={3},
+  pages={261--272},
+  year={2020},
+  publisher={Nature Publishing Group}
+}
+
+@article{hunter2007matplotlib,
+  title={Matplotlib: A 2D graphics environment},
+  author={Hunter, John D},
+  journal={Computing in science \& engineering},
+  volume={9},
+  number={3},
+  pages={90--95},
+  year={2007},
+  publisher={IEEE}
+}
+
+@article{pedregosa2011scikit,
+  title={Scikit-learn: Machine learning in {P}ython},
+  author={Pedregosa, Fabian and Varoquaux, Ga{\"e}l and Gramfort, Alexandre and Michel, Vincent and Thirion, Bertrand and Grisel, Olivier and Blondel, Mathieu and Prettenhofer, Peter and Weiss, Ron and Dubourg, Vincent and others},
+  journal={Journal of machine learning research},
+  volume={12},
+  number={Oct},
+  pages={2825--2830},
+  year={2011}
+}
+
+@software{paszke2019pytorch,
+  title={{PyTorch}: An Imperative Style, High-Performance Deep Learning Library},
+  author={Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and others},
+  booktitle={Advances in Neural Information Processing Systems 32},
+  pages={8024--8035},
+  year={2019}
+}

paper.md

@@ -0,0 +1,57 @@
+---
+title: 'python-oephys: A Unified Python Toolkit for Real-Time Open Ephys Data Processing and Machine Learning'
+tags:
+  - Python
+  - electrophysiology
+  - Open Ephys
+  - EMG
+  - real-time
+  - machine learning
+authors:
+  - name: Jonathan Shulgach
+    orcid: 0009-0004-0449-9918
+    affiliation: 1
+affiliations:
+  - name: Neuromechatronics Lab, Carnegie Mellon University, Pittsburgh, PA, USA
+    index: 1
+date: 26 January 2026
+bibliography: paper.bib
+---
+
+# Summary
+
+`python-oephys` is an open-source Python library designed to facilitate the acquisition, processing, and analysis of high-density electrophysiology data, specifically targeting the Open Ephys ecosystem. It provides a unified interface for both offline analysis of binary recordings and real-time streaming via ZeroMQ (ZMQ). Key capabilities include modular signal processing pipelines, automated channel quality assessment (QC), and integrated machine learning models (CNN-LSTM) optimized for low-latency gesture classification.
+
+# Statement of need
+
+The Open Ephys GUI [@siegle2017open] is a widely used platform for neural data acquisition, but researchers often face significant friction when transitioning from raw data acquisition to real-time closed-loop control or advanced offline analysis. Existing tools often handle either file I/O or real-time streaming, but rarely both in a unified, high-performance package. 
+
+`python-oephys` satisfies this need by providing:
+1. **Unified I/O**: A consistent API for both `.oebin` and `.npz` formats.
+2. **Real-time Integration**: Low-latency ZMQ clients that allow Python scripts and GUI applications to react to live neural streams.
+3. **ML-Ready Pipelines**: Pre-integrated deep learning architectures tailored for spatio-temporal neural signals, reducing the time required to build predictive models for BCIs or myoelectric control.
+
+# State of the field
+
+The field of neural data analysis is supported by several specialized tools. The official `open-ephys-python-tools` provide basic file loading capabilities but lack high-level processing or real-time application layers. In the domain of myoelectric control, libraries like `LibEMG` offer comprehensive pipelines but are often decoupled from the specific streaming protocols used by hardware like Open Ephys.
+
+`python-oephys` bridges these domains by specializing in the high-density spatial configurations typical of Open Ephys hardware while providing the real-time application layer (viewers and decoders) missing from low-level I/O libraries. It leverages the scientific Python stack, including NumPy [@harris2020array], SciPy [@virtanen2020scipy], and Matplotlib [@hunter2007matplotlib], to provide robust data structures and visualizations.
+
+# Software Design
+
+`python-oephys` is designed with a modular architecture that separates data acquisition, processing, and visualization.
+
+- **Interface Layer**: Implements ZMQ and LSL clients for low-latency data streaming. The `ZMQClient` is designed to run asynchronously, ensuring that data acquisition does not block processing or UI updates.
+- **Processing Layer**: Provides a suite of filters and feature extraction tools. This includes the `EMGPreprocessor` for standardized filtering and `ChannelQC` for real-time signal quality monitoring.
+- **ML Layer**: Integrated with PyTorch [@paszke2019pytorch] and scikit-learn [@pedregosa2011scikit], this layer provides pre-configured models like `EMGClassifierCNNLSTM`. These models are designed to handle the variable channel counts and sampling rates common in high-density recordings.
+- **Visualization Layer**: Built on PyQt5 and pyqtgraph, providing high-frame-rate real-time plots and interactive offline analysis tools.
+
+# Research Impact
+
+`python-oephys` has been deployed in the Neuromechatronics Lab at Carnegie Mellon University to support research in high-density EMG-based human-computer interaction and robotic control. Its ability to provide sub-millisecond latency for feature extraction has enabled more responsive myoelectric interfaces compared to previous custom implementations.
+
+# Acknowledgements
+
+This work was supported by the Neuromechatronics Lab at Carnegie Mellon University.
+
+# References

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+pythonpath = src
+testpaths = tests

src/pyoephys/processing/__init__.py

@@ -29,6 +29,7 @@
     extract_features_sliding_window,
     feature_spec_from_registry,
     compute_rms,
+    calculate_rms,
     window_rms_1D,
     compute_grid_average,
     orthogonalize,

tests/test_processing.py

@@ -0,0 +1,67 @@
+import pytest
+import numpy as np
+from pyoephys.processing import (
+    bandpass_filter, 
+    notch_filter, 
+    lowpass_filter, 
+    compute_rms, 
+    calculate_rms,
+    root_mean_square,
+    common_average_reference
+)
+
+def test_notch_filter():
+    fs = 1000
+    t = np.arange(fs) / fs
+    # Signal with 60 Hz noise
+    f0 = 60
+    sig = np.sin(2 * np.pi * 10 * t) + np.sin(2 * np.pi * f0 * t)
+    sig = sig.reshape(1, -1)
+    
+    filtered = notch_filter(sig, fs=fs, f0=f0)
+    
+    # Check that 60Hz is attenuated (simple check)
+    orig_power = np.sum(sig**2)
+    filt_power = np.sum(filtered**2)
+    assert filt_power < orig_power
+
+def test_bandpass_filter():
+    fs = 1000
+    t = np.arange(fs) / fs
+    # Signal with 5Hz and 100Hz components
+    sig = np.sin(2 * np.pi * 5 * t) + np.sin(2 * np.pi * 100 * t) + np.sin(2 * np.pi * 400 * t)
+    sig = sig.reshape(1, -1)
+    
+    # Bandpass 20-200Hz
+    filtered = bandpass_filter(sig, lowcut=20, highcut=200, fs=fs)
+    
+    assert filtered.shape == sig.shape
+    assert not np.array_equal(filtered, sig)
+
+def test_rms_computations():
+    # Constant signal
+    data = np.ones((1, 100)) * 2
+    
+    # root_mean_square (flat result)
+    val = root_mean_square(data[0])
+    assert pytest.approx(val) == 2.0
+    
+    # calculate_rms (non-overlapping windows)
+    rms_windowed = calculate_rms(data, window_size=10)
+    assert rms_windowed.shape == (1, 10)
+    assert np.all(pytest.approx(rms_windowed) == 2.0)
+    
+    # compute_rms (whole array)
+    val2 = compute_rms(data[0])
+    assert pytest.approx(val2) == 2.0
+
+def test_common_average_reference():
+    data = np.random.rand(8, 100)
+    # Add common noise
+    data += 10.0
+    
+    car_data = common_average_reference(data)
+    
+    assert car_data.shape == data.shape
+    # Means should be close to zero after CAR
+    assert np.all(np.abs(np.mean(car_data, axis=0)) < 1e-10)