labmate 0.8.2__tar.gz → 0.8.4__tar.gz

{labmate-0.8.2/labmate.egg-info → labmate-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.8.2
+Version: 0.8.4
 Summary: Data management library to save data and plots to hdf5 files
 Home-page: https://github.com/kyrylo-gr/labmate
 Author: kyrylo.gr | LKB-OMQ

{labmate-0.8.2 → labmate-0.8.4}/labmate/__config__.py

@@ -1,3 +1,3 @@
 """This file contains all package constants."""
 
-__version__ = "0.8.2"
+__version__ = "0.8.4"

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/acquisition_data.py

@@ -1,9 +1,10 @@
 """Module that contains NotebookAcquisitionData class."""
+
 from typing import Dict, List, Optional, Union
 
 from dh5 import DH5
-from ..utils.file_read import read_files
 
+from ..utils.file_read import read_files
 from .logger_setup import logger
 
 
@@ -14,6 +15,9 @@ class NotebookAcquisitionData(DH5):
     `cell` is a str. It saves using `save_cell` function that will save it to `..._CELL.py` file
     """
 
+    _current_step: int
+    _cells: Dict[int, Optional[str]]
+
     def __init__(
         self,
         filepath: str,
@@ -58,10 +62,11 @@ class NotebookAcquisitionData(DH5):
         self._config = configs
         self.save_configs()
 
-        self._cell = cell
-        self.save_cell(cell=cell)
+        self._cells = {1: cell}
+        self.save_cell(cell=cell, suffix="1")
 
         self.experiment_name = experiment_name
+        self.current_step = 1
 
         self["useful"] = False
 
@@ -95,7 +100,12 @@ class NotebookAcquisitionData(DH5):
             with open(filepath + "_" + name, "w", encoding="utf-8") as file:
                 file.write(value)
 
-    def save_cell(self, cell: Optional[str] = None, filepath: Optional[str] = None):
+    def save_cell(
+        self,
+        cell: Optional[str] = None,
+        filepath: Optional[str] = None,
+        suffix: Optional[str] = None,
+    ):
         """Save the cell code to the h5 file and possibly to a file.
 
         If `save_files` during init was set to True, then it will create a '.py' file near
@@ -108,14 +118,15 @@ class NotebookAcquisitionData(DH5):
              the desired location, i.e. it should end with the file prefix to which the suffix and
              'py' extension will be added. Defaults to save filepath as h5 file.
         """
-        cell = cell or self._cell
         if cell == "none":
             return
         if cell is None or cell == "":
             logger.warning("Acquisition cell is not set. Nothing to save")
             return
-
-        self["acquisition_cell"] = cell
+        if suffix is not None:
+            self[f"acquisition_cell/{suffix}"] = cell
+        else:
+            self["acquisition_cell/0"] = cell
 
         if not self._save_files:
             return
@@ -124,13 +135,26 @@ class NotebookAcquisitionData(DH5):
         with open(filepath + "_CELL.py", "w", encoding="utf-8") as file:
             file.write(cell)
 
+    def save_cells(
+        self,
+        cells: Optional[Dict[int, Optional[str]]] = None,
+        filepath: Optional[str] = None,
+    ):
+        """Save all sells that are provided or pushed into self._cells array."""
+        cells = cells or self._cells
+        # if len(cells) == 1:
+        #     self.save_cell(cells.popitem()[1], filepath)
+        #     return
+        for i, cell in cells.items():
+            self.save_cell(cell, filepath, suffix=str(i))
+
     def save_additional_info(self):
         """Save all additional information, i.e. cell code, configs. Put useful key to True."""
         self["useful"] = True
 
         if not self._save_files:
             return
-        self.save_cell()
+        self.save_cells()
         self.save_configs()
 
     def save_acquisition(self, **kwds) -> "NotebookAcquisitionData":
@@ -140,3 +164,18 @@ class NotebookAcquisitionData(DH5):
         if self.save_on_edit is False:
             self.save()
         return self
+
+    @property
+    def current_step(self):
+        """Return the current step of the acquisition."""
+        return self._current_step
+
+    @current_step.setter
+    def current_step(self, value: int):
+        self._current_step = value
+
+    def set_cell(self, cell: Optional[str], step: Optional[int] = None):
+        """Set the cell code."""
+        if step is None:
+            step = self.current_step
+        self._cells[step] = cell

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/acquisition_loop.py

@@ -185,9 +185,7 @@ class AcquisitionLoop(DH5):
                 )
                 self[key][iteration] = value
         else:
-            if isinstance(value, (complex, np.complex_)) or (  # type: ignore
-                isinstance(value, (np.ndarray,)) and value.dtype == np.complex_
-            ):
+            if np.iscomplexobj(value):
                 self[key] = SyncNp(np.zeros(key_shape, dtype=np.complex128))
             else:
                 self[key] = SyncNp(np.zeros(key_shape))

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/acquisition_manager.py

@@ -104,9 +104,13 @@ class AcquisitionManager:
                 configs: dict of configurations files to save
                 directory: directory where the data is stored
         """
-        acquisition_tmp_data = self._acquisition_tmp_data or self.get_temp_data(self.temp_file_path)
+        acquisition_tmp_data = self._acquisition_tmp_data or self.get_temp_data(
+            self.temp_file_path
+        )
         if acquisition_tmp_data is None:
-            raise ValueError("You should create a new acquisition. It will create temp.json file.")
+            raise ValueError(
+                "You should create a new acquisition. It will create temp.json file."
+            )
         return acquisition_tmp_data
 
     @acquisition_tmp_data.setter
@@ -122,11 +126,15 @@ class AcquisitionManager:
         self, filename: Union[str, List[str], Tuple[str, ...]]
     ) -> "AcquisitionManager":
         """Set self.config_file to filename. Verify if exists.
-        Only set config file for future acquisition and will not change current acquisition"""
+        Only set config file for future acquisition and will not change current acquisition
+        """
         if not isinstance(filename, (list, set, tuple)):
             filename = [str(filename)]
 
         self.config_files = list(filename)
+        self._config_files_names_to_path = {
+            os.path.basename(file): file for file in self.config_files
+        }
 
         for config_file in self.config_files:
             if not os.path.exists(config_file):
@@ -156,9 +164,13 @@ class AcquisitionManager:
         if not experiment_path.exists():
             experiment_path.makedirs()
         if self._init_code and not os.path.exists(experiment_path / "init_analyse.py"):
-            with open(experiment_path / "init_analyse.py", "w", encoding="utf-8") as file:
+            with open(
+                experiment_path / "init_analyse.py", "w", encoding="utf-8"
+            ) as file:
                 file.write(self._init_code)
-        filepath_original = filepath = experiment_path / f"{dic.time_stamp}__{dic.experiment_name}"
+        filepath_original = filepath = (
+            experiment_path / f"{dic.time_stamp}__{dic.experiment_name}"
+        )
         if ignore_existence:
             return filepath
 
@@ -183,7 +195,9 @@ class AcquisitionManager:
         self.cell = cell
         configs = read_files(self.config_files)
         if self.config_files_eval:
-            configs = append_values_from_modules_to_files(configs, self.config_files_eval)
+            configs = append_values_from_modules_to_files(
+                configs, self.config_files_eval
+            )
 
         dic = AcquisitionTmpData(
             experiment_name=name,
@@ -194,7 +208,9 @@ class AcquisitionManager:
 
         self.acquisition_tmp_data = dic
 
-        self._current_acquisition = self.get_acquisition(replace=True, save_on_edit=save_on_edit)
+        self._current_acquisition = self.get_acquisition(
+            replace=True, save_on_edit=save_on_edit
+        )
 
         return self.current_acquisition
 
@@ -208,7 +224,9 @@ class AcquisitionManager:
         configs = read_files(self.config_files)
 
         if self.config_files_eval:
-            configs = append_values_from_modules_to_files(configs, self.config_files_eval)
+            configs = append_values_from_modules_to_files(
+                configs, self.config_files_eval
+            )
 
         if name is None:
             name = self.current_experiment_name + "_item"
@@ -252,13 +270,17 @@ class AcquisitionManager:
 
     @property
     def current_experiment_name(self) -> str:
-        return self.acquisition_tmp_data.experiment_name  # self.current_acquisition.name
+        return (
+            self.acquisition_tmp_data.experiment_name
+        )  # self.current_acquisition.name
 
     def get_acquisition(
         self, replace: Optional[bool] = False, save_on_edit: Optional[bool] = None
     ) -> NotebookAcquisitionData:
         acquisition_tmp_data = self.acquisition_tmp_data
-        filepath = self.create_path_from_tmp_data(acquisition_tmp_data, ignore_existence=True)
+        filepath = self.create_path_from_tmp_data(
+            acquisition_tmp_data, ignore_existence=True
+        )
         configs = acquisition_tmp_data.configs
         configs = configs if configs else None
         cell = self.cell

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/analysis_data.py

@@ -1,15 +1,14 @@
 """AnalysisData class."""
+
 import os
 from typing import List, Literal, Optional, Protocol, Tuple, TypeVar, Union
 
-
 from dh5 import DH5
 from dh5.path import Path
 
+from .. import utils
 from .analysis_loop import AnalysisLoop
-
 from .config_file import ConfigFile
-from .. import utils
 from .logger_setup import logger
 
 _T = TypeVar("_T", bound="AnalysisData")
@@ -95,7 +94,10 @@ class AnalysisData(DH5):
             raise ValueError(f"File '{filepath}' does not exist.")
 
         super().__init__(
-            filepath=filepath, overwrite=False, read_only=False, save_on_edit=save_on_edit
+            filepath=filepath,
+            overwrite=False,
+            read_only=False,
+            save_on_edit=save_on_edit,
         )
 
         self.lock_data()
@@ -146,9 +148,9 @@ class AnalysisData(DH5):
             logger.warning("Analysis cell is not set. Nothing to save")
             return self
 
-        self.unlock_data(cell_name_key).update({cell_name_key: code}).lock_data(cell_name_key).save(
-            [cell_name_key]
-        )
+        self.unlock_data(cell_name_key).update({cell_name_key: code}).lock_data(
+            cell_name_key
+        ).save([cell_name_key])
 
         if self._save_files:
             assert self.filepath, "You must set self.filepath before saving"
@@ -185,13 +187,18 @@ class AnalysisData(DH5):
             "inside_h5", False
         ):
             try:
-                import pltsave
+                raise NotImplementedError(
+                    "save_fig_inside_h5 is not implemented for the moment."
+                )
+                # import pltsave
 
-                data = pltsave.dumps(fig).to_json()
-                self[f"figures/{fig_name}"] = data
-                self.save([f"figures/{fig_name}"])
+                # data = pltsave.dumps(fig).to_json()
+                # self[f"figures/{fig_name}"] = data
+                # self.save([f"figures/{fig_name}"])
             except Exception as error:
-                logger.exception("Failed to save the figure inside h5 file due to %s", error)
+                logger.exception(
+                    "Failed to save the figure inside h5 file due to %s", error
+                )
         if tight_layout and hasattr(fig, "tight_layout"):
             fig.tight_layout()  # type: ignore
         fig.savefig(full_fig_name, **kwargs)
@@ -229,7 +236,9 @@ class AnalysisData(DH5):
 
         return "FIG" + name
 
-    def parse_config(self, config_files: Optional[Tuple[str, ...]] = None) -> "ConfigFile":
+    def parse_config(
+        self, config_files: Optional[Tuple[str, ...]] = None
+    ) -> "ConfigFile":
         """Parse config files. If `config_files` are not provided takes `default_config_files`."""
 
         config_files = config_files or self._default_config_files
@@ -240,7 +249,8 @@ class AnalysisData(DH5):
             return self._parsed_configs[hash(config_files)]
 
         config_data = sum(
-            (self.parse_config_file(config_file) for config_file in config_files), ConfigFile()
+            (self.parse_config_file(config_file) for config_file in config_files),
+            ConfigFile(),
         )
 
         self._parsed_configs[hash(config_files)] = config_data
@@ -263,7 +273,9 @@ class AnalysisData(DH5):
             if key_value == "filename" or key_value == "file" or key_value == "f":
                 filename = os.path.split(self.filepath)[-1]
                 keys_with_values.append(
-                    utils.title_parsing.ValueForPrint(key_value, filename, key_units, key_format)
+                    utils.title_parsing.ValueForPrint(
+                        key_value, filename, key_units, key_format
+                    )
                 )
             elif key_value in config_data:
                 keys_with_values.append(
@@ -316,7 +328,9 @@ class AnalysisData(DH5):
                 )
 
             if config_file_name in self._parsed_configs:
-                self._parsed_configs[original_config_name] = self._parsed_configs[config_file_name]
+                self._parsed_configs[original_config_name] = self._parsed_configs[
+                    config_file_name
+                ]
                 return self._parsed_configs[config_file_name]
 
         else:
@@ -339,7 +353,9 @@ class AnalysisData(DH5):
             (config_files,) if isinstance(config_files, str) else tuple(config_files)
         )
 
-    def get_analysis_code(self, name: str = "default", /, update_code: bool = True) -> str:
+    def get_analysis_code(
+        self, name: str = "default", /, update_code: bool = True
+    ) -> str:
         code: Optional[dict] = self.get("analysis_cells")
         if code is None:
             raise ValueError(
@@ -350,7 +366,9 @@ class AnalysisData(DH5):
         # if isinstance(code, bytes):
         #     code = code.decode()
         if name not in code:
-            raise KeyError(f"Cannot get cell '{name}'. Possible cells are: {tuple(code.keys())}")
+            raise KeyError(
+                f"Cannot get cell '{name}'. Possible cells are: {tuple(code.keys())}"
+            )
 
         code_str: str = code[name]
         if update_code:

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/analysis_loop.py

@@ -2,7 +2,7 @@
 It has mainly __iter__ method and __getitem__ method for slicing.
 """
 
-from typing import Any, List, Optional, Iterable, Tuple, Union
+from typing import Any, Iterable, List, Optional, Tuple, Union
 
 from dh5 import DH5
 
@@ -39,7 +39,9 @@ class AnalysisLoop(DH5):
 
     """
 
-    def __init__(self, data: Optional[dict] = None, loop_shape: Optional[List[int]] = None):
+    def __init__(
+        self, data: Optional[dict] = None, loop_shape: Optional[List[int]] = None
+    ):
         """Initialize an AnalysisLoop object.
 
         Args:

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition/custom_lint.py

@@ -1,4 +1,5 @@
 """Custom additional linter functions for the acquisition module."""
+
 import ast
 from typing import Any, Dict
 
@@ -24,7 +25,9 @@ def on_call_functions(node: ast.Call, db: Dict[str, Any]):
             h = hash(tuple(get_all_args_from_call(node)))
             data = db.setdefault("save_fig", [])
             if h in data:
-                errors.append("save_fig with the save arguments is used more then ones.")
+                errors.append(
+                    "save_fig with the save arguments is used more then ones."
+                )
 
             data.append(h)
     return errors

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition_notebook/acquisition_analysis_manager.py

@@ -264,7 +264,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
 
     def load_file(self, filename) -> "AnalysisData":
         filename = self._get_full_filename(filename)
-        if not os.path.exists(filename if filename.endswith(".h5") else filename + ".h5"):
+        if not os.path.exists(
+            filename if filename.endswith(".h5") else filename + ".h5"
+        ):
             raise ValueError(f"File {filename} cannot be found")
 
         data = AnalysisData(
@@ -288,6 +290,7 @@ class AcquisitionAnalysisManager(AcquisitionManager):
         cell: Optional[str] = None,
         prerun: Optional[Union[_CallableWithNoArgs, List[_CallableWithNoArgs]]] = None,
         save_on_edit: Optional[bool] = None,
+        step: int = 1,
     ) -> "AcquisitionAnalysisManager":
         self._analysis_cell_str = None
         self._analysis_data = None
@@ -295,8 +298,19 @@ class AcquisitionAnalysisManager(AcquisitionManager):
         self._acquisition_started = time.time()
 
         cell = cell or get_current_cell(self.shell)
-
-        self.new_acquisition(name=name, cell=cell, save_on_edit=save_on_edit)
+        if step != 1 and self._current_acquisition is not None:
+            if self._current_acquisition.experiment_name != name:
+                raise ValueError(
+                    f"Current acquisition ('{self.current_experiment_name}') "
+                    f"isn't the one expected ('{name}') for this acquisition. "
+                    f"Possible solutions: run acquisition '{name}' with step 1; "
+                    f"or change current acquisition name to '{self.current_experiment_name}'"
+                )
+            self._current_acquisition.current_step = step
+            self._current_acquisition.set_cell(cell, step=step)
+            self._current_acquisition.save_cell(cell, suffix=str(step))
+        else:
+            self.new_acquisition(name=name, cell=cell, save_on_edit=save_on_edit)
 
         logger.info(self.current_filepath.basename)
 
@@ -325,7 +339,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                 display_warning("Old data analysis")
 
             filename = str(filepath or self._get_full_filename(filename))  # type: ignore
-            filename = (filename.rsplit(".h5", 1)[0]) if filename.endswith(".h5") else filename
+            filename = (
+                (filename.rsplit(".h5", 1)[0]) if filename.endswith(".h5") else filename
+            )
 
         else:
             self._is_old_data = False
@@ -340,7 +356,8 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                     )
                     or (
                         acquisition_name[0] == r"^"
-                        and re.match(acquisition_name, self.current_experiment_name) is None
+                        and re.match(acquisition_name, self.current_experiment_name)
+                        is None
                     )
                 ):
                     raise ValueError(
@@ -374,7 +391,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
         if cell is not None:
             self.save_analysis_cell(cell=cell)
 
-        if (self._analysis_cell_str is not None) and (self._linting_external_vars is not None):
+        if (self._analysis_cell_str is not None) and (
+            self._linting_external_vars is not None
+        ):
             from ..acquisition import custom_lint
             from ..utils import lint
 
@@ -387,7 +406,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                 run_on_call=custom_lint.on_call_functions,
             )
             for var in lint_result.external_vars:
-                logger.warning("External variable used inside the analysis code: %s", var)
+                logger.warning(
+                    "External variable used inside the analysis code: %s", var
+                )
             for error in lint_result.errors:
                 logger.warning(error)
         utils.run_functions(self._analysis_cell_prerun_hook)
@@ -417,7 +438,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
     def parse_config_file(self, config_file_name: str, /) -> "ConfigFile":
         return self.data.parse_config_file(config_file_name)
 
-    def parse_config(self, config_files: Optional[Tuple[str, ...]] = None) -> "ConfigFile":
+    def parse_config(
+        self, config_files: Optional[Tuple[str, ...]] = None
+    ) -> "ConfigFile":
         return self.data.parse_config(config_files=config_files)
 
     @property
@@ -433,16 +456,22 @@ class AcquisitionAnalysisManager(AcquisitionManager):
         return self.data.parse_config_str(values, max_length=max_length)
 
     def linting(
-        self, allowed_variables: Optional[Iterable[str]] = None, init_file: Optional[str] = None
+        self,
+        allowed_variables: Optional[Iterable[str]] = None,
+        init_file: Optional[str] = None,
     ):
         from ..utils import lint
 
-        allowed_variables = set() if allowed_variables is None else set(allowed_variables)
+        allowed_variables = (
+            set() if allowed_variables is None else set(allowed_variables)
+        )
         if init_file is not None:
             allowed_variables.update(lint.find_variables_from_file(init_file)[0])
         self._linting_external_vars = allowed_variables
 
-    def set_default_config_files(self, config_files: Union[str, Tuple[str, ...], List[str]], /):
+    def set_default_config_files(
+        self, config_files: Union[str, Tuple[str, ...], List[str]], /
+    ):
         self._default_config_files = (
             (config_files,) if isinstance(config_files, str) else tuple(config_files)
         )
@@ -452,7 +481,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
     def set_analysis_cell_prerun_hook(
         self,
         hook: Union[
-            _CallableWithNoArgs, List[_CallableWithNoArgs], Tuple[_CallableWithNoArgs, ...]
+            _CallableWithNoArgs,
+            List[_CallableWithNoArgs],
+            Tuple[_CallableWithNoArgs, ...],
         ],
     ):
         self._analysis_cell_prerun_hook = (
@@ -462,7 +493,9 @@ class AcquisitionAnalysisManager(AcquisitionManager):
     def set_acquisition_cell_prerun_hook(
         self,
         hook: Union[
-            _CallableWithNoArgs, List[_CallableWithNoArgs], Tuple[_CallableWithNoArgs, ...]
+            _CallableWithNoArgs,
+            List[_CallableWithNoArgs],
+            Tuple[_CallableWithNoArgs, ...],
         ],
     ):
         self._acquisition_cell_prerun_hook = (
@@ -502,16 +535,21 @@ class AcquisitionAnalysisManager(AcquisitionManager):
 
             res = self.find_param_in_config(param_text)
             if res is None:
-                logger.warning("Parameter '%s' cannot be found in default config files.", param)
+                logger.warning(
+                    "Parameter '%s' cannot be found in default config files.", param
+                )
                 continue
             file, line_no = res
+            file = self._config_files_names_to_path.get(file, file)
             link = display.links.create_link(param_text, file, line_no, after_text)
             links += link + "<br/>"
         return display.display_html(links)
 
     def connect_default_widget(
         self,
-        objs: Union["display_widget.WidgetProtocol", List["display_widget.WidgetProtocol"]],
+        objs: Union[
+            "display_widget.WidgetProtocol", List["display_widget.WidgetProtocol"]
+        ],
     ):
         if not isinstance(objs, (list, tuple)):
             objs = [objs]

{labmate-0.8.2 → labmate-0.8.4}/labmate/acquisition_notebook/display_widget.py

@@ -198,9 +198,9 @@ def _create_file_link(aqm: "AcquisitionAnalysisManager", level_up) -> str:
     if filepath is None:
         return ""
     link_name = os.path.basename(filepath)
-    link = "/".join(os.path.abspath(filepath).replace("\\", "/").split("/")[-level_up:]).replace(
-        " ", "%20"
-    )
+    link = "/".join(
+        os.path.abspath(filepath).replace("\\", "/").split("/")[-level_up:]
+    ).replace(" ", "%20")
     link = f"[{link_name}](//kyrylo-gr.github.io/h5viewer/open?url={link})"
     return link
 

{labmate-0.8.2 → labmate-0.8.4}/labmate/attrdict/attrdict_class.py

@@ -1,5 +1,7 @@
 """This module contains the AttrDict class."""
+
 from typing import Any, List, Optional, Tuple, Union, overload
+
 from ..utils import title_parsing as utils_parse
 
 
@@ -30,12 +32,10 @@ class AttrDict(dict):
         return type(self)(result)
 
     @overload
-    def find_all(self, key: str) -> List[Tuple[str, Any]]:
-        ...
+    def find_all(self, key: str) -> List[Tuple[str, Any]]: ...  # noqa
 
     @overload
-    def find_all(self, key: list) -> List[List[Tuple[str, Any]]]:
-        ...
+    def find_all(self, key: list) -> List[List[Tuple[str, Any]]]: ...  # noqa
 
     def find_all(self, key: Union[str, list]):
         """Find all keys that contain the given string.
@@ -54,12 +54,10 @@ class AttrDict(dict):
         return elms
 
     @overload
-    def find(self, key: str) -> Optional[Tuple[str, Any]]:
-        ...
+    def find(self, key: str) -> Optional[Tuple[str, Any]]: ...  # noqa
 
     @overload
-    def find(self, key: list) -> List[Optional[Tuple[str, Any]]]:
-        ...
+    def find(self, key: list) -> List[Optional[Tuple[str, Any]]]: ...  # noqa
 
     def find(self, key: Union[str, list]) -> Union[Optional[tuple], list]:
         """Find the first key that contain the given string.
@@ -94,15 +92,21 @@ class AttrDict(dict):
         keys_with_values = self.__get_value_for_output(keys)
         return utils_parse.format_title(keys_with_values, max_length=max_length)
 
-    def __get_value_for_output(self, keys: List[str]) -> List[utils_parse.ValueForPrint]:
+    def __get_value_for_output(
+        self, keys: List[str]
+    ) -> List[utils_parse.ValueForPrint]:
         """Prepare the values for output. Returns list of ValueForPrint(key, value, unit, format))."""
         keys_with_values = []
         for key in keys:
             key_value, key_units, key_format = utils_parse.parse_get_format(key)
             if key_value in self:
                 keys_with_values.append(
-                    utils_parse.ValueForPrint(key_value, self[key_value], key_units, key_format)
+                    utils_parse.ValueForPrint(
+                        key_value, self[key_value], key_units, key_format
+                    )
                 )
             else:
-                raise ValueError(f"Cannot find key={key} inside {self.__class__.__name__}")
+                raise ValueError(
+                    f"Cannot find key={key} inside {self.__class__.__name__}"
+                )
         return keys_with_values

{labmate-0.8.2 → labmate-0.8.4}/labmate/display/__init__.py

@@ -1,8 +1,8 @@
 # flake8: noqa: F401
-from typing import Any, TYPE_CHECKING
 import importlib
+from typing import TYPE_CHECKING, Any
 
-from .main import display_html, display, logger, display_widgets
+from .main import display, display_html, display_widgets, logger
 
 __all__ = ["links", "buttons", "logger"]
 
@@ -14,7 +14,9 @@ class _LazyModule:
 
     def __getattr__(self, name):
         if self.__module is None:
-            self.__module = importlib.import_module(f".{self.__name}", package=__package__)
+            self.__module = importlib.import_module(
+                f".{self.__name}", package=__package__
+            )
         return getattr(self.__module, name)
 
     # @property
@@ -29,5 +31,4 @@ buttons = _LazyModule("buttons")
 
 
 if TYPE_CHECKING:
-    from . import links
-    from . import buttons
+    from . import buttons, links

{labmate-0.8.2 → labmate-0.8.4}/labmate/display/platform_utils/windows_utils.py

@@ -1,7 +1,9 @@
 """This submodule contains functions that are specific for windows."""
 
 
-def copy_fig(fig=None, format_=None, text_to_copy=None, **kwargs):  # pragma: no cover <--
+def copy_fig(
+    fig=None, format_=None, text_to_copy=None, **kwargs
+):  # pragma: no cover <--
     """Copy fig to the clipboard.
 
     Parameters
@@ -24,10 +26,10 @@ def copy_fig(fig=None, format_=None, text_to_copy=None, **kwargs):  # pragma: no
         If no figure is found
     """
     # from win32gui import GetWindowText, GetForegroundWindow  # type: ignore import warnings
-    import win32clipboard  # type: ignore import warnings
+    from io import BytesIO
 
     import matplotlib.pyplot as plt
-    from io import BytesIO
+    import win32clipboard  # type: ignore import warnings
 
     # Determined available values by digging into windows API
     format_map = {
@@ -71,7 +73,9 @@ def copy_fig(fig=None, format_=None, text_to_copy=None, **kwargs):  # pragma: no
                 im = Image.open(buf)
                 with BytesIO() as output:
                     im.convert("RGB").save(output, "BMP")
-                    data = output.getvalue()[14:]  # The file header off-set of BMP is 14 bytes
+                    data = output.getvalue()[
+                        14:
+                    ]  # The file header off-set of BMP is 14 bytes
                     format_id = win32clipboard.CF_DIB  # DIB = device independent bitmap
 
             except ImportError:
@@ -85,6 +89,8 @@ def copy_fig(fig=None, format_=None, text_to_copy=None, **kwargs):  # pragma: no
     win32clipboard.EmptyClipboard()
     win32clipboard.SetClipboardData(format_id, data)
     if text_to_copy:
-        win32clipboard.SetClipboardData(win32clipboard.CF_TEXT, text_to_copy.encode("utf-8"))
+        win32clipboard.SetClipboardData(
+            win32clipboard.CF_TEXT, text_to_copy.encode("utf-8")
+        )
 
     win32clipboard.CloseClipboard()

{labmate-0.8.2 → labmate-0.8.4}/labmate/parsing/saving.py

@@ -1,5 +1,7 @@
 """This file contains functions that prepare file for saving for further parsing."""
+
 from typing import Dict
+
 from . import parse_str
 
 
@@ -25,7 +27,9 @@ def append_values_from_modules_to_files(
     return configs
 
 
-def append_values_from_module_to_file(body: str, module, separator="  # value: ") -> str:
+def append_values_from_module_to_file(
+    body: str, module, separator="  # value: "
+) -> str:
     """Add values from a module to a given file body.
 
     Args:
@@ -64,7 +68,9 @@ def append_values_from_module_to_file(body: str, module, separator="  # value: "
         for key, (val, _) in parse_str(line).items():
             real_val = variables.get(key, "")
             if (
-                isinstance(val, str) and isinstance(real_val, str) and real_val != val.strip("\"'")
+                isinstance(val, str)
+                and isinstance(real_val, str)
+                and real_val != val.strip("\"'")
             ) or (
                 isinstance(val, str)
                 and isinstance(real_val, (float, int, complex))

{labmate-0.8.2 → labmate-0.8.4}/labmate/utils/lint.py

@@ -1,4 +1,5 @@
 """Linting module that detects bad practice with AcquisitionAnalysisManager."""
+
 import ast
 from typing import Any, Callable, Dict, List, NamedTuple, Optional, Set
 
@@ -197,7 +198,9 @@ class LintResult(NamedTuple):
     errors: List[str]
 
 
-def find_variables_from_node(node, ignore_var: Optional[set] = None, **kwargs) -> LintResult:
+def find_variables_from_node(
+    node, ignore_var: Optional[set] = None, **kwargs
+) -> LintResult:
     """Walk through ast.node and find the variable that was never declared inside this node, but used.
 
     Variables from ingore_var set is allowed external variables to use.

{labmate-0.8.2 → labmate-0.8.4}/labmate/utils/random_utils.py

@@ -1,4 +1,5 @@
 """Random utilities."""
+
 from typing import Any, Callable, List, Optional, Tuple, Union
 
 from dh5.utils.random_utils import (  # pylint: disable=unused-import # noqa: F401
@@ -6,13 +7,16 @@ from dh5.utils.random_utils import (  # pylint: disable=unused-import # noqa: F4
     get_timestamp,
 )
 
-
 _CallableWithNoArgs = Callable[[], Any]
 
 
 def run_functions(
     functions: Optional[
-        Union[_CallableWithNoArgs, List[_CallableWithNoArgs], Tuple[_CallableWithNoArgs, ...]]
+        Union[
+            _CallableWithNoArgs,
+            List[_CallableWithNoArgs],
+            Tuple[_CallableWithNoArgs, ...],
+        ]
     ] = None,
     /,
 ):

{labmate-0.8.2 → labmate-0.8.4}/labmate/utils/title_parsing.py

@@ -1,6 +1,7 @@
 """This file contains function of title generation.
 (parsing expected units and format, creating title)
 """
+
 from typing import Any, List, NamedTuple, Optional, Tuple
 
 
@@ -47,10 +48,14 @@ def format_title(values: List[ValueForPrint], max_length: Optional[int] = None)
     for value in values:
         units = f" ({value.units})" if value.units is not None else ""
         value_str = (
-            value.value if value.format is None else value.value.__format__(f".{value.format}")
+            value.value
+            if value.format is None
+            else value.value.__format__(f".{value.format}")
         )
         new_txt = f"{value.key} = {value_str}{units}"
-        if not max_length or ((last_line_len + len(new_txt) < max_length) or last_line_len == 0):
+        if not max_length or (
+            (last_line_len + len(new_txt) < max_length) or last_line_len == 0
+        ):
             txt += ("; " if txt != "" else "") + new_txt
             last_line_len += len(new_txt) + 2
         else:

{labmate-0.8.2 → labmate-0.8.4/labmate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.8.2
+Version: 0.8.4
 Summary: Data management library to save data and plots to hdf5 files
 Home-page: https://github.com/kyrylo-gr/labmate
 Author: kyrylo.gr | LKB-OMQ