Skip to content

Interface npz

pynapple.io.interface_npz

File classes help to validate and load pynapple objects or NWB files. Data are always lazy-loaded. Both classes behaves like dictionnary.

NPZFile

Bases: object

Class that points to a NPZ file that can be loaded as a pynapple object. Objects have a save function in npz format as well as the Folder class.

Examples:

>>> import pynapple as nap
>>> tsd = nap.load_file("path/to/my_tsd.npz")
>>> tsd
Time (s)
0.0    0
0.1    1
0.2    2
dtype: int64
Source code in pynapple/io/interface_npz.py 
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
class NPZFile(object):
    """Class that points to a NPZ file that can be loaded as a pynapple object.
    Objects have a save function in npz format as well as the Folder class.

    Examples
    --------
    >>> import pynapple as nap
    >>> tsd = nap.load_file("path/to/my_tsd.npz")
    >>> tsd
    Time (s)
    0.0    0
    0.1    1
    0.2    2
    dtype: int64

    """

    def __init__(self, path):
        """Initialization of the NPZ file

        Parameters
        ----------
        path : str
            Valid path to a NPZ file
        """
        self.path = path
        self.name = os.path.basename(path)
        self.file = np.load(self.path, allow_pickle=True)
        self.type = ""

        # First check if type is explicitely defined
        possible = ["Ts", "Tsd", "TsdFrame", "TsdTensor", "TsGroup", "IntervalSet"]
        if "type" in self.file.keys():
            if len(self.file["type"]) == 1:
                if isinstance(self.file["type"][0], np.str_):
                    if self.file["type"] in possible:
                        self.type = self.file["type"][0]

        # Second check manually
        if self.type == "":
            k = set(self.file.keys())
            if {"t", "start", "end", "index"}.issubset(k):
                self.type = "TsGroup"
            elif {"t", "d", "start", "end", "columns"}.issubset(k):
                self.type = "TsdFrame"
            elif {"t", "d", "start", "end"}.issubset(k):
                if self.file["d"].ndim == 1:
                    self.type = "Tsd"
                else:
                    self.type = "TsdTensor"
            elif {"t", "start", "end"}.issubset(k):
                self.type = "Ts"
            elif {"start", "end"}.issubset(k):
                self.type = "IntervalSet"
            else:
                self.type = "npz"

    def load(self):
        """Load the NPZ file

        Returns
        -------
        (Tsd, Ts, TsdFrame, TsdTensor, TsGroup, IntervalSet)
            A pynapple object
        """
        if self.type == "npz":
            return self.file
        else:
            time_support = nap.IntervalSet(self.file["start"], self.file["end"])
            if self.type == "TsGroup":

                times = self.file["t"]
                index = self.file["index"]
                has_data = False
                if "d" in self.file.keys():
                    data = self.file["data"]
                    has_data = True

                if "keys" in self.file.keys():
                    keys = self.file["keys"]
                else:
                    keys = np.unique(index)

                group = {}
                for k in keys:
                    if has_data:
                        group[k] = nap.Tsd(
                            t=times[index == k],
                            d=data[index == k],
                            time_support=time_support,
                        )
                    else:
                        group[k] = nap.Ts(
                            t=times[index == k], time_support=time_support
                        )

                tsgroup = nap.TsGroup(
                    group, time_support=time_support, bypass_check=True
                )

                metainfo = {}
                for k in set(self.file.keys()) - {
                    "start",
                    "end",
                    "t",
                    "index",
                    "d",
                    "rate",
                    "keys",
                }:
                    tmp = self.file[k]
                    if len(tmp) == len(tsgroup):
                        metainfo[k] = tmp
                tsgroup.set_info(**metainfo)
                return tsgroup

            elif self.type == "TsdFrame":
                return nap.TsdFrame(
                    t=self.file["t"],
                    d=self.file["d"],
                    time_support=time_support,
                    columns=self.file["columns"],
                )
            elif self.type == "TsdTensor":
                return nap.TsdTensor(
                    t=self.file["t"], d=self.file["d"], time_support=time_support
                )
            elif self.type == "Tsd":
                return nap.Tsd(
                    t=self.file["t"], d=self.file["d"], time_support=time_support
                )
            elif self.type == "Ts":
                return nap.Ts(t=self.file["t"], time_support=time_support)
            elif self.type == "IntervalSet":
                return time_support
            else:
                return self.file

__init__ 

__init__(path)

Initialization of the NPZ file

Parameters:

Name Type Description Default
path str

Valid path to a NPZ file

 required
Source code in pynapple/io/interface_npz.py 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
def __init__(self, path):
    """Initialization of the NPZ file

    Parameters
    ----------
    path : str
        Valid path to a NPZ file
    """
    self.path = path
    self.name = os.path.basename(path)
    self.file = np.load(self.path, allow_pickle=True)
    self.type = ""

    # First check if type is explicitely defined
    possible = ["Ts", "Tsd", "TsdFrame", "TsdTensor", "TsGroup", "IntervalSet"]
    if "type" in self.file.keys():
        if len(self.file["type"]) == 1:
            if isinstance(self.file["type"][0], np.str_):
                if self.file["type"] in possible:
                    self.type = self.file["type"][0]

    # Second check manually
    if self.type == "":
        k = set(self.file.keys())
        if {"t", "start", "end", "index"}.issubset(k):
            self.type = "TsGroup"
        elif {"t", "d", "start", "end", "columns"}.issubset(k):
            self.type = "TsdFrame"
        elif {"t", "d", "start", "end"}.issubset(k):
            if self.file["d"].ndim == 1:
                self.type = "Tsd"
            else:
                self.type = "TsdTensor"
        elif {"t", "start", "end"}.issubset(k):
            self.type = "Ts"
        elif {"start", "end"}.issubset(k):
            self.type = "IntervalSet"
        else:
            self.type = "npz"

load 

load()

Load the NPZ file

Returns:

Type Description
(Tsd, Ts, TsdFrame, TsdTensor, TsGroup, IntervalSet)

A pynapple object
Source code in pynapple/io/interface_npz.py 
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
def load(self):
    """Load the NPZ file

    Returns
    -------
    (Tsd, Ts, TsdFrame, TsdTensor, TsGroup, IntervalSet)
        A pynapple object
    """
    if self.type == "npz":
        return self.file
    else:
        time_support = nap.IntervalSet(self.file["start"], self.file["end"])
        if self.type == "TsGroup":

            times = self.file["t"]
            index = self.file["index"]
            has_data = False
            if "d" in self.file.keys():
                data = self.file["data"]
                has_data = True

            if "keys" in self.file.keys():
                keys = self.file["keys"]
            else:
                keys = np.unique(index)

            group = {}
            for k in keys:
                if has_data:
                    group[k] = nap.Tsd(
                        t=times[index == k],
                        d=data[index == k],
                        time_support=time_support,
                    )
                else:
                    group[k] = nap.Ts(
                        t=times[index == k], time_support=time_support
                    )

            tsgroup = nap.TsGroup(
                group, time_support=time_support, bypass_check=True
            )

            metainfo = {}
            for k in set(self.file.keys()) - {
                "start",
                "end",
                "t",
                "index",
                "d",
                "rate",
                "keys",
            }:
                tmp = self.file[k]
                if len(tmp) == len(tsgroup):
                    metainfo[k] = tmp
            tsgroup.set_info(**metainfo)
            return tsgroup

        elif self.type == "TsdFrame":
            return nap.TsdFrame(
                t=self.file["t"],
                d=self.file["d"],
                time_support=time_support,
                columns=self.file["columns"],
            )
        elif self.type == "TsdTensor":
            return nap.TsdTensor(
                t=self.file["t"], d=self.file["d"], time_support=time_support
            )
        elif self.type == "Tsd":
            return nap.Tsd(
                t=self.file["t"], d=self.file["d"], time_support=time_support
            )
        elif self.type == "Ts":
            return nap.Ts(t=self.file["t"], time_support=time_support)
        elif self.type == "IntervalSet":
            return time_support
        else:
            return self.file