fmatoolbox 0.1.2__tar.gz → 0.1.3__tar.gz

{fmatoolbox-0.1.2/src/fmatoolbox.egg-info → fmatoolbox-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmatoolbox
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python port of FMAToolbox
 Author: Pietro Bozzo
 License-Expression: GPL-3.0-or-later

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fmatoolbox"
-version = "0.1.2"
+version = "0.1.3"
 description = "Python port of FMAToolbox"
 authors = [{name = "Pietro Bozzo"}]
 readme = "README.md"

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/src/fmatoolbox/analysis.py

@@ -12,7 +12,7 @@ from typing import Callable
 
 
 def istantaneousRate(samples, start:float=None, stop:float=None, bin:float=None, step:int=None, smooth:float=None, g_range:tuple[int,int]=None):
-    '''
+    """
     estimate the istantaneous rate of a point process from a realization of its time stamps, e.g., the firing rate from spike times
 
     arguments:
@@ -27,7 +27,7 @@ def istantaneousRate(samples, start:float=None, stop:float=None, bin:float=None,
 
     output:
         rate        (:,g+1) float, every row is [time stamp, rates for g processes], g is 1 if 'samples' has just one column
-    '''
+    """
 
     # validate input
     samples = np.asarray(samples)
@@ -78,11 +78,11 @@ def istantaneousRate(samples, start:float=None, stop:float=None, bin:float=None,
         rate = np.array(rate).T / bin
 
     # make time axis
-    t = bin/step/2 + np.linspace(0,(n_bins-1)*bin,n_bins*step)
+    t = start + bin/step/2 + np.linspace(0,(n_bins-1)*bin,n_bins*step)
 
     # apply smoothing
     if smooth is not None:
-        firing_rate = sp.ndimage.gaussian_filter(firing_rate,smooth,axes=0)
+        rate = sp.ndimage.gaussian_filter(rate,smooth,axes=0)
 
     return np.column_stack((t,rate))
 

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/src/fmatoolbox/data.py

@@ -1,5 +1,5 @@
-''' Session data handling functions for FMAToolbox '''
-from typing import Any, Callable
+''' Functions to load data for a recording session '''
+
 import pathlib
 import scipy.io
 import numpy as np
@@ -10,27 +10,32 @@ import re
 import fmatoolbox.exceptions
 import collections
 import concurrent.futures
-
-
-def loadSpikeTimes(session:str, output:str='dict', anat_file:str=None, return_elec:bool=False, return_loc:bool=False, reload:bool=False):
-    # load spikes from a session
-    #
-    # arguments:
-    #     session         string, path to session .xml file, spike files must be in session folder
-    #     output          string = None, determines output type, can be:
-    #                       'dict', dictionary of spike times per unit
-    #                       'compact', (:,2) array of [timestamps, unit ids]
-    #                       'full', (:,2) array of [timestamps, electrode groups, clusters]
-    #                       'regions', dict of {region id: dict}, entries are {'spikes': region spikes, 'units': region units}
-    #     anat_file        str = None, DESCRIBE
-    #     return_elec      bool = False, if true, return cluster_loc
-    #     return_loc       bool = False, if true, return cluster_loc
-    #     reload           bool = False, load original files, bypassing Regions/<basename>_spikes.npz backup (for 'output' = 'regions')
-    #
-    # output:
-    #     spikes          (see 'output')
-    #     electrodes      (n) float, optional, electrode id per unit
-    #     cluster_loc     (n) float, optional, index of max spike-amplitude cluster per unit
+import xml.etree.ElementTree
+from typing import Any, Callable
+from os import PathLike
+
+
+def loadSpikeTimes(session:str|PathLike[str], output:str='dict', anat_file:str=None, return_elec:bool=False, return_loc:bool=False, reload:bool=False):
+    """
+    load spikes for a session
+
+    arguments:
+        session        file, path to session .xml file, spike files must be in session folder
+        output         string = None, determines output type, either:
+                        - 'dict', dictionary of spike times per unit
+                        - 'compact', (:,2) array of [timestamps, unit ids]
+                        - 'full', (:,2) array of [timestamps, electrode groups, clusters]
+                        - 'regions', dict of {region id: dict}, entries are {'spikes': region spikes, 'units': region units}
+        anat_file      str = None, DESCRIBE
+        return_elec    bool = False, if true, return cluster_loc
+        return_loc     bool = False, if true, return cluster_loc
+        reload         bool = False, load original files, bypassing Regions/<basename>_spikes.npz backup (for 'output' = 'regions')
+
+    output:
+        spikes         (see 'output')
+        electrodes     (n) float, optional, electrode id per unit
+        cluster_loc    (n) float, optional, index of max spike-amplitude cluster per unit
+    """
 
     file_root = pathlib.Path(session).with_suffix('')
     cell_metrics_file = file_root.with_suffix('.cell_metrics.cellinfo.mat')
@@ -50,7 +55,7 @@ def loadSpikeTimes(session:str, output:str='dict', anat_file:str=None, return_el
     return out[:2+return_loc:2-return_elec]
 
 
-def loadCellMetricsFile(session:str, output:str='dict', anat_file:str=None, return_extra:bool=False, reload:bool=False):
+def loadCellMetricsFile(session:str|PathLike[str], output:str='dict', anat_file:str=None, return_extra:bool=False, reload:bool=False):
 
     file_root = pathlib.Path(session).with_suffix('')
 
@@ -92,7 +97,7 @@ def loadCellMetricsFile(session:str, output:str='dict', anat_file:str=None, retu
             if anat_file is None:
                 raise ValueError("'anat_file' must be provided when 'output' = 'regions'")
             anat = loadAnatomyFile(anat_file)
-            anat = anat[anat['rat'] == int(file_root.stem[3:6])]  # keep rat of interest, deduced from file name
+            anat = anat[anat['rat'] == int(file_root.stem[3:6])] # keep rat of interest, deduced from file name
             ids = np.unique(anat['region'])
             spikes = {str(id): {} for id in ids}
             for id in ids:
@@ -108,7 +113,7 @@ def loadCellMetricsFile(session:str, output:str='dict', anat_file:str=None, retu
                     s = np.concatenate(s)
                     spikes[id]['spikes'] = s[s[:,0].argsort()]
                 else:
-                    spikes[id]['spikes'] = np.array(s,ndmin=2)
+                    spikes[id]['spikes'] = np.empty((0,2))
             # save
             saveRegionSpikes(spike_file,spikes)
 
@@ -120,13 +125,19 @@ def loadCellMetricsFile(session:str, output:str='dict', anat_file:str=None, retu
     return spikes
 
 
-def loadCluFiles(session:str, rate:float=20000, output:str='dict', anat_file:str=None, reload:bool=False):
+def loadCluFiles(session:str|PathLike[str], rate:float=None, output:str='dict', anat_file:str=None, reload:bool=False):
 
     if output not in ['dict','compact','full','regions']:
         raise ValueError("'output' must be 'dict', 'compact', 'full', or 'regions'")
 
-    # load .res and .clu files
+    # load parameters n_channels from .xml
     froot = pathlib.Path(session).with_suffix('')
+    if rate is None:
+        tree = xml.etree.ElementTree.parse(froot.with_suffix(".xml"))
+        root = tree.getroot()
+        rate = float(root.find(".//samplingRate").text)
+
+    # load .res and .clu files
     res_files = {int(p.name[len(froot.name)+5:]): p for p in froot.parent.iterdir()
                  if p.is_file() and p.name.startswith(froot.name + '.res.') and p.name[len(froot.name)+5:].isdigit()}
     clu_files = {int(p.name[len(froot.name)+5:]): p for p in froot.parent.iterdir()
@@ -203,7 +214,7 @@ def loadCluFiles(session:str, rate:float=20000, output:str='dict', anat_file:str
     return spikes
 
 
-def loadAnatomyFile(file_path):
+def loadAnatomyFile(file_path:str|PathLike[str]):
     # load .anat file, whose columns must be [rat, electrode, brain region] (comma separated)
     #
     # arguments:
@@ -212,7 +223,7 @@ def loadAnatomyFile(file_path):
     return np.genfromtxt(file_path,delimiter=",",comments="%",dtype=[("rat",int),("electrode",int),("region","U50")])
 
 
-def loadRegionSpikes(file):
+def loadRegionSpikes(file:str|PathLike[str]):
     spike_npz = np.load(file)
     spikes = {r[3:]: {'spikes': spike_npz[r]} for r in spike_npz.files if r.startswith('sp_')}
     for reg in spikes:
@@ -221,7 +232,7 @@ def loadRegionSpikes(file):
     return spikes
 
 
-def saveRegionSpikes(file,spikes):
+def saveRegionSpikes(file:str|PathLike[str], spikes):
     file = pathlib.Path(file)
     if not file.parent.exists():
         pathlib.Path.mkdir(file.parent)
@@ -231,7 +242,7 @@ def saveRegionSpikes(file,spikes):
     return
 
 
-def loadEventFile(filename: str, compact: bool = False):
+def loadEventFile(filename:str|PathLike[str], compact:bool=False):
     # load events from a .evt file
     #
     # arguments:
@@ -289,8 +300,8 @@ def loadEventFile(filename: str, compact: bool = False):
     return events
 
 
-def loadEvents(session:str, extra:str|list[str]):
-    # load event files from a session
+def loadEvents(session:str|PathLike[str], extra:str|list[str]):
+    # load event files for a session
     #
     # arguments:
     #     session      string, path to session .xml file, event files must be in session folder
@@ -340,7 +351,7 @@ def loadEvents(session:str, extra:str|list[str]):
     return events, cat_names
 
 
-def loadSpikeWaveforms(session: str):
+def loadSpikeWaveforms(session:str|PathLike[str]):
 
     file_root = pathlib.Path(session).with_suffix('')
     data = scipy.io.loadmat(file_root.with_suffix('.cell_metrics.cellinfo.mat'),simplify_cells=True)['cell_metrics']
@@ -351,7 +362,87 @@ def loadSpikeWaveforms(session: str):
     return
 
 
-def loadLFP(session: str):
+def loadWideband(session:str|PathLike[str], dtype=None, channels=None, intervals=None, skip=None, cat=None):
+    """
+    load wideband data for a session, which is organized in records: chunks of data containing one sample for each channel
+
+    arguments:
+        session      file, path to session .xml file, spike files must be in session folder
+        dtype        type = np.int16
+        channels     (:,) int = None, channels to load, if None, load all channels; counted base 0 as NeuroScope
+        intervals    (:,2) float = None, time intervals to load, if None, load all data
+        skip         int = 0, number of records to skip after each record is read (to subsample data)
+        cat          bool = True, concatenate loaded data into a single array; if False, return a list of arrays for each interval
+
+    output:
+        data         (records, channels) dtype, data for each channel, each row is a record
+        t            (records,) float, time of each record (not stacked as first column of 'data' to preserve data types)
+    """
+
+    file_root = pathlib.Path(session).with_suffix("")
+    dat_file = file_root.with_suffix(".dat")
+
+    # load parameters n_channels from .xml
+    tree = xml.etree.ElementTree.parse(file_root.with_suffix(".xml"))
+    root = tree.getroot()
+    frequency = float(root.find(".//samplingRate").text)
+    n_channels = int(root.find(".//nChannels").text)
+
+    if dtype is None: dtype = np.int16
+    if skip is None: skip = 0
+    if intervals is None: intervals = [[0,np.inf]]
+    intervals = np.array(intervals,ndmin=2)
+
+    sample_size = np.dtype(dtype).itemsize
+    file_size = dat_file.stat().st_size
+    results = []
+    t = []
+    with open(dat_file,'rb') as f:
+        for start, stop in intervals:
+
+            # locate 'start' in file
+            record_offset = int(np.floor(start * frequency))
+            byte_offset = record_offset * n_channels * sample_size
+            f.seek(byte_offset)
+
+            # copute number of records to read
+            if np.isinf(stop):
+                remaining_bytes = file_size - byte_offset
+                n_records = remaining_bytes // (n_channels * sample_size)
+            else:
+                n_records = int(np.floor((stop-start) * frequency))
+            max_records = (file_size - byte_offset) // (n_channels * sample_size)
+            n_records = min(n_records,max_records)
+
+            raw = np.fromfile(f,dtype=dtype,count=n_records*n_channels).reshape((-1,n_channels))
+            if raw.size == 0:
+                break
+
+            # select requested channels
+            if channels is not None:
+                raw = raw[:,channels]
+            # apply skipping
+            if skip > 0:
+                raw = raw[::skip+1]
+
+            results.append(raw)
+            t.append(np.linspace(start, start+raw.shape[0]/frequency, raw.shape[0]))
+
+    # handle empty output
+    if len(results) == 0:
+        if channels is None: channels = np.arange(n_channels)
+        results = [np.empty((0,len(channels)),dtype=dtype)]
+        t = [np.empty(0)]
+
+    # concatenate results from intervals
+    if cat:
+        results = np.vstack(results)
+        t = np.concatenate(t)
+
+    return results, t
+
+
+def loadLFP(session:str|PathLike[str]):
 
     print('implement!')
 
@@ -365,9 +456,36 @@ def saveMatrix():
 
     return
 
+
+def printXML(session:str|PathLike[str]):
+    """
+    simple utility to print contents of a session's .xml file
+    """
+
+    def print_xml(element,level=0):
+        indent = "  " * level
+        # print tag and attributes
+        print(f"{indent}{element.tag}",end="")
+        if element.attrib:
+            print(f" {element.attrib}",end="")
+        # print text if present
+        text = element.text.strip() if element.text else ""
+        if text:
+            print(f" -> {text}",end="")
+        print()
+        # recurse into children
+        for child in element:
+            print_xml(child,level+1)
+
+    tree = xml.etree.ElementTree.parse(pathlib.Path(session).with_suffix(".xml"))
+    root = tree.getroot()
+    print_xml(root)
+
+    return
+
 # functions to run batch
 
-def readBatchFile(file_path: str):
+def readBatchFile(file_path:str|PathLike[str]):
     # read batch file
     #
     # arguments:
@@ -425,7 +543,7 @@ def _batchWorker(payload):
         return -i-1, e
 
 
-def runBatch(batch_file:str, func:Callable, args:list[list[Any]]=None, rnd_seed:str=None, kwargs:dict|list[dict]=None, ignore_args:bool=False,
+def runBatch(batch_file:str|PathLike[str], func:Callable, args:list[list[Any]]=None, rnd_seed:str=None, kwargs:dict|list[dict]=None, ignore_args:bool=False,
              sessions:list[int]=None, parallel:bool|int=False, verbose:bool=True) -> tuple[list, ...]:
     # run a routine on multiple sessions
     #

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/src/fmatoolbox/general.py

@@ -154,12 +154,9 @@ def restrict(samples, intervals, shift:bool=False, s_ind:bool=False, i_ind:bool=
     #     samples      (p,m) float, restricted samples, i. e., rows of 'samples' whose first element falls into 'intervals'
     #     Is           (n) bool, optional, indicese of original samples which were kept
     #     Ii           (n) bool, optional, indicese of intervals which contain kept samples
-
-    samples = np.asarray(samples)
-    if samples.size == 0:
-        samples = np.array([])
     
     # promote 1d arrays to 2d
+    samples = np.asarray(samples)
     squeeze = samples.ndim == 1
     if squeeze:
         samples = samples.reshape((-1,1))

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/src/fmatoolbox/plotting.py

@@ -10,6 +10,7 @@ import scipy.stats as spst
 import scipy as sp
 from collections.abc import Iterable
 from typing import Literal, Callable
+import matplotlib as mpl
 
 
 def adjustAxes(axs:mpla.Axes|Iterable[mpla.Axes], format:Literal['paper','poster']='paper'):
@@ -26,8 +27,11 @@ def adjustAxes(axs:mpla.Axes|Iterable[mpla.Axes], format:Literal['paper','poster
 
     lw = 1 if format == 'paper' else 2
     axw = 1.3 if format == 'paper' else 2.1
-    axtick = 9 if format == 'paper' else 14
-    axfont = 10 if format == 'paper' else 18
+    ax_label_fs = 9 if format == 'paper' else 18
+    ax_label_pad = 0.1 if format == 'paper' else 1
+    ax_tick_fs = 8 if format == 'paper' else 14
+    ax_tick_l = 2 if format == 'paper' else 5
+    ax_tick_pad = 1 if format == 'paper' else 2
 
     for ax in axs:
         
@@ -36,9 +40,11 @@ def adjustAxes(axs:mpla.Axes|Iterable[mpla.Axes], format:Literal['paper','poster
 
         # adjust thickness and font size
         [ax.spines[spine].set_linewidth(lw) for spine in ['bottom','left','polar'] if spine in ax.spines]
-        ax.tick_params(width=axw,labelsize=axtick)
-        ax.xaxis.label.set_fontsize(axfont)
-        ax.yaxis.label.set_fontsize(axfont)
+        ax.tick_params(width=axw,labelsize=ax_tick_fs,pad=ax_tick_pad,length=ax_tick_l)
+        ax.xaxis.label.set_fontsize(ax_label_fs)
+        ax.yaxis.label.set_fontsize(ax_label_fs)
+        ax.xaxis.labelpad = ax_label_pad
+        ax.yaxis.labelpad = ax_label_pad
 
     return
 
@@ -432,17 +438,17 @@ def plotIntervals(intervals, alpha=0.3, color:mplt.ColorType='gray', ax:mpla.Axe
         ax.axvspan(start,stop,alpha=alpha,color=color)
 
 
-def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points:int=None, norm=None, color:mplt.ColorType=None, label=None, ax:mpla.Axes=None, **plot_kwargs):
+def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points:int=None, bins=None, norm=None, color:mplt.ColorType=None, label=None, ax:mpla.Axes=None, **plot_kwargs):
     '''
     estimate and plot probability density function (PDF) of data
 
     arguments:
         x            (n,) tuple | array, data to plot
         mode         str = {'normal','log','polar'}, DESCRIBE
-        log          bool = False, plot log-transformed PDF, DEPRECATED
         bandwidth    float | str = 'scott', bandwidth for gaussian kernel
         eps          float = 1e-12, small value used to avoid log(0)
         n_points     int = 50, number of points used to evaluate PDF
+        bins         (:,) float = None, bin edges, if None, bins are linearly spaced between min and max of x
         norm         str = {'density','max'}, normalization mode, 'density' computes PDF, 'max' normalizes its maximum to 1
         color        color = None, line color
         label        str = None, legend label for line
@@ -452,14 +458,14 @@ def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points
     if mode is None: mode = 'normal'
     if bandwidth is None: bandwidth = 0.05 if mode == 'polar' else 'scott'
     if eps is None: eps = 1e-12
-    if n_points is None: n_points = 50
+    if n_points is None and bins is None: n_points = 50
     if norm is None: norm = 'density'
     if ax is None: ax = plt.gca()
     if isinstance(x,tuple):
-        if color is None:
-            color = [None] * len(x)
-        if label is None:
-            label = [None] * len(x)
+        if color is None or isinstance(color,str):
+            color = [color] * len(x)
+        if label is None or isinstance(label,str):
+            label = [label] * len(x)
     else:
         x = (x,)
         color = [color]
@@ -481,7 +487,10 @@ def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points
         match mode:
             # 1. real-valued data using gaussian kernel density estimator
             case 'normal':
-                this_grid = np.linspace(data.min(),data.max(),n_points) # linear grid
+                if n_points is None:
+                    this_grid = bins
+                else:
+                    this_grid = np.linspace(data.min(),data.max(),n_points) # linear grid
                 kde = sp.stats.gaussian_kde(data,bw_method=bandwidth)
                 this_density = kde(this_grid)
                 if norm == 'max':
@@ -493,7 +502,10 @@ def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points
                 if data.min() <= 0:
                     raise ValueError('log-transforming data requires positive values')
                 data = np.log(data + eps) # log-transform data
-                this_grid = np.linspace(data.min(),data.max(),n_points) # linear grid in log-space
+                if n_points is None:
+                    this_grid = bins
+                else:
+                    this_grid = np.linspace(data.min(),data.max(),n_points) # linear grid in log-space
                 jacobian = np.exp(this_grid) # jacobian term to transform density back to linear
                 kde = sp.stats.gaussian_kde(data,bw_method=bandwidth)
                 this_density = kde(this_grid) / jacobian
@@ -504,7 +516,10 @@ def plotPDF(x, mode:str=None, bandwidth:float|str=None, eps:float=None, n_points
             # 3. circular data using von-Mises kernel density estimator
             case 'polar':
                 data = np.mod(data,2*np.pi)
-                this_grid = np.linspace(0,2*np.pi,n_points) # linear grid in [0,2*pi]
+                if n_points is None:
+                    this_grid = bins
+                else:
+                    this_grid = np.linspace(0,2*np.pi,n_points) # linear grid in [0,2*pi]
                 this_density = np.zeros_like(this_grid)
                 for theta in data:
                     this_density += spst.vonmises.pdf(this_grid-theta,1/bandwidth)

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3}/src/fmatoolbox/regions.py

@@ -7,6 +7,7 @@ import re
 import fmatoolbox.analysis
 import fmatoolbox.data
 import warnings
+import xml.etree.ElementTree
 from collections.abc import Iterable
 
 def _regionDataPath():
@@ -34,8 +35,9 @@ class regions:
         #     reload         bool = False, load spikes from original files, bypassing Regions/<basename>_spikes.npz backup
         #     anat_file      string = None, DESCRIBE
 
-        self.session = pathlib.Path(session).parent
-        self.basename = pathlib.Path(session).stem
+        session = pathlib.Path(session)
+        self.session = session.parent
+        self.basename = session.stem
         self.rat = self.basename[3:6]
 
         # 1. load events
@@ -109,13 +111,13 @@ class regions:
             self.region = {}
 
         # 4. load spikes and store them per region
+        if anat_file is None:
+            anat_file = next(_regionDataPath().glob('*.anat'), None)
+        else:
+            anat_file = pathlib.Path(anat_file)
+            if not anat_file.exists():
+                anat_file = _regionDataPath() / anat_file
         if load_spikes:
-            if anat_file is None:
-                anat_file = next(_regionDataPath().glob('*.anat'), None)
-            else:
-                anat_file = pathlib.Path(anat_file)
-                if not anat_file.exists():
-                    anat_file = _regionDataPath() / anat_file
             self.region = fmatoolbox.data.loadSpikeTimes(session,output='regions',anat_file=anat_file,reload=reload)
             if ids:
                 self.region = {r: self.region[r] for r in ids}
@@ -126,6 +128,25 @@ class regions:
                 for id in self.ids:
                     self.region[id]['spikes'] = fmatoolbox.general.restrict(self.region[id]['spikes'],epoch_intervals)
 
+        # 5. load electrode groups and channels per region
+        try:
+            anat = fmatoolbox.data.loadAnatomyFile(anat_file)
+            anat = anat[anat['rat'] == int(self.rat)] # keep rat of interest, deduced from file name
+            anat_ids = np.unique(anat['region'])
+            tree = xml.etree.ElementTree.parse(session.with_suffix(".xml"))
+            root = tree.getroot()
+            channel_groups = root.find(".//channelGroups").findall("group")
+            channel_groups = [[int(element.text) for element in c.findall(".//channel")] for c in channel_groups]
+            if len(self.region):
+                for id in self.ids:
+                    self.region[id]['channels'] = {int(e): channel_groups[e-1] for e in anat[anat['region'] == id]['electrode']}
+            else:
+                self.ids = anat_ids.tolist()
+                for id in self.ids:
+                    self.region[id] = {'channels': {int(e): channel_groups[e-1] for e in anat[anat['region'] == id]['electrode']} }
+        except FileNotFoundError:
+            pass
+
         return
     
 
@@ -166,7 +187,8 @@ class regions:
             regs = regs[np.sort(idx)]
 
         # default: all electrode groups
-        all_e_groups = np.concatenate([list(self.region[r]['e_group'].keys()) for r in self.ids])
+        all_e_groups = [list(self.region[r]['e_group'].keys()) for r in self.ids if 'e_group' in self.region[r]]
+        if len(all_e_groups): all_e_groups = np.concatenate(all_e_groups)
         if np.all(e_groups == None):
             if exclusive and np.any(regs != None):
                 e_groups = np.array([None])
@@ -296,17 +318,36 @@ class regions:
 
 
     def electrodes(self,regs=None):
-        # get pooled list of electrode groups for regions
-        #
-        # arguments:
-        #     regs        (:) string = None, electrode of these regions are returned as an array, default is all regions
-        #
-        # output:
-        #     electrodes       (:) int, sorted by value
+        """
+        get pooled list of electrode groups for regions
+        
+        arguments:
+            regs          (:) string = None, electrode of these regions are returned as an array, default is all regions
+        
+        output:
+            electrodes    (:) int, sorted by value
+        """
 
         regs, _, _ = self._checkIDs(regs=regs)
 
         return np.concatenate([list(self.region[r]['e_group'].keys()) for r in regs])
+    
+
+    def channels(self,regs=None):
+        """
+        get pooled list of recording channels for regions
+        
+        arguments:
+            regs        (:) string = None, channels of these regions are returned as an array, default is all regions
+        
+        output:
+            channels    (:) int
+        """
+
+        regs, _, _ = self._checkIDs(regs=regs)
+        values = [list(self.region[r]['channels'].values()) for r in regs]
+        
+        return np.array([x for outer in values for inner in outer for x in inner])
 
 
     def units(self,regs=None,e_groups=None):
@@ -376,8 +417,8 @@ class regions:
 
     ## functions to compute quantities ##
 
-    def firingRate(self, regs:Iterable[str]=None, e_groups:Iterable[int]=None, states:Iterable[str]=None, when=None, shift=False,
-                   window=None, step=None, smooth=None, norm=False):
+    def firingRate(self, regs:Iterable[str]=None, e_groups:Iterable[int]=None, states:Iterable[str]=None, when=None, shift:bool=None,
+                   window=None, step:int=None, smooth=None, norm:bool=None):
         '''
         get region firing rate
 
@@ -400,8 +441,10 @@ class regions:
 
         if states is not None and when is not None:
             raise ValueError("'states' and 'when' cannot be specified at the same time")
+        if shift is None: shift = False
         if window is None: window = 0.05
         if step is None: step = 1
+        if norm is None: norm = False
 
         regs, e_groups, states = self._checkIDs(regs=regs,e_groups=e_groups,states=states,fuse=True)
 
@@ -450,7 +493,7 @@ class regions:
         return firing_rate
     
 
-    def unitFiringRate(self,regs=None,states=None,when=None,shift=False,window=None,step=None,smooth=None):
+    def unitFiringRate(self, regs=None, states=None, when=None, shift:bool=None, window=None, step:int=None, smooth:bool=None):
         # get units' firing rate
         #
         # arguments:
@@ -468,6 +511,7 @@ class regions:
 
         if states is not None and when is not None:
             raise ValueError("'states' and 'when' cannot be specified at the same time")
+        if shift is None: shift = False
         if window is None: window = 0.05
         if step is None: step = 1
 
@@ -498,7 +542,7 @@ class regions:
         return firing_rate
     
 
-    def avalanches(self,regs=None,states=None,when=None,shift=False,thresh=30,window=0.05,step=1,smooth=None,return_fr=False,norm=False):
+    def avalanches(self, regs=None, states=None, when=None, shift:bool=None, thresh:float=None, window:float=None, step:int=None, smooth:bool=None, norm:bool=None, return_fr:bool=None):
         # compute avalanches per region from population firing rate
         #
         # arguments:
@@ -519,6 +563,9 @@ class regions:
         #     size_t       (m) float, size over time, in which every avalanche is separated by a 0
         #     fr           (:,r+1) float, every row is [time stamp, firing rates for r regions], optional
 
+        if thresh is None: thresh = 30
+        if return_fr is None: return_fr = False
+
         none_state = states is None
         regs, _, states = self._checkIDs(regs=regs,states=states,fuse=True)
         if none_state:

{fmatoolbox-0.1.2 → fmatoolbox-0.1.3/src/fmatoolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmatoolbox
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python port of FMAToolbox
 Author: Pietro Bozzo
 License-Expression: GPL-3.0-or-later