brukerapi 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

brukerapi/splitters.py

@@ -1,20 +1,21 @@
-from .utils import index_to_slice
-from .dataset import Dataset
-
-import numpy as np
 import copy
+import os
 from pathlib import Path
 
-SUPPORTED_FG = ['FG_ISA','FG_IRMODE','FG_ECHO']
+import numpy as np
 
+from .dataset import Dataset
+from .exceptions import MissingProperty
+from .utils import index_to_slice
 
-class Splitter(object):
+SUPPORTED_FG = ["FG_ISA", "FG_IRMODE", "FG_ECHO"]
 
-    def write(self, datasets, path_out=None):
 
+class Splitter:
+    def write(self, datasets, path_out=None):
         for dataset in datasets:
             if path_out:
-                dataset.write('{}/{}/{}'.format(Path(path_out), dataset.path.parents[0].name, dataset.path.name))
+                dataset.write(f"{Path(path_out)}/{dataset.path.parents[0].name}/{dataset.path.name}")
             else:
                 dataset.write(dataset.path)
 
@@ -37,11 +38,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataMin = visu_pars['VisuCoreDataMin']
-        value = np.reshape(VisuCoreDataMin.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        VisuCoreDataMin = visu_pars["VisuCoreDataMin"]
+        value = np.reshape(VisuCoreDataMin.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataMin.size = (np.prod(value.shape),)
-        VisuCoreDataMin.value = value.flatten(order='F')
+        VisuCoreDataMin.size = (int(np.prod(value.shape)),)
+        VisuCoreDataMin.value = value.flatten(order="F")
 
     def _split_VisuCoreDataMax(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -51,11 +52,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataMax = visu_pars['VisuCoreDataMax']
-        value = np.reshape(VisuCoreDataMax.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        VisuCoreDataMax = visu_pars["VisuCoreDataMax"]
+        value = np.reshape(VisuCoreDataMax.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataMax.size = (np.prod(value.shape),)
-        VisuCoreDataMax.value = value.flatten(order='F')
+        VisuCoreDataMax.size = (int(np.prod(value.shape)),)
+        VisuCoreDataMax.value = value.flatten(order="F")
 
     def _split_VisuCoreDataOffs(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -65,11 +66,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataOffs = visu_pars['VisuCoreDataOffs']
-        value = np.reshape(VisuCoreDataOffs.value, dataset.shape_final[dataset.encoded_dim:],order='F')
+        VisuCoreDataOffs = visu_pars["VisuCoreDataOffs"]
+        value = np.reshape(VisuCoreDataOffs.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataOffs.size = (np.prod(value.shape),)
-        VisuCoreDataOffs.value = value.flatten(order='F')
+        VisuCoreDataOffs.size = (int(np.prod(value.shape)),)
+        VisuCoreDataOffs.value = value.flatten(order="F")
 
     def _split_VisuCoreDataSlope(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -79,34 +80,34 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataSlope = visu_pars['VisuCoreDataSlope']
-        value = np.reshape(VisuCoreDataSlope.value, dataset.shape_final[dataset.encoded_dim:],order='F')
+        VisuCoreDataSlope = visu_pars["VisuCoreDataSlope"]
+        value = np.reshape(VisuCoreDataSlope.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataSlope.size = (np.prod(value.shape),)
-        VisuCoreDataSlope.value = value.flatten(order='F')
+        VisuCoreDataSlope.size = (int(np.prod(value.shape)),)
+        VisuCoreDataSlope.value = value.flatten(order="F")
 
     def _split_VisuCoreTransposition(self, dataset, visu_pars, index, fg_index):
         try:
-            VisuCoreTransposition = visu_pars['VisuCoreTransposition']
+            VisuCoreTransposition = visu_pars["VisuCoreTransposition"]
         except KeyError:
             return VisuCoreTransposition
 
-        value = np.reshape(VisuCoreTransposition.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        value = np.reshape(VisuCoreTransposition.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(index, value.shape, fg_index - dataset.encoded_dim)]
-        VisuCoreTransposition.size = (np.prod(value.shape),)
-        VisuCoreTransposition.value = value.flatten(order='F')
+        VisuCoreTransposition.size = (int(np.prod(value.shape)),)
+        VisuCoreTransposition.value = value.flatten(order="F")
+        return None
 
 
 class FrameGroupSplitter(Splitter):
     def __init__(self, fg):
         if fg not in SUPPORTED_FG:
-            raise NotImplemented('Split operation for {} is not implemented'.format(fg))
+            raise NotImplementedError(f"Split operation for {fg} is not implemented")
 
-        super(FrameGroupSplitter, self).__init__()
+        super().__init__()
         self.fg = fg
 
-
-    def split(self, dataset, select=None, write=False, path_out=None, **kwargs):
+    def split(self, dataset, select=None, write=None, path_out=None, **kwargs):
         """Split Bruker object along a dimension of specific frame group.
         Only the frame groups listed in SPLIT_FG_IMPLEMENTED can be used to split the object.
 
@@ -121,14 +122,17 @@ class FrameGroupSplitter(Splitter):
 
         """
 
-        if "<{}>".format(self.fg) not in dataset.dim_type:
-            raise ValueError(f'Dataset does not contain {self.fg} frame group')
+        if write is None:
+            write = False
+
+        if f"<{self.fg}>" not in dataset.dim_type:
+            raise ValueError(f"Dataset does not contain {self.fg} frame group")
 
         """
         CHECK if FG and index are valid
         """
         # absolute index of FG_SLICE among dimensions of the dataset
-        fg_abs_index = dataset.dim_type.index("<{}>".format(self.fg))
+        fg_abs_index = dataset.dim_type.index(f"<{self.fg}>")
 
         # index of FG_SLICE among frame group dimensions of the dataset
         fg_rel_index = fg_abs_index - dataset.encoded_dim
@@ -141,10 +145,12 @@ class FrameGroupSplitter(Splitter):
             select = list(range(0, fg_size))
 
         if isinstance(select, int):
-            select = [select,]
+            select = [
+                select,
+            ]
 
         if max(select) >= fg_size:
-            raise IndexError(f'Selection {select} out of bounds, size of {self.fg} dimension is {fg_size}')
+            raise IndexError(f"Selection {select} out of bounds, size of {self.fg} dimension is {fg_size}")
 
         """
         PERFORM splitting
@@ -153,10 +159,13 @@ class FrameGroupSplitter(Splitter):
 
         for select_ in select:
             # construct a new Dataset, without loading data, the data will be supplied later
-            name = '{}_{}_{}/2dseq'.format(dataset.path.parents[0].name, self.fg, select_)
+            name = f"{dataset.path.parents[0].name}_{self.fg}_{select_}/2dseq"
+
+            dset_path = dataset.path.parents[1] / name
+            os.makedirs(dset_path, exist_ok=True)
 
             # construct a new Dataset, without loading data, the data will be supplied later
-            dataset_ = Dataset(dataset.path.parents[1] / name, load=False)
+            dataset_ = Dataset(dataset.path.parents[1] / name, load=0)
 
             dataset_.parameters = self._split_params(dataset, select_, fg_abs_index, fg_rel_index, fg_size)
 
@@ -178,8 +187,7 @@ class FrameGroupSplitter(Splitter):
         return datasets
 
     def _split_params(self, dataset, select, fg_abs_index, fg_rel_index, fg_size):
-
-        visu_pars = copy.deepcopy(dataset.parameters['visu_pars'])
+        visu_pars = copy.deepcopy(dataset.parameters["visu_pars"])
 
         self._split_VisuCoreFrameCount(visu_pars, fg_size)
         self._split_VisuFGOrderDescDim(visu_pars)
@@ -189,12 +197,12 @@ class FrameGroupSplitter(Splitter):
         self._split_VisuCoreDataMin(dataset, visu_pars, select, fg_rel_index)
         self._split_VisuCoreDataMax(dataset, visu_pars, select, fg_rel_index)
 
-        if self.fg == 'FG_ECHO':
+        if self.fg == "FG_ECHO":
             self._split_params_FG_ECHO(dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars)
-        if self.fg == 'FG_ISA':
+        if self.fg == "FG_ISA":
             self._split_params_FG_ISA(dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars)
 
-        return {'visu_pars': visu_pars}
+        return {"visu_pars": visu_pars}
 
     def _split_params_FG_ISA(self, dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars):
         self._split_VisuCoreDataUnits(visu_pars, dataset, select, fg_rel_index)
@@ -204,43 +212,42 @@ class FrameGroupSplitter(Splitter):
         self._split_VisuAcqEchoTime(visu_pars, select)
 
     def _split_VisuCoreFrameCount(self, visu_pars, fg_size):
-        VisuCoreFrameCount = visu_pars['VisuCoreFrameCount']
+        VisuCoreFrameCount = visu_pars["VisuCoreFrameCount"]
         value = int(VisuCoreFrameCount.value / fg_size)
         VisuCoreFrameCount.value = value
 
     def _split_VisuFGOrderDescDim(self, visu_pars):
-        VisuFGOrderDescDim = visu_pars['VisuFGOrderDescDim']
+        VisuFGOrderDescDim = visu_pars["VisuFGOrderDescDim"]
         value = VisuFGOrderDescDim.value - 1
 
         if value > 1:
             VisuFGOrderDescDim.value = value
         else:
-            del visu_pars['VisuFGOrderDescDim']
+            del visu_pars["VisuFGOrderDescDim"]
 
     def _split_VisuCoreDataUnits(self, visu_pars, fg_scheme, index, fg_index):
-        VisuCoreDataUnits = visu_pars['VisuCoreDataUnits']
+        VisuCoreDataUnits = visu_pars["VisuCoreDataUnits"]
         value = VisuCoreDataUnits.value
         VisuCoreDataUnits.value = value[index]
         VisuCoreDataUnits.size = (65,)
 
     def _split_VisuFGOrderDesc(self, visu_pars, fg):
-        VisuFGOrderDesc = visu_pars['VisuFGOrderDesc']
+        VisuFGOrderDesc = visu_pars["VisuFGOrderDesc"]
 
         size = VisuFGOrderDesc.size[0] - 1
         VisuFGOrderDesc.size = size
 
         value = VisuFGOrderDesc.nested
         for fg_ in value:
-            if fg_[1] == '<{}>'.format(fg):
+            if fg_[1] == f"<{fg}>":
                 value.remove(fg_)
         if value:
             VisuFGOrderDesc.value = value
         else:
-            del visu_pars['VisuFGOrderDesc']
+            del visu_pars["VisuFGOrderDesc"]
 
     def _split_VisuFGElemComment(self, visu_pars, fg_scheme, index, fg_index):
-
-        VisuFGElemComment = visu_pars['VisuFGElemComment']
+        VisuFGElemComment = visu_pars["VisuFGElemComment"]
 
         value = VisuFGElemComment.value
 
@@ -249,9 +256,9 @@ class FrameGroupSplitter(Splitter):
         VisuFGElemComment.size = (65,)
 
     def _split_VisuAcqEchoTime(self, visu_pars, select):
-        VisuAcqEchoTime = visu_pars['VisuAcqEchoTime']
-        value = VisuAcqEchoTime.value
-        VisuAcqEchoTime.size=(1,)
+        VisuAcqEchoTime = visu_pars["VisuAcqEchoTime"]
+        value = VisuAcqEchoTime.list
+        VisuAcqEchoTime.size = (1,)
         VisuAcqEchoTime.value = float(value[select])
 
 
@@ -259,7 +266,8 @@ class SlicePackageSplitter(Splitter):
     """
     Split 2dseq data set along individual slice packages
     """
-    def split(self, dataset, write=False, path_out=None):
+
+    def split(self, dataset, write=None, path_out=None):
         """
         Split 2dseq data set containing multiple data sets into a list of 2dseq data sets containing individual slice packages.
 
@@ -271,19 +279,22 @@ class SlicePackageSplitter(Splitter):
         :return: list of split data sets
         """
 
+        if write is None:
+            write = False
+
         try:
-            VisuCoreSlicePacksSlices = dataset['VisuCoreSlicePacksSlices'].value
+            VisuCoreSlicePacksSlices = dataset["VisuCoreSlicePacksSlices"].nested
         except KeyError:
-            print('Parameter VisuCoreSlicePacksSlices not found')
+            raise MissingProperty("Parameter VisuCoreSlicePacksSlices not found") from KeyError
 
         # list of split data sets
         datasets = []
 
         # range of frames of given slice package
-        frame_range = range(0,0)
+        frame_range = range(0, 0)
 
         # absolute index of FG_SLICE among dimensions of the dataset
-        fg_rel_index = dataset['VisuFGOrderDesc'].sub_list(1).index('<FG_SLICE>')
+        fg_rel_index = dataset["VisuFGOrderDesc"].sub_list(1).index("<FG_SLICE>")
 
         # index of FG_SLICE among frame group dimensions of the dataset
         fg_abs_index = fg_rel_index + dataset.encoded_dim
@@ -291,17 +302,18 @@ class SlicePackageSplitter(Splitter):
         # slice package split loop
         for sp_index in range(len(VisuCoreSlicePacksSlices)):
             # set range
-            frame_range= range(frame_range.stop, frame_range.stop + VisuCoreSlicePacksSlices[sp_index][1])
+            frame_range = range(frame_range.stop, frame_range.stop + VisuCoreSlicePacksSlices[sp_index][1])
 
             # number of frames contained in given slice package
             frame_count = frame_range.stop - frame_range.start
 
             # name of the data set created by the split
-            name = '{}_sp_{}/2dseq'.format(dataset.path.parents[0].name, sp_index)
+            name = f"{dataset.path.parents[0].name}_sp_{sp_index}/2dseq"
 
+            os.makedirs(dataset.path.parents[1] / name, exist_ok=True)
 
             # construct a new Dataset, without loading data, the data will be supplied later
-            dataset_ = Dataset(dataset.path.parents[1] / name, load=False)
+            dataset_ = Dataset(dataset.path.parents[1] / name, load=0)
 
             # SPLIT parameters
             dataset_.parameters = self._split_parameters(dataset, frame_range, fg_rel_index, fg_abs_index, sp_index, frame_count)
@@ -310,12 +322,12 @@ class SlicePackageSplitter(Splitter):
             dataset_.load_properties()
 
             # change id
-            dataset_.id = '{}_sp_{}'.format(dataset_.id, sp_index)
+            dataset_.id = f"{dataset_.id}_sp_{sp_index}"
 
             # construct schema
             dataset_.load_schema()
 
-            #SPLIT data
+            # SPLIT data
             dataset_.data = self._split_data(dataset, frame_range, fg_abs_index)
 
             # append to result
@@ -328,7 +340,7 @@ class SlicePackageSplitter(Splitter):
 
     def _split_parameters(self, dataset, frame_range, fg_rel_index, fg_abs_index, sp_index, frame_count):
         # create a copy of visu_pars of the original data set
-        visu_pars_ = copy.deepcopy(dataset.parameters['visu_pars'])
+        visu_pars_ = copy.deepcopy(dataset.parameters["visu_pars"])
 
         # modify individual parameters so that the resulting data set is consistent
         self._split_VisuCorePosition(visu_pars_, frame_range, frame_count)
@@ -337,37 +349,38 @@ class SlicePackageSplitter(Splitter):
         self._split_VisuCoreDataMax(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreDataOffs(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreDataSlope(dataset, visu_pars_, frame_range, fg_rel_index)
-        self._split_VisuCoreTransposition(dataset, visu_pars_, frame_range, fg_rel_index)
+        if "VisuCoreTransposition" in dataset:
+            self._split_VisuCoreTransposition(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreFrameCount(dataset, visu_pars_, frame_count, fg_abs_index)
         self._split_VisuFGOrderDesc(visu_pars_, fg_rel_index, frame_count)
         self._split_VisuCoreSlicePacksDef(visu_pars_)
         self._split_VisuCoreSlicePacksSlices(visu_pars_, sp_index)
         self._split_VisuCoreSlicePacksSliceDist(visu_pars_, sp_index)
 
-        return {"visu_pars":visu_pars_}
+        return {"visu_pars": visu_pars_}
 
     def _split_VisuCoreFrameCount(self, dataset, visu_pars, frame_count, fg_ind_abs):
-        VisuCoreFrameCount = visu_pars['VisuCoreFrameCount']
+        VisuCoreFrameCount = visu_pars["VisuCoreFrameCount"]
 
         layout = np.array(dataset.shape_final)
-        layout[0:dataset.encoded_dim] = 1
+        layout[0 : dataset.encoded_dim] = 1
         layout[fg_ind_abs] = 1
         frames = int(frame_count * np.prod(layout))
 
         VisuCoreFrameCount.value = frames
 
     def _split_VisuCoreOrientation(self, visu_pars, frame_range, frame_count):
-        VisuCoreOrientation = visu_pars['VisuCoreOrientation']
-        VisuCoreOrientation.value = VisuCoreOrientation.value[frame_range, :].flatten(order='C')
+        VisuCoreOrientation = visu_pars["VisuCoreOrientation"]
+        VisuCoreOrientation.value = VisuCoreOrientation.value[frame_range, :].flatten(order="C")
         VisuCoreOrientation.size = (frame_count, 9)
 
     def _split_VisuCorePosition(self, visu_pars, frame_range, frame_count):
-        VisuCorePosition = visu_pars['VisuCorePosition']
-        VisuCorePosition.value = VisuCorePosition.value[frame_range, :].flatten(order='C')
+        VisuCorePosition = visu_pars["VisuCorePosition"]
+        VisuCorePosition.value = VisuCorePosition.value[frame_range, :].flatten(order="C")
         VisuCorePosition.size = (frame_count, 3)
 
     def _split_VisuFGOrderDesc(self, visu_pars, fg_rel_ind, frame_count):
-        VisuFGOrderDesc = visu_pars['VisuFGOrderDesc']
+        VisuFGOrderDesc = visu_pars["VisuFGOrderDesc"]
         value = VisuFGOrderDesc.value
 
         if isinstance(value[fg_rel_ind], list):
@@ -377,18 +390,18 @@ class SlicePackageSplitter(Splitter):
 
         VisuFGOrderDesc.value = value
 
-    def _split_VisuCoreSlicePacksDef(self,visu_pars):
-        VisuCoreSlicePacksDef = visu_pars['VisuCoreSlicePacksDef']
+    def _split_VisuCoreSlicePacksDef(self, visu_pars):
+        VisuCoreSlicePacksDef = visu_pars["VisuCoreSlicePacksDef"]
         value = VisuCoreSlicePacksDef.value
         value[1] = 1
         VisuCoreSlicePacksDef.value = value
 
     def _split_VisuCoreSlicePacksSlices(self, visu_pars_, sp_index):
-        VisuCoreSlicePacksSlices = visu_pars_['VisuCoreSlicePacksSlices']
+        VisuCoreSlicePacksSlices = visu_pars_["VisuCoreSlicePacksSlices"]
         VisuCoreSlicePacksSlices.value = [VisuCoreSlicePacksSlices.value[sp_index]]
 
     def _split_VisuCoreSlicePacksSliceDist(self, visu_pars_, sp_index):
-        VisuCoreSlicePacksSliceDist = visu_pars_['VisuCoreSlicePacksSliceDist']
-        value = int(VisuCoreSlicePacksSliceDist.value[sp_index])
+        VisuCoreSlicePacksSliceDist = visu_pars_["VisuCoreSlicePacksSliceDist"]
+        value = int(VisuCoreSlicePacksSliceDist.array[sp_index])
         VisuCoreSlicePacksSliceDist.value = value
         VisuCoreSlicePacksSliceDist.size = 1

brukerapi/utils.py

@@ -1,12 +1,12 @@
 import numpy as np
 
+
 def index_to_slice(index, data_shape, dim_index):
     out = []
 
     if isinstance(index, range):
         index = slice(index.start, index.stop)
 
-
     for i in range(len(data_shape)):
         if i != dim_index:
             out.append(slice(0, data_shape[i]))
@@ -15,48 +15,47 @@ def index_to_slice(index, data_shape, dim_index):
 
     return tuple(out)
 
+
 def simple_measurement(dataset):
+    if dataset.encoded_dim == 1:
+        axes = (0,)
+    elif dataset.encoded_dim == 2:
+        axes = (0, 1)
+    elif dataset.encoded_dim == 3:
+        axes = (0, 1, 2)
 
-        if dataset.encoded_dim == 1:
-            axes = (0,)
-        elif dataset.encoded_dim == 2:
-            axes = (0,1)
-        elif dataset.encoded_dim == 3:
-            axes = (0,1,2)
+    return np.fft.fftshift(np.fft.fft2(dataset.data, axes=axes), axes=axes)
 
-        return np.fft.fftshift(np.fft.fft2(dataset.data,axes=axes),axes=axes)
 
 def simple_reconstruction(dataset, **kwargs):
-        """
-        Simple Fourier reconstruction
-        :return: image
-        """
-        if dataset.encoded_dim == 1:
-            axes = (0,)
-        elif dataset.encoded_dim == 2:
-            axes = (0,1)
-        elif dataset.encoded_dim == 3:
-            axes = (0,1,2)
-
-        data = np.fft.fftshift(np.fft.ifft2(dataset.data, axes=axes),
-                               axes=axes)
-
-        if kwargs.get("COMBINE_CHANNELS") is True:
-            return combine_channels(data=data)
-        else:
-            return data
+    """
+    Simple Fourier reconstruction
+    :return: image
+    """
+    if dataset.encoded_dim == 1:
+        axes = (0,)
+    elif dataset.encoded_dim == 2:
+        axes = (0, 1)
+    elif dataset.encoded_dim == 3:
+        axes = (0, 1, 2)
 
-def combine_channels(dataset, data=None):
+    data = np.fft.fftshift(np.fft.ifft2(dataset.data, axes=axes), axes=axes)
 
-        if dataset.scheme is not None:
-            channel_dim = dataset.scheme.dim_type.index('channel')
-        else:
-            raise NotImplemented
+    if kwargs.get("COMBINE_CHANNELS") is True:
+        return combine_channels(data=data)
+    return data
+
+
+def combine_channels(dataset, data=None):
+    if dataset.scheme is not None:
+        channel_dim = dataset.scheme.dim_type.index("channel")
+    else:
+        raise NotImplementedError
 
-        if data is None:
-            data = dataset.data
+    if data is None:
+        data = dataset.data
 
-        data = data ** 2
-        data = np.expand_dims(np.sum(data, channel_dim), channel_dim)
+    data = data**2
+    data = np.expand_dims(np.sum(data, channel_dim), channel_dim)
 
-        return np.sqrt(data)
+    return np.sqrt(data)

{brukerapi-0.1.10.dist-info → brukerapi-0.2.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: brukerapi
-Version: 0.1.10
+Version: 0.2.0
 Summary: Bruker API
-Author-email: Tomas Psorn <tomaspsorn@isibrno.cz>
+Author-email: Tomas Psorn <tomaspsorn@isibrno.cz>, Jiri Vitous <vitous@isibrno.cz>
 License: MIT
 Project-URL: Homepage, https://github.com/isi-nmr/brukerapi-python
 Project-URL: Download, https://github.com/isi-nmr/brukerapi-python/releases/latest
@@ -15,6 +15,8 @@ Requires-Dist: pyyaml
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: zenodo_get; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Dynamic: license-file
 
 brukerapi-python
@@ -30,6 +32,7 @@ brukerapi-python
     :target: https://bruker-api.readthedocs.io/en/latest/?badge=latest
     :alt: Documentation Status
 
+
 A Python package providing I/O interface for Bruker data sets.
 
 tl;dr
@@ -70,6 +73,18 @@ Load an entire **study**:
     dataset.data                       # access data array
     dataset.VisuCoreSize               # get a value of a single parameter
 
+Load a parametric file:
+
+.. code-block:: python
+
+   from brukerapi.jcampdx import JCAMPDX
+
+   parameters = JCAMPDX('path_to_scan/method')
+   
+   TR = data.params["PVM_RepetitionTime"].value # This way
+   TR = data.get_value("PVM_RepetitionTime") # Or this way
+
+
 
 
 
@@ -170,8 +185,8 @@ Compatible pulse sequences for **fid** data sets:
 * STEAM.ppg
 * igFLASH.ppg
 
-ParaVision v6.0.1
-"""""""""""""""""
+ParaVision v6.0.1 and v7.0.0
+"""""""""""""""""""""""""""""""
 Compatible data set types:
 
 * **fid**
@@ -217,8 +232,10 @@ Compatible pulse sequences for **fid** data sets:
 * CPMG.ppg
 * RfProfile.ppg
 
-ParaVision v360
-"""""""""""""""
+
+ParaVision 360 v1.1 v3.0-v3.7
+"""""""""""""""""""""""""""""""""
+Reading rawdata is supported only in a basic form, no reshaping into k-space is supported at the moment.
 Compatible data set types:
 
 * **2dseq**

brukerapi-0.2.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+brukerapi/__init__.py,sha256=lT95qTFTZoyKk5vKYR3lPIdoLY6y4r8eOJcbk_wTy0g,83
+brukerapi/cli.py,sha256=Vkl8ZL2_8WGh1gv9AGY54Y0TP7MNX7Sf9RwQOKrcGnY,4158
+brukerapi/data.py,sha256=qvILBKRbQf2DEZRpnySuOa8dRkXBEhizDJkFvRxZPKg,201
+brukerapi/dataset.py,sha256=obd_zc9KZOhYe7DQbGSLXGaBwuGoi4NWXNocS3kSJf8,25251
+brukerapi/exceptions.py,sha256=qsXzJLZn1mdypN8TltX4fUPgCxCDWWFaVpEPlBkDRE4,8501
+brukerapi/folders.py,sha256=pJ7HOfp4aEl01pDRYJdiRaLljzbpbQbxkhgntBpFltg,17798
+brukerapi/jcampdx.py,sha256=SqT9AE_qxezlKnM2hfHTIFZXusO-UgezNJeVqKwayAY,25392
+brukerapi/mergers.py,sha256=Kt3gzE64fzgexi6DGIxSDjA6Bsrpv3E_Kvw2K5AA4Es,3944
+brukerapi/schemas.py,sha256=R_W1BkeLT56Jsu9MmSKszOPhBcsIPPXy3B45j-PrDaU,24623
+brukerapi/splitters.py,sha256=Z276unmCOL6YIbRrUP1QKU49QiTq3_7U7GbnZQt_Qug,15793
+brukerapi/utils.py,sha256=Auuj_RyBKxjG7jNKOKngeJyp95bFvAPk_4aYnR_Wbms,1447
+brukerapi/config/properties_2dseq_core.json,sha256=3JlQyDWhRiczFhLTXR0NS1OIxWwRljDBRvwlBtUnsfg,3919
+brukerapi/config/properties_2dseq_custom.json,sha256=Kxic-Asg2am-vFtFHaHN_lxZdA8VEBUXlVeSPLbWLBw,9282
+brukerapi/config/properties_fid_core.json,sha256=cxFIbb37lzl4oKTTg6226hv9ul3ClBMAUJcYxoTszow,17236
+brukerapi/config/properties_fid_custom.json,sha256=QIN3fryEbuV236D9GIOPmNkBYiKNXMByjTS4uubCmUM,1347
+brukerapi/config/properties_rawdata_core.json,sha256=wF2uDSUtM_fOep-grs6Jy46giGHTEwIkkFHykLFcrMI,3028
+brukerapi/config/properties_rawdata_custom.json,sha256=hNA4yuvxYua57PHDINGic3bDWft1VpIu1D0JSeXn6V4,833
+brukerapi/config/properties_traj_core.json,sha256=zx2gnPkVj9fUAL1iwixrtoRV7BlJpVTSYA4I-7s9Mzc,1956
+brukerapi/config/properties_traj_custom.json,sha256=-KWibjBW62-wbe6z28z9iK50kAIAyYxwtZZru37J1N4,4
+brukerapi-0.2.0.dist-info/licenses/LICENSE,sha256=qrKdH1kPjQsHQZxAS6dOSoPKyhrI0nKtNFVhG-fjDJw,1064
+brukerapi-0.2.0.dist-info/METADATA,sha256=Pnpr54WUISHauMVmpPLXTDMIazdaexueMmHl7ezjZcE,5853
+brukerapi-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brukerapi-0.2.0.dist-info/entry_points.txt,sha256=GkMTo84oMksVEhkrItYbnegKXFu0jyQHfOAvAn8z-Wo,46
+brukerapi-0.2.0.dist-info/top_level.txt,sha256=32V6nLorM2P3LQY_gPPKEgDbeTF0N-HCAyUeEUsf2GU,10
+brukerapi-0.2.0.dist-info/RECORD,,

brukerapi-0.1.10.dist-info/RECORD

@@ -1,25 +0,0 @@
-brukerapi/__init__.py,sha256=lT95qTFTZoyKk5vKYR3lPIdoLY6y4r8eOJcbk_wTy0g,83
-brukerapi/cli.py,sha256=eHvbg7JHCRgS9LO8nkKplMu9q3ZDj03uvSGsqLZ4H0g,4167
-brukerapi/data.py,sha256=qdG404FHfWqk2g59E1qmtGpEghTKWcavt_kzvbo2WN8,203
-brukerapi/dataset.py,sha256=otp-8N3n4HZc6IHp86PQ_2qXlPt3vzCdLiDYo3BviNk,25049
-brukerapi/exceptions.py,sha256=XHX6vtjPCqNMConAbT0IDjdiTIhHZe8kqjL12eBJ0Fg,9234
-brukerapi/folders.py,sha256=4JvAXbekqI0BTU3EBlSuObGio9wnKiuIm8Ggiprdjuw,17605
-brukerapi/jcampdx.py,sha256=he6Y0cdeMzbsg7Ls0UX3iQ37677YikNkEjGAr27aPws,25218
-brukerapi/mergers.py,sha256=IyNMesrhkdmexQgpO7vetaCJ-TSgN6zIatkLOv3mRMo,4067
-brukerapi/schemas.py,sha256=o9c9PsxfZt0bYoeN4JXycSpAyRYOXocZXDTcnR9G-IY,25061
-brukerapi/splitters.py,sha256=GZFvuDryBiWL7u2QrldWyd3-5btmATaYpMynWJOPIwM,15402
-brukerapi/utils.py,sha256=kDKq1FV_E4mnROHALPEfv9aTfNy_QfIeZE6wB6IAn_E,1604
-brukerapi/config/properties_2dseq_core.json,sha256=3JlQyDWhRiczFhLTXR0NS1OIxWwRljDBRvwlBtUnsfg,3919
-brukerapi/config/properties_2dseq_custom.json,sha256=Kxic-Asg2am-vFtFHaHN_lxZdA8VEBUXlVeSPLbWLBw,9282
-brukerapi/config/properties_fid_core.json,sha256=DYOKtJwqDhtKoJK1DPTuxofsiWwol2yXtnLfJp7TBzg,16076
-brukerapi/config/properties_fid_custom.json,sha256=QIN3fryEbuV236D9GIOPmNkBYiKNXMByjTS4uubCmUM,1347
-brukerapi/config/properties_rawdata_core.json,sha256=yksvjh5o4-t1e2VVzDSy_WuF5QzllovcwefxlIRJ188,2528
-brukerapi/config/properties_rawdata_custom.json,sha256=RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o,2
-brukerapi/config/properties_traj_core.json,sha256=zx2gnPkVj9fUAL1iwixrtoRV7BlJpVTSYA4I-7s9Mzc,1956
-brukerapi/config/properties_traj_custom.json,sha256=-KWibjBW62-wbe6z28z9iK50kAIAyYxwtZZru37J1N4,4
-brukerapi-0.1.10.dist-info/licenses/LICENSE,sha256=qrKdH1kPjQsHQZxAS6dOSoPKyhrI0nKtNFVhG-fjDJw,1064
-brukerapi-0.1.10.dist-info/METADATA,sha256=sIQDg55peXquqazXBn75rj2QXVJcanAZEX3jpFfMH0U,5317
-brukerapi-0.1.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-brukerapi-0.1.10.dist-info/entry_points.txt,sha256=GkMTo84oMksVEhkrItYbnegKXFu0jyQHfOAvAn8z-Wo,46
-brukerapi-0.1.10.dist-info/top_level.txt,sha256=32V6nLorM2P3LQY_gPPKEgDbeTF0N-HCAyUeEUsf2GU,10
-brukerapi-0.1.10.dist-info/RECORD,,