pstutils 0.1.0__tar.gz

pstutils-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include README.md

pstutils-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: pstutils
+Version: 0.1.0
+Summary: This package is internal to Plexon. It includes functions to be used in conjunction with the SiNAPS Data Pipeline.
+Author-email: Nikhil Chandra <nikhil@plexon.com>, Chris Heydrick <chris@plexon.com>
+Requires-Python: >3.9
+Description-Content-Type: text/markdown
+Requires-Dist: phylib==2.4.3
+Requires-Dist: numpy==1.26.4
+Requires-Dist: pypl2
+Requires-Dist: pypixelmapdump
+Requires-Dist: debugpy
+Requires-Dist: wheel
+
+# Introduction
+The pstutils Python package manages an API that exposes functions written for various applications that form a part of the SiNAPS Data Pipeline (e.g., PL2STASH, NPY2NEX)
+
+# Clone repository
+```bash
+mkdir pstutils
+cd 
+git clone git@192.168.37.103:nikhilchandra/pstutils.git .
+```
+
+# Package
+There are a few different options for packaging this project into a .tar.gz file.
+
+## Option 1: Python Virtual Environment
+```bash
+python -m venv venv
+./venv/scripts/activate
+python -m pip install setuptools build
+python -m build
+```
+
+## Option 2: Conda Environment
+```bash
+conda create -n <env_name> python=3.<version #> --yes
+conda activate <env_name>
+python -m pip install build
+python -m build
+```
+
+# Install package to virtual environment
+
+## From .tar.gz
+You can install the package from the .tar.gz file generated in the previous step.
+```bash
+python -m pip install ./dist/<name-of-tar.gz-file>
+```
+
+## From Plexon's private GitLab server
+Alternatively, you can install the package directly from the repository stored on Plexon's GitLab server.
+```bash
+pip install git+http://192.168.37.103/nikhilchandra/pstutils
+```

pstutils-0.1.0/README.md

@@ -0,0 +1,42 @@
+# Introduction
+The pstutils Python package manages an API that exposes functions written for various applications that form a part of the SiNAPS Data Pipeline (e.g., PL2STASH, NPY2NEX)
+
+# Clone repository
+```bash
+mkdir pstutils
+cd 
+git clone git@192.168.37.103:nikhilchandra/pstutils.git .
+```
+
+# Package
+There are a few different options for packaging this project into a .tar.gz file.
+
+## Option 1: Python Virtual Environment
+```bash
+python -m venv venv
+./venv/scripts/activate
+python -m pip install setuptools build
+python -m build
+```
+
+## Option 2: Conda Environment
+```bash
+conda create -n <env_name> python=3.<version #> --yes
+conda activate <env_name>
+python -m pip install build
+python -m build
+```
+
+# Install package to virtual environment
+
+## From .tar.gz
+You can install the package from the .tar.gz file generated in the previous step.
+```bash
+python -m pip install ./dist/<name-of-tar.gz-file>
+```
+
+## From Plexon's private GitLab server
+Alternatively, you can install the package directly from the repository stored on Plexon's GitLab server.
+```bash
+pip install git+http://192.168.37.103/nikhilchandra/pstutils
+```

pstutils-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "pstutils"
+version = "0.1.0"
+authors = [
+    { name="Nikhil Chandra", email="nikhil@plexon.com" },
+    { name="Chris Heydrick", email="chris@plexon.com" },
+]
+description="This package is internal to Plexon. It includes functions to be used in conjunction with the SiNAPS Data Pipeline."
+readme="README.md"
+requires-python=">3.9"
+dependencies = [
+    "phylib==2.4.3",
+    "numpy==1.26.4",
+    "pypl2",
+    "pypixelmapdump",
+    "debugpy",
+    "wheel",
+]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+include-package-data = true
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+"pstutils.maps" = ["*.mat"]
+"*" = ["*.pyd", "pyarmor_runtime_*/*"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["*"]

pstutils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pstutils-0.1.0/src/pstutils/__init__.py

@@ -0,0 +1,13 @@
+from .pstutils import DEBUG
+from .pstutils import extract_wb_data_to_bin
+from .pstutils import extract_pl2_data_to_nex5_stash
+from .pstutils import robocopy
+from .pstutils import archive
+from .pstutils import get_disk_usage
+from .pstutils import build_final_nex5_from_npy_and_pl2
+from .pstutils import build_final_nex5_from_npy_and_stash
+from .pstutils import extract_pl2_headers_to_json
+# from .pstutils import _get_channel_out_of_tune_durations as get_oot_durs
+from .pstutils import get_bad_channels
+from .pstutils import get_probe_names
+from .pstutils import get_unit_id_to_neuron_name_mapping

pstutils-0.1.0/src/pstutils/nex/NexFileData.py

@@ -0,0 +1,278 @@
+"""
+Data classes for .nex and .nex5 files.
+"""
+import numpy as np
+from typing import List
+
+
+def CalcScaleFloatsToShorts(numbers: 'np.ndarray[np.float32]') -> float:
+    """Calculates coefficient that can be used to convert float values to shorts (16-bit integers).
+
+    Args:
+        numbers (np.ndarray[np.float32]): array of float values
+
+    Returns:
+        float: coefficient such that float_value*coefficient is within 16-bit 
+                integer range for all values in array.
+    """
+    theMax = np.amax(numbers)
+    theMin = np.amin(numbers)
+    absMax = max(abs(theMin), abs(theMax))
+    if absMax == 0.0:
+        return 1.0
+    else:
+        return 32767.0 / absMax
+
+
+class Variable:
+    """Base variable class: name only."""
+
+    def __init__(self, name: str = "") -> None:
+        self.Name: str = name
+        """Variable name."""
+
+
+class Event(Variable):
+    """Event class: name and array of timestamps in seconds."""
+
+    def __init__(self, name: str = "", timestamps: List[float] = []) -> None:
+        self.Name: str = name
+        """Variable name."""
+
+        self.Timestamps: 'np.ndarray[np.float64]' = np.asarray(timestamps).astype(np.float64)
+        """Timestamps in seconds."""
+
+    def MaxTimestamp(self) -> float:
+        """Returns maximum timestamp in seconds."""
+        if self.Timestamps is None or len(self.Timestamps) == 0:
+            return 0
+        return self.Timestamps[-1]
+
+
+class Neuron(Event):
+    """
+    Neuron class: event data plus wire, unit and position data.
+    """
+
+    def __init__(self, name: str = "", timestamps: List[float] = []) -> None:
+        self.Name: str = name
+        """Variable name."""
+
+        self.Timestamps: 'np.ndarray[np.float64]' = np.asarray(timestamps).astype(np.float64)
+        """Timestamps in seconds."""
+
+        self.WireNumber: int = 0
+        """Wire (electrode) number."""
+
+        self.UnitNumber: int = 0
+        """Unit or cluster number."""
+
+        self.XPos: float = 0
+        """X axis electrode position in (0,100) range, used in 3D display."""
+
+        self.YPos: float = 0
+        """Y axis electrode position in (0,100) range, used in 3D display."""
+
+
+class Marker(Event):
+    """Markers are events with associated strings or integers."""
+
+    def __init__(self, name: str = "", timestamps: List[float] = [],
+                 fieldNames: List[str] = [], markerValues: List[List[str]] = []) -> None:
+        self.Name: str = name
+        """Variable name."""
+
+        self.Timestamps: 'np.ndarray[np.float64]' = np.asarray(timestamps).astype(np.float64)
+        """Timestamps in seconds."""
+
+        self.FieldNames: List[str] = fieldNames
+        """Each timestamp can have several strings or integers associated with it (several fields). These are filed names."""
+
+        self.MarkerValues: List[List[str]] = markerValues
+        """Each timestamp can have several strings or integers associated with it (several fields).
+        Each sublist contains string values for a specific marker field."""
+
+        self.MarkerValuesAsUnsignedIntegers = [[]]
+        """List of np arrays. Each list element contains numeric values for a specific marker field."""
+
+    def MaxMarkerLength(self):
+        """Returns maximum length of all string marker values."""
+        maxLen = 0
+        if len(self.MarkerValues) > 0:
+            for fieldValues in self.MarkerValues:
+                for m in fieldValues:
+                    maxLen = max(maxLen, len(m))
+            return maxLen
+        else:
+            for fieldValues in self.MarkerValuesAsUnsignedIntegers:
+                for m in fieldValues:
+                    maxLen = max(maxLen, len(str(m)))
+            return maxLen
+
+
+class Interval(Variable):
+    """Interval class. Has two arrays: interval starts and interval ends in seconds."""
+
+    def __init__(self, name: str = "", starts: List[float] = [], ends: List[float] = []) -> None:
+        self.Name: str = name
+        """Variable name."""
+
+        self.IntervalStarts: 'np.ndarray[np.float64]' = np.asarray(starts).astype(np.float64)
+        """Interval start times in seconds."""
+
+        self.IntervalEnds: 'np.ndarray[np.float64]' = np.asarray(ends).astype(np.float64)
+        """Interval end times in seconds."""
+
+    def MaxTimestamp(self) -> float:
+        """Returns maximum timestamp in seconds."""
+        if self.IntervalEnds is None or len(self.IntervalEnds) == 0:
+            return 0
+        return self.IntervalEnds[-1]
+
+
+class Continuous(Variable):
+    """ Continuous class. 
+        Contains: (1) Sampling rate in Hz. (2) Array of timestamps in seconds (each timestamp is for the beginning of the fragment).
+                (3) Array of indexes (each index is the position of the first data point of the fragment in the a/d array).
+                (4) Array of all a/d values in milliVolts.
+    """
+
+    def __init__(self, name: str = "", samplingRate: float = 0, fragmentStarts: List[float] = [],
+                 fragmentStartIndexes: List[int] = [],
+                 values: List[float] = []) -> None:
+        self.Name: str = name
+        """Variable name."""
+
+        self.SamplingRate: float = samplingRate
+        """Sampling rate in Hz."""
+
+        self.FragmentTimestamps: 'np.ndarray[np.float64]' = np.asarray(fragmentStarts).astype(np.float64)
+        """Array of timestamps in seconds (each timestamp is for the beginning of the fragment)."""
+
+        self.FragmentStartIndexes: 'np.ndarray[np.uint32]' = np.asarray(fragmentStartIndexes).astype(np.uint32)
+        """Array of indexes (each index is the position of the first data point of the fragment in the a/d array)."""
+
+        self.Values: 'np.ndarray[np.float32]' = np.asarray(values).astype(np.float32)
+        """Array of all a/d values in milliVolts."""
+
+        self.CalculatedScaleFloatsToShorts = 1
+        """When saving data to .nex file, this field contains coefficient to convert floats to shorts."""
+
+    def MaxTimestamp(self) -> float:
+        """Returns maximum timestamp in seconds (the last timestamp of all continuous values)."""
+        if self.FragmentTimestamps is None or len(self.FragmentTimestamps) == 0 or self.SamplingRate <= 0:
+            return 0
+        if self.FragmentStartIndexes is None or len(self.FragmentStartIndexes) == 0 or self.Values is None or len(self.Values) == 0:
+            return 0
+        step = 1.0/self.SamplingRate
+        return self.FragmentTimestamps[-1] + step * (len(self.Values) - self.FragmentStartIndexes[-1] - 1.0)
+
+
+class Waveform(Event):
+    """ Waveform class. 
+        Contains: Sampling rate in Hz
+                Number of points in each wave
+                Array of timestamps in seconds (each timestamp is for the beginning of the waveform).
+                Array of all waveform a/d values in milliVolts.
+    """
+
+    def __init__(self, name: str = "", samplingRate: float = 0, timestamps: List[float] = [],
+                 numPointsWave: int = 0, values: List[float] = []):
+        self.Name: str = name
+        """Variable name."""
+
+        self.SamplingRate: float = samplingRate
+        """Sampling rate in Hz."""
+
+        self.Timestamps: 'np.ndarray[np.float64]' = np.asarray(timestamps).astype(np.float64)
+        """Timestamps in seconds."""
+
+        self.WireNumber: int = 0
+        """Wire (electrode) number."""
+
+        self.UnitNumber: int = 0
+        """Unit or cluster number."""
+
+        self.NumPointsWave: int = numPointsWave
+        """Number of data point in each wave."""
+
+        self.Values: 'np.ndarray[np.float32]' = np.asarray(values).astype(np.float32)
+        """Waveform values in milliVolts."""
+
+        self.Values = self.Values.reshape((len(self.Timestamps), self.NumPointsWave))
+
+        self.CalculatedScaleFloatsToShorts = 1
+        """When saving data to .nex file, this field contains coefficient to convert floats to shorts."""
+
+    def MaxTimestamp(self) -> float:
+        """Returns maximum timestamp in seconds (the last timestamp of the last waveform)."""
+        if self.Timestamps is None or len(self.Timestamps) == 0 or self.SamplingRate <= 0 or self.NumPointsWave == 0:
+            return 0
+        step = 1.0/self.SamplingRate
+        return self.Timestamps[-1] + step * (self.NumPointsWave - 1.0)
+
+
+class FileData:
+    """
+    FileData object. Contains arrays of data variables.
+    """
+
+    def __init__(self) -> None:
+        self.Comment: str = ""
+        """File comment."""
+
+        self.TimestampFrequency: float = 0
+        """Timestamps frequency, in Hertz. Timestamp values in .net and .nex5 files are stored in ticks, where tick = 1/TimestampFrequency."""
+
+        self.StartTimeSeconds: float = 0
+        """Start time in seconds."""
+
+        self.EndTimeSeconds: float = 0
+        """End time in seconds."""
+
+        self.Events: List[Event] = []
+        """List of Events."""
+
+        self.Neurons: List[Neuron] = []
+        """List of Neurons."""
+
+        self.Intervals: List[Interval] = []
+        """List of intervals."""
+
+        self.Markers: List[Marker] = []
+        """List of Markers."""
+
+        self.Continuous: List[Continuous] = []
+        """List of Continuous variables."""
+
+        self.Waveforms: List[Waveform] = []
+        """List of Waveform variables."""
+
+    def NumberOfVariables(self) -> int:
+        """Returns number of all variables"""
+        return len(self.Neurons) + len(self.Events) + len(self.Intervals) + len(self.Markers) + len(self.Continuous) + len(self.Waveforms)
+
+    def MaxTimestamp(self) -> float:
+        """Returns maximum timestamp of all variables in seconds."""
+        maxTs = 0
+        for v in self.Neurons:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        for v in self.Events:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        for v in self.Intervals:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        for v in self.Markers:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        for v in self.Continuous:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        for v in self.Waveforms:
+            maxTs = max(maxTs, v.MaxTimestamp())
+        return maxTs
+
+    def TicksToSeconds(self, ticks: int) -> float:
+        """Converts time in thicks to time in seconds."""
+        return ticks/self.TimestampFrequency
+
+    def SecondsToTicks(self, seconds: float) -> int:
+        """Converts time in seconds to time in ticks."""
+        return round(seconds * self.TimestampFrequency)