labmate 0.8.3__tar.gz → 0.9.0__tar.gz

{labmate-0.8.3/labmate.egg-info → labmate-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.8.3
+Version: 0.9.0
 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.3 → labmate-0.9.0}/labmate/__config__.py

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

{labmate-0.8.3 → labmate-0.9.0}/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.3 → labmate-0.9.0}/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.3 → labmate-0.9.0}/labmate/acquisition/acquisition_manager.py

@@ -132,6 +132,9 @@ class AcquisitionManager:
             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):

{labmate-0.8.3 → labmate-0.9.0}/labmate/acquisition/analysis_data.py

@@ -1,10 +1,12 @@
 """AnalysisData class."""
 
+import json
 import os
-from typing import List, Literal, Optional, Protocol, Tuple, TypeVar, Union
+from typing import List, Literal, Optional, Protocol, Tuple, TypedDict, TypeVar, Union
 
 from dh5 import DH5
 from dh5.path import Path
+from matplotlib.backends.backend_pdf import PdfPages
 
 from .. import utils
 from .analysis_loop import AnalysisLoop
@@ -21,6 +23,13 @@ class FigureProtocol(Protocol):
         """Save the figure to a file."""
 
 
+class PdfMetadataDict(TypedDict, total=False):
+    """Metadata for the pdf file."""
+
+    Subject: Union[str, dict]
+    Keywords: Union[str, dict]
+
+
 class AnalysisData(DH5):
     """A subclass of DH5 that provides additional functionality for analyzing data.
 
@@ -167,6 +176,7 @@ class AnalysisData(DH5):
         name: Optional[Union[str, int]] = None,
         extensions: Optional[str] = None,
         tight_layout: bool = True,
+        metadata: Optional[PdfMetadataDict] = None,
         **kwargs,
     ) -> _T:
         """Save the figure with the filename (...)_FIG_name.
@@ -201,7 +211,23 @@ class AnalysisData(DH5):
                 )
         if tight_layout and hasattr(fig, "tight_layout"):
             fig.tight_layout()  # type: ignore
-        fig.savefig(full_fig_name, **kwargs)
+        if metadata is None:
+            fig.savefig(full_fig_name, **kwargs)
+        else:
+            if not full_fig_name.endswith(".pdf"):
+                raise ValueError("Metadata can be added only to pdf files.")
+            pdf_fig = PdfPages(full_fig_name)
+            fig.savefig(pdf_fig, format="pdf", **kwargs)  # type: ignore
+            metadata = metadata or {}
+            if not isinstance(metadata.get("Subject", ""), str):
+                metadata["Subject"] = json.dumps(metadata.get("Subject"))
+
+            if not isinstance(metadata.get("Keywords", ""), str):
+                metadata["Keywords"] = json.dumps(metadata.get("Keywords"))
+
+            pdf_metadata = pdf_fig.infodict()
+            pdf_metadata.update(metadata)
+            pdf_fig.close()
 
         self._figure_saved = True
 

{labmate-0.8.3 → labmate-0.9.0}/labmate/acquisition_notebook/acquisition_analysis_manager.py

@@ -290,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
@@ -297,12 +298,25 @@ 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)
 
-        utils.run_functions(self._acquisition_cell_prerun_hook)
+        if step == 1:
+            utils.run_functions(self._acquisition_cell_prerun_hook)
+
         utils.run_functions(prerun)
 
         return self
@@ -528,10 +542,62 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                 )
                 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 display_cfg_link(
+        self,
+        parameters: Dict[str, Any],
+    ):
+        from labmate.display import html_output
+
+        links = []
+        for param, value in parameters.items():
+            param_eq = f"{param.strip()} = "
+            res = self.find_param_in_config(param_eq)
+            if res is None:
+                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)
+
+            def update_value(param, value):
+                self.update_config_params_on_disk({param: value})
+
+            buttons = [
+                display.buttons.create_button(update_value, param, value, name="Update")
+            ]
+
+            link = html_output.create_link_row(
+                link_text=f"{param} = ",
+                link_url=f"{file}:{line_no}",
+                text=str(value),
+                buttons=buttons,  # type: ignore
+            )
+            links.append(link)
+        return display.display_widgets_vertically(links, class_="labmate-params")
+
+    def update_config_params_on_disk(self, params: Dict[str, Any]):
+        # params_per_files = {}
+        # for param, value in params.items():
+        #     res = self.find_param_in_data_config(param)
+        #     if res is None:
+        #         raise ValueError(
+        #             f"Parameter '{param}' cannot be found in default config files."
+        #         )
+        #     file, _ = res
+        #     params_per_files.setdefault(file, {})[param] = value
+
+        for file in self.config_files:
+            file = self._config_files_names_to_path.get(file, file)
+            utils.file_read.update_file_variable(file, params)
+
+        return self
+
     def connect_default_widget(
         self,
         objs: Union[

{labmate-0.8.3 → labmate-0.9.0}/labmate/acquisition_notebook/display_widget.py

@@ -1,20 +1,38 @@
-"""Module with widgets that can be displayed with AcquisitionAnalysisManager."""
-
 import os
 from typing import TYPE_CHECKING, List, Optional, Protocol, TypeVar
 
 from .. import display as lm_display
 from ..display import platform_utils
 
-# import abc
-
-
 if TYPE_CHECKING:
     from labmate.acquisition_notebook import AcquisitionAnalysisManager
 
 _T = TypeVar("_T")
 
 
+def _get_filepath(aqm: "AcquisitionAnalysisManager") -> Optional[str]:
+    filepath = aqm.current_analysis or aqm.current_acquisition
+    return filepath.filepath if filepath else None
+
+
+def _create_file_link(aqm: "AcquisitionAnalysisManager", level_up) -> str:
+    filepath = _get_filepath(aqm)
+    if filepath is None:
+        return ""
+    link_name = os.path.basename(filepath)
+    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
+
+
+def display_widgets(objs: List["WidgetProtocol"], *args, **kwargs):
+    """Create (with *args, **kwargs) and display a list of widgets."""
+    widgets = [obj.create(*args, **kwargs) for obj in objs]
+    lm_display.display_widgets(widgets)  # type: ignore
+
+
 class WidgetProtocol(Protocol):
     """Protocol for widgets that can be displayed with AcquisitionAnalysisManager.
 
@@ -73,7 +91,7 @@ class BaseWidget:
         raise NotImplementedError("This method is not implemented for the base class.")
 
 
-class CopyFilePathButton(BaseWidget):
+class CopyFileURLPathButton(BaseWidget):
     """Create button to copy file path to clipboard.
 
     Examples:
@@ -180,32 +198,9 @@ class OpenFinderButton(BaseWidget):
                 path = path.replace("/", "\\")
                 subprocess.run(["explorer", "/select,", path], shell=True)
             elif sys.platform == "darwin":
-                subprocess.Popen(["open", "-R", path])
+                subprocess.Popen(["open", "-R", os.path.dirname(path)])
             else:
-                subprocess.Popen(["nautilus", "--select", path])
+                subprocess.Popen(["nautilus", "--select", os.path.dirname(path)])
 
         self.widget = lm_display.buttons.create_button(open_finder, name="Open finder")
         return self.widget
-
-
-def _get_filepath(aqm: "AcquisitionAnalysisManager") -> Optional[str]:
-    filepath = aqm.current_analysis or aqm.current_acquisition
-    return filepath.filepath if filepath else None
-
-
-def _create_file_link(aqm: "AcquisitionAnalysisManager", level_up) -> str:
-    filepath = _get_filepath(aqm)
-    if filepath is None:
-        return ""
-    link_name = os.path.basename(filepath)
-    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
-
-
-def display_widgets(objs: List["WidgetProtocol"], *args, **kwargs):
-    """Create (with *args, **kwargs) and display a list of widgets."""
-    widgets = [obj.create(*args, **kwargs) for obj in objs]
-    lm_display.display_widgets(widgets)  # type: ignore

{labmate-0.8.3 → labmate-0.9.0}/labmate/display/__init__.py

@@ -2,9 +2,15 @@
 import importlib
 from typing import TYPE_CHECKING, Any
 
-from .main import display, display_html, display_widgets, logger
+from .main import (
+    display,
+    display_html,
+    display_widgets,
+    display_widgets_vertically,
+    logger,
+)
 
-__all__ = ["links", "buttons", "logger"]
+__all__ = ["links", "buttons", "logger", "html_output"]
 
 
 class _LazyModule:
@@ -28,7 +34,8 @@ class _LazyModule:
 
 links = _LazyModule("links")
 buttons = _LazyModule("buttons")
+html_output = _LazyModule("html_output")
 
 
 if TYPE_CHECKING:
-    from . import buttons, links
+    from . import buttons, html_output, links

{labmate-0.8.3 → labmate-0.9.0}/labmate/display/buttons.py

@@ -1,5 +1,7 @@
 """This submodule contains functions that create Button widgets."""
+
 from typing import TypeVar
+
 from .main import display, widgets
 
 # from functools import wraps
@@ -69,6 +71,8 @@ def create_button(func, *args, name=None, **kwargs) -> "DisplayingButton":
     def on_button_click(_):
         func(*args, **kwargs)
 
+    button.style.button_color = "transparent"  # type: ignore
+
     button.on_click(on_button_click)
     return button
 

labmate-0.9.0/labmate/display/html_output.py

@@ -0,0 +1,63 @@
+"""This submodule contains functions that create different html."""
+
+from typing import List, Optional
+
+from .main import widgets
+
+
+def display_warning(text: str):
+    """Display div warning block with `text`.
+
+    If IPython is not installed, log into logger from display submodule at warning level.
+    """
+    from .main import display_html
+
+    html = f"""<div style="
+    background-color:#ec7413; padding: .5em; text-align:center"
+    >{text}</div>"""
+
+    display_html(str(html))
+
+
+def create_link_row(
+    link_text: str,
+    link_url: str,
+    text: str,
+    buttons: Optional[List[widgets.Button]] = None,
+):
+
+    # Create the HTML link with custom styling
+    link_widget = widgets.HTML(
+        value=f'<a href="{link_url}" target="_blank" onclick="return false;">{link_text}</a>'
+    )
+
+    # Create the text with custom styling
+    text_widget = widgets.HTML(
+        value=f'<span style="padding: 0 10px;">{text}</span>',
+        layout=widgets.Layout(background_color="transparent"),
+    )
+
+    custom_css = """
+    <style>
+    .cell-output-ipywidget-background:has(.labmate-params) {
+        background: transparent !important;
+    }
+    .labmate-params, .labmate-params * {
+        color: inherit !important;
+    }
+    .labmate-params a {
+        text-decoration: underline;
+        color: blue;
+
+    }
+
+    </style>
+    """
+    buttons = buttons or []
+
+    hbox = widgets.HBox(
+        [widgets.HTML(custom_css), link_widget, text_widget, *buttons],
+        layout=widgets.Layout(background_color="transparent"),
+    )
+    hbox.add_class("labmate-params")
+    return hbox

{labmate-0.8.3 → labmate-0.9.0}/labmate/display/main.py

@@ -1,9 +1,9 @@
 """This submodule contains functions that help to display content in IPython."""
+
 import logging
 import sys
 from typing import Callable, List
 
-
 logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.WARNING)
 logger = logging.getLogger(__name__)
 handler = logging.StreamHandler()
@@ -18,9 +18,9 @@ try:
     if "pytest" in sys.modules:
         raise ImportError
 
-    from IPython.core.display import HTML  # type: ignore
-    from IPython.core import display  # type: ignore
     import ipywidgets as widgets  # pylint: disable=W0611 # type: ignore
+    from IPython.core import display  # type: ignore
+    from IPython.core.display import HTML  # type: ignore
 
     display = display.display_functions.display
 
@@ -49,9 +49,17 @@ except ImportError:
             def __init__(self, lst: list) -> None:  # noqa: D107
                 pass
 
+        class VBox:  # noqa: D106
+            def __init__(self, lst: list) -> None:  # noqa: D107
+                pass
+
         class CoreWidget:  # noqa: D106
             pass
 
+        class Layout:
+            def __init__(self, *args, **kwargs) -> None:
+                del args, kwargs
+
     # pylint: enable=C0115, C0103, R0903
 
 
@@ -64,3 +72,11 @@ def display_widgets(objs: List[widgets.CoreWidget]):
     """Display the given list of widgets in a HBox ."""
     button_row = widgets.HBox(objs)
     display(button_row)
+
+
+def display_widgets_vertically(objs: List[widgets.CoreWidget], class_: str = ""):
+    """Display the given list of widgets in a VBox ."""
+    button_row = widgets.VBox(objs)
+    if class_:
+        button_row.add_class(class_)  # type: ignore
+    display(button_row)

{labmate-0.8.3 → labmate-0.9.0}/labmate/utils/__init__.py

@@ -1,2 +1,3 @@
-from .random_utils import *  # noqa
+from . import file_read  # noqa
 from . import title_parsing  # noqa
+from .random_utils import *  # noqa

labmate-0.9.0/labmate/utils/file_read.py

@@ -0,0 +1,96 @@
+"""Different method to read files."""
+
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from ..parsing.brackets_score import BracketsScore
+
+
+def read_file(file: str, /) -> str:
+    """Read the contents of a file and returns it as a string.
+
+    Args:
+        file (str): The path to the file to be read.
+
+    Returns:
+        str: The contents of the file as a string.
+
+    Raises:
+        ValueError: If the file does not exist or is not a file.
+    """
+    if not os.path.isfile(file):
+        raise ValueError(
+            "Cannot read a file if it doesn't exist or it's not a file."
+            f"Path: {os.path.abspath(file)}"
+        )
+
+    with open(file, "r", encoding="utf-8") as file_opened:
+        return file_opened.read()
+
+
+def read_files(files: List[str], /) -> Dict[str, str]:
+    """Read the contents of the given  files and returns them as a dictionary.
+
+    Args:
+        files: A list of file paths to read.
+
+    Returns:
+        A dictionary where the keys are the file names and the values are the contents of the files.
+
+    Raises:
+        ValueError: If some of the files have the same name, which would cause a key collision in the dictionary.
+    """
+    configs: Dict[str, str] = {}
+    for config_file in files:
+        config_file_name = os.path.basename(config_file)
+        if config_file_name in configs:
+            raise ValueError(
+                "Some of the files have the same name. So it cannot be pushed into dictionary to"
+                " preserve unique key"
+            )
+        configs[config_file_name] = read_file(config_file)
+    return configs
+
+
+def update_file_variable(file, params: Dict[str, Any]):
+    """
+    Update the variables in a file with the given parameters.
+
+    Args:
+        file (str): The path to the file to update.
+        params (Dict[str, Any]): The parameters to update the file with.
+    """
+    with open(file, "r", encoding="utf-8") as file_opened:
+        lines = file_opened.readlines()
+    brackets = BracketsScore()
+    current_param: Optional[str] = None
+    # print(lines)
+    for line in lines:
+        # print(line)
+        if len(line) == 0:
+            continue
+        if brackets.is_zero() and "=" in line:
+            param = line.split("=")[0].strip()
+            # print("param", param)
+            if param in params:
+                current_param = param
+                start_line = lines.index(line)
+        brackets.update_from_str(line)
+        if brackets.is_zero() and current_param is not None:
+            end_line = lines.index(line)
+            end_comment = line.split("#")[-1].strip() if "#" in line else None
+            del lines[start_line : end_line + 1]
+            value_str = json.JSONEncoder().encode(params[current_param])
+            lines.insert(
+                start_line,
+                (
+                    f"{current_param} = {value_str}"
+                    + (f"  # {end_comment}" if end_comment is not None else "")
+                    + "\n"
+                ),
+            )
+            current_param = None
+
+    with open(file, "w", encoding="utf-8") as file_opened:
+        file_opened.writelines(lines)

{labmate-0.8.3 → labmate-0.9.0}/labmate/utils/title_parsing.py

@@ -17,7 +17,11 @@ def parse_get_format(key: str) -> Tuple[str, Optional[str], Optional[str]]:
     args = key.split("__")
     if len(args) >= 3:
         return args[0], args[1], args[2]
-    elif len(args) == 2 and len(args[1]) > 0 and args[1][0].isdigit():
+    elif (
+        len(args) == 2
+        and len(args[1]) > 0
+        and (args[1][0].isdigit() or args[1][0] in (".", "_"))
+    ):
         return args[0], None, args[1]
     elif len(args) == 2:
         return args[0], args[1], None
@@ -32,6 +36,23 @@ class ValueForPrint(NamedTuple):
     units: Optional[str] = None
     format: Optional[str] = None
 
+    def format_value(self, format_spec: Optional[str] = None) -> str:
+        format_spec = format_spec or self.format
+        if not format_spec:
+            return str(self.value)
+        if format_spec.endswith("p"):
+            format_spec = format_spec[:-1] + "e"
+            value_str = format(self.value, format_spec)
+            number, power = value_str.split("e")
+            number = number.rstrip("0_").rstrip(".") if "." in number else number
+            power = (
+                (power[0].lstrip("+0") + power[1:].lstrip("+0"))
+                if len(power) > 1
+                else power
+            )
+            return f"{number}e{power}"
+        return format(self.value, format_spec)
+
 
 def format_title(values: List[ValueForPrint], max_length: Optional[int] = None) -> str:
     """Create title out of a list of valuesForPrint.
@@ -47,11 +68,7 @@ def format_title(values: List[ValueForPrint], max_length: Optional[int] = None)
     last_line_len = 0
     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_str = value.format_value()
         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

{labmate-0.8.3 → labmate-0.9.0/labmate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.8.3
+Version: 0.9.0
 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.3/labmate/display/html_output.py

@@ -1,15 +0,0 @@
-"""This submodule contains functions that create different html."""
-
-
-def display_warning(text: str):
-    """Display div warning block with `text`.
-
-    If IPython is not installed, log into logger from display submodule at warning level.
-    """
-    from .main import display_html
-
-    html = f"""<div style="
-    background-color:#ec7413; padding: .5em; text-align:center"
-    >{text}</div>"""
-
-    display_html(str(html))

labmate-0.8.3/labmate/utils/file_read.py

@@ -1,49 +0,0 @@
-"""Different method to read files."""
-import os
-from typing import Dict, List
-
-
-def read_file(file: str, /) -> str:
-    """Read the contents of a file and returns it as a string.
-
-    Args:
-        file (str): The path to the file to be read.
-
-    Returns:
-        str: The contents of the file as a string.
-
-    Raises:
-        ValueError: If the file does not exist or is not a file.
-    """
-    if not os.path.isfile(file):
-        raise ValueError(
-            "Cannot read a file if it doesn't exist or it's not a file."
-            f"Path: {os.path.abspath(file)}"
-        )
-
-    with open(file, "r", encoding="utf-8") as file_opened:
-        return file_opened.read()
-
-
-def read_files(files: List[str], /) -> Dict[str, str]:
-    """Read the contents of the given  files and returns them as a dictionary.
-
-    Args:
-        files: A list of file paths to read.
-
-    Returns:
-        A dictionary where the keys are the file names and the values are the contents of the files.
-
-    Raises:
-        ValueError: If some of the files have the same name, which would cause a key collision in the dictionary.
-    """
-    configs: Dict[str, str] = {}
-    for config_file in files:
-        config_file_name = os.path.basename(config_file)
-        if config_file_name in configs:
-            raise ValueError(
-                "Some of the files have the same name. So it cannot be pushed into dictionary to"
-                " preserve unique key"
-            )
-        configs[config_file_name] = read_file(config_file)
-    return configs