labmate 0.8.4__py3-none-any.whl → 0.10.0__py3-none-any.whl

labmate/__config__.py

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

labmate/acquisition/acquisition_data.py

@@ -4,8 +4,8 @@ from typing import Dict, List, Optional, Union
 
 from dh5 import DH5
 
+from ..logger import logger
 from ..utils.file_read import read_files
-from .logger_setup import logger
 
 
 class NotebookAcquisitionData(DH5):

labmate/acquisition/acquisition_manager.py

@@ -26,15 +26,17 @@ class AcquisitionManager:
     """AcquisitionManager."""
 
     _data_directory: Path
-    config_files = []
-    config_files_eval = {}
+    config_files: List[str] = []
+    config_files_eval: Dict[str, str] = {}
+    _configs_last_modified: List[float] = []
 
-    _current_acquisition = None
-    _current_filepath = None
+    _current_acquisition: Optional[NotebookAcquisitionData] = None
+    _current_filepath: Optional[str] = None
 
-    _save_files = False
-    _save_on_edit = True
+    _save_files: bool = False
+    _save_on_edit: bool = True
     _init_code = None
+    _once_saved: bool
 
     cell: Optional[str] = None
 
@@ -54,9 +56,11 @@ class AcquisitionManager:
 
         self._current_acquisition = None
         self._acquisition_tmp_data = None
+        self._once_saved = False
 
         self.config_files = []
         self.config_files_eval = {}
+        self._configs_last_modified = []
 
         if data_directory is not None:
             self.data_directory = Path(data_directory)
@@ -187,13 +191,19 @@ class AcquisitionManager:
             return None
         return AcquisitionTmpData(**jsn.read(path))
 
+    def _get_configs_last_modified(self) -> List[float]:
+        return [os.path.getmtime(file) for file in self.config_files]
+
     def new_acquisition(
         self, name: str, cell: Optional[str] = None, save_on_edit: Optional[bool] = None
     ) -> NotebookAcquisitionData:
         """Create a new acquisition with the given experiment name."""
         self._current_acquisition = None
+        self._once_saved = False
         self.cell = cell
         configs = read_files(self.config_files)
+        self._configs_last_modified = self._get_configs_last_modified()
+
         if self.config_files_eval:
             configs = append_values_from_modules_to_files(
                 configs, self.config_files_eval
@@ -310,4 +320,5 @@ class AcquisitionManager:
         acq_data.save_additional_info()
         if acq_data.save_on_edit is False:
             acq_data.save()
+        self._once_saved = True
         return self

labmate/acquisition/analysis_data.py

@@ -1,15 +1,16 @@
 """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 .. import utils
+from ..logger import logger
 from .analysis_loop import AnalysisLoop
 from .config_file import ConfigFile
-from .logger_setup import logger
 
 _T = TypeVar("_T", bound="AnalysisData")
 
@@ -21,6 +22,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 +175,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 +210,26 @@ 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.")
+
+            from matplotlib.backends.backend_pdf import PdfPages
+
+            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/acquisition_notebook/acquisition_analysis_manager.py

@@ -16,6 +16,7 @@ from typing import (
 
 from .. import display, utils
 from ..acquisition import AcquisitionManager, AnalysisData
+from ..logger import logger
 from . import display_widget
 
 if TYPE_CHECKING:
@@ -24,19 +25,17 @@ if TYPE_CHECKING:
     from ..acquisition import FigureProtocol
     from ..acquisition.config_file import ConfigFile
 
+    # from ..logger import Logger
+
 
 logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.INFO)
-logger = logging.getLogger(__name__)
-handler = logging.StreamHandler()
-formatter = logging.Formatter("%(levelname)s:%(message)s")
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-logger.setLevel(logging.INFO)
-logger.propagate = False
 
 _CallableWithNoArgs = Callable[[], Any]
 
 
+CATCH_PRINT = True
+
+
 class AcquisitionAnalysisManager(AcquisitionManager):
     """AcquisitionAnalysisManager.
 
@@ -126,6 +125,7 @@ class AcquisitionAnalysisManager(AcquisitionManager):
         self._save_on_edit_analysis = save_on_edit_analysis
         self._save_fig_inside_h5 = save_fig_inside_h5
 
+        self._logger = logger
         super().__init__(
             data_directory=str(data_directory),
             config_files=config_files,
@@ -133,6 +133,10 @@ class AcquisitionAnalysisManager(AcquisitionManager):
             save_on_edit=save_on_edit,
         )
 
+    @property
+    def logger(self):
+        return self._logger
+
     @property
     def current_acquisition(self):
         """Return current acquisition if it's not an old data analyses."""
@@ -240,13 +244,19 @@ class AcquisitionAnalysisManager(AcquisitionManager):
 
     def save_acquisition(self, **kwds) -> "AcquisitionAnalysisManager":
         acquisition_finished = time.time()
-        additional_info: Dict[str, Any] = {
-            "acquisition_duration": acquisition_finished - self._acquisition_started
-        }
-        if self._default_config_files:
-            additional_info.update({"default_config_files": self._default_config_files})
+        if not self._once_saved:
+            additional_info: Dict[str, Any] = {
+                "acquisition_duration": acquisition_finished
+                - self._acquisition_started,
+                "logs": self.logger.getvalue(),
+                "prints": self.logger.get_stdout(),
+            }
+            if self._default_config_files:
+                additional_info.update(
+                    {"default_config_files": self._default_config_files}
+                )
 
-        kwds.update({"info": additional_info})
+            kwds.update({"info": additional_info})
 
         super().save_acquisition(**kwds)
         self._load_analysis_data()
@@ -309,12 +319,24 @@ class AcquisitionAnalysisManager(AcquisitionManager):
             self._current_acquisition.current_step = step
             self._current_acquisition.set_cell(cell, step=step)
             self._current_acquisition.save_cell(cell, suffix=str(step))
+            configs_modified = self._get_configs_last_modified()
+            if configs_modified != self._configs_last_modified:
+                raise ValueError(
+                    "Config files were modified since the previous acquisition step. "
+                    "Please rerun the acquisition from the first step."
+                )
+            self.logger.stdout_flush()
         else:
+            self.logger.reset()
             self.new_acquisition(name=name, cell=cell, save_on_edit=save_on_edit)
 
-        logger.info(self.current_filepath.basename)
+        self.logger.info(  # pylint: disable=W1203
+            f"{step}:{self.current_filepath.basename}"
+        )
+
+        if step == 1:
+            utils.run_functions(self._acquisition_cell_prerun_hook)
 
-        utils.run_functions(self._acquisition_cell_prerun_hook)
         utils.run_functions(prerun)
 
         return self
@@ -366,7 +388,7 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                     )
 
             filename = str(self.current_filepath)  # without h5
-        logger.info(os.path.basename(filename))
+        self.logger.info(os.path.basename(filename))
 
         if (
             (not self._is_old_data)
@@ -406,11 +428,12 @@ class AcquisitionAnalysisManager(AcquisitionManager):
                 run_on_call=custom_lint.on_call_functions,
             )
             for var in lint_result.external_vars:
-                logger.warning(
+                self.logger.warning(
                     "External variable used inside the analysis code: %s", var
                 )
             for error in lint_result.errors:
-                logger.warning(error)
+                self.logger.warning(error)
+
         utils.run_functions(self._analysis_cell_prerun_hook)
         utils.run_functions(prerun)
 
@@ -535,7 +558,7 @@ class AcquisitionAnalysisManager(AcquisitionManager):
 
             res = self.find_param_in_config(param_text)
             if res is None:
-                logger.warning(
+                self.logger.warning(
                     "Parameter '%s' cannot be found in default config files.", param
                 )
                 continue
@@ -545,6 +568,57 @@ class AcquisitionAnalysisManager(AcquisitionManager):
             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:
+                self.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/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/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/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/display/html_output.py

@@ -1,5 +1,9 @@
 """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`.
@@ -13,3 +17,47 @@ def display_warning(text: str):
     >{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/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/logger/__init__.py

@@ -0,0 +1,79 @@
+import io
+import logging
+import sys
+
+
+class BufferCatcher(io.StringIO):
+    _last_value = None
+
+    @property
+    def last_value(self):
+        if self._last_value is None:
+            return self.getvalue()
+        return self._last_value
+
+    def close(self) -> None:
+        self._last_value = self.getvalue()
+        return super().close()
+
+
+class StreamHandler(logging.StreamHandler):
+    stream: io.StringIO
+
+    def __init__(self, stream=None):
+        if stream is None:
+            stream = io.StringIO()
+        super().__init__(stream)
+
+    def reset(self):
+        self.stream.close()
+        stream = io.StringIO()
+        self.setStream(stream)
+
+
+class Logger(logging.Logger):
+    stdout_message: str
+
+    def __init__(self, name, level=logging.NOTSET):
+        super().__init__(name, level)
+
+        self.logger_handler = StreamHandler()
+        logger_formatter = logging.Formatter(
+            "%(name)s:%(filename)s:%(asctime)s:\n%(levelname)s:%(message)s"
+        )
+        self.logger_handler.setFormatter(logger_formatter)
+        self.logger_handler.setLevel(logging.DEBUG)
+        self.addHandler(self.logger_handler)
+
+        logger_handler_short = logging.StreamHandler()
+        logger_formatter_short = logging.Formatter("%(levelname)s:%(message)s")
+        logger_handler_short.setFormatter(logger_formatter_short)
+        logger_handler_short.setLevel(logging.INFO)
+        self.addHandler(logger_handler_short)
+
+        self.propagate = False
+        self.stdout_buffer = BufferCatcher()
+        self.stdout_message = ""
+
+    def reset(self):
+        self.logger_handler.reset()
+
+        self.stdout_setup()
+        self.stdout_message = ""
+
+    def stdout_flush(self):
+        self.stdout_message += f"\n{self.stdout_buffer.last_value}"
+        self.stdout_setup()
+
+    def stdout_setup(self):
+        self.stdout_buffer = BufferCatcher()
+        sys.stdout._buffer = self.stdout_buffer  # type: ignore # pylint: disable=protected-access
+
+    def getvalue(self):
+        return self.logger_handler.stream.getvalue()
+
+    def get_stdout(self):
+        return self.stdout_message + f"\n{self.stdout_buffer.last_value}"
+
+
+logger = Logger("Labmate")

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/utils/file_read.py

@@ -1,6 +1,10 @@
 """Different method to read files."""
+
+import json
 import os
-from typing import Dict, List
+from typing import Any, Dict, List, Optional
+
+from ..parsing.brackets_score import BracketsScore
 
 
 def read_file(file: str, /) -> str:
@@ -47,3 +51,46 @@ def read_files(files: List[str], /) -> Dict[str, str]:
             )
         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/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.4.dist-info → labmate-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.8.4
+Version: 0.10.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.4.dist-info → labmate-0.10.0.dist-info}/RECORD

@@ -1,40 +1,40 @@
-labmate/__config__.py,sha256=vSn0Wg7zasd-lKnYyP7LRB_e4JcnIeULAsgcJKNrSgM,71
+labmate/__config__.py,sha256=klTEHuAm-AhAQg9qYq-W6YyefUJiHBGfIPWnRQr-eT0,72
 labmate/__init__.py,sha256=aHQiPLldCXIJqz6wwcfyFU9sGLofUR3W5sXBIRzK2n4,182
 labmate/acquisition/__init__.py,sha256=8q3dy18lL32A9y_Du8GggpLgJqDMFcFKddHrySMavrM,269
-labmate/acquisition/acquisition_data.py,sha256=FUF0JTHl5_nmgPHUHFocTQEwPlxuCAVT5Xsf338jVhI,6686
+labmate/acquisition/acquisition_data.py,sha256=UcpUaT1SkmnqGMyzP8cgH2JjLRtWZZdTk5S0JHf-v9c,6681
 labmate/acquisition/acquisition_loop.py,sha256=fiiseV21GB7pczHSEJrlLPiTSQ2u9y5VMDyCO7Hn0vY,11106
-labmate/acquisition/acquisition_manager.py,sha256=uzGCWKCcOIwKTZsKp12OY1rvyWaFBlBsBDRR7mFZwj0,10496
-labmate/acquisition/analysis_data.py,sha256=DF9NshXBWu74gK8b_ZOGIuveabkzbLIDXfyui1c4yK8,14695
+labmate/acquisition/acquisition_manager.py,sha256=D94ahyQuzsEZdJzEUHJcN2aRwGoVYu4YDMKDCa7JnCU,10992
+labmate/acquisition/analysis_data.py,sha256=svpkOp12iMhBlR7nBgCFQXiOzQtwiQ3v2wXrZNpYdmk,15711
 labmate/acquisition/analysis_loop.py,sha256=1Y8lyPkTCNwskM8DkwrMXSOt0hNmBHcWJaQjdVZ81Hs,5075
 labmate/acquisition/config_file.py,sha256=1WwqaKTM-R5xZQHqqqGUi2QCF0PC1ag2mFgPOJuEdWI,2212
 labmate/acquisition/custom_lint.py,sha256=x4vNoOnbH3A4Odu2DQVtBsuSPo5JfvRpo8_EP0EOmgM,1005
-labmate/acquisition/logger_setup.py,sha256=udTp-0S4cqhGdUGQlk3G3Eg51wePEGraNG-69P9fTOo,129
 labmate/acquisition_notebook/__init__.py,sha256=ZtOGQtmPqEM1IRrL-_JYo4xYA87lFQ5JY5GmKcZz9z0,251
-labmate/acquisition_notebook/acquisition_analysis_manager.py,sha256=PEP5gXnuB2EMazjM-aMcLt4Ws81AgqYZCgZmoD20Lo8,20105
-labmate/acquisition_notebook/display_widget.py,sha256=VNSo7r5nY_8biq-PAJeLvU_nzJ71kS82gFuOy-762BQ,6918
+labmate/acquisition_notebook/acquisition_analysis_manager.py,sha256=cnsaIxgJc0yU1odPbqFY1VCmVVZT9Lwyyt6KWdkC4_U,22615
+labmate/acquisition_notebook/display_widget.py,sha256=yS7KeZ362djhHYFldQMpz8keVT7G2MgHsCmGMlXT81s,6858
 labmate/attrdict/__init__.py,sha256=MvuZVe7j4a0HxGMxim_K2cv-dhqZOfzdeMiTX-SRgDg,58
 labmate/attrdict/attrdict_class.py,sha256=4lKXe7oZo_lLHefmf5vAOKhibWgGDffJcxMhaWLvGs4,4047
-labmate/display/__init__.py,sha256=tD9kCR-2VpV2Fvm7cpw4mDgqMCEXIXh_AOO5KLawxEo,844
-labmate/display/buttons.py,sha256=_WbtS5PVpjgH2UEaSM5MACGHqcWiCSV3xN8di-MI7hk,2861
-labmate/display/html_output.py,sha256=SRsrszxBxuv-sQaWEkW_fyxFbImyJVj76iMTysqxKa4,425
+labmate/display/__init__.py,sha256=u6HL38LpkeiGDkcIqE4GVvsEGF8OgZ776cSOHG5dmLA,966
+labmate/display/buttons.py,sha256=ReFLn5KD-KOlxjZPCoT32lt1jNMN8Xka3K35oh17ZLo,2926
+labmate/display/html_output.py,sha256=aBDVzaR39PfFxchKcY9W5OpiYjIzB6t3WzNjzjubjzg,1591
 labmate/display/links.py,sha256=YgCNxowca-oHxqozGWbe4oGLzwltnZ-C0v3E5fQnK0U,746
-labmate/display/main.py,sha256=5M0-ckxhkCH0LXaZN6HD61b0noMypolKC9foEQmXx9w,1852
+labmate/display/main.py,sha256=2bjLbRmK5H1PYhtoiyZHzisu6CyQ6AmzlFtEhFZkStg,2354
 labmate/display/platform_utils/__init__.py,sha256=GOWB9vXF-wxGZfdHQJlQWy-hy2V2KXUP3JwxgN91Fq4,1136
 labmate/display/platform_utils/windows_utils.py,sha256=4Z_avuJIZ_KoXkuRZOH2667t2wEljzNBMP6fbNDknuk,3268
+labmate/logger/__init__.py,sha256=Ks4bUNO_rNTFsw0Sh3JAfK1tZq8mqHoqXHP89xpexp0,2177
 labmate/parsing/__init__.py,sha256=AHNB502jlm6PGd49_PJjvSxt97fxJeXnIfXYh8HV5x0,1312
 labmate/parsing/brackets_score.py,sha256=zzup7z6o57YUGeMr5FOSTo3nz9Z62s2omxqFV3M9MmI,988
 labmate/parsing/parsed_value.py,sha256=UYB_gCkV3DiFQRjcprnQUPw--FqYPqb3pii-PQsbHf0,5261
 labmate/parsing/saving.py,sha256=pwCdYI9shrpKyFceRPNbPcbEfJbNQ7Xj0AMsDOr5qLA,2548
-labmate/utils/__init__.py,sha256=PExO1TzVGwb9dXVZ733iML2H-ZFly-dksiHLgFU1xr4,72
+labmate/utils/__init__.py,sha256=g9LSaSVDFC4Uo7hbdd66aT7QewuXNRheZ8PZlMrcsNw,104
 labmate/utils/async_utils.py,sha256=mSfmpF7I3M5KePkPtoS-OcuoCkFDHPKjf-RVF0P3R48,118
 labmate/utils/autoreload.py,sha256=wKi1GgWyRu1h101OguVRpO3zQXZ8qsFj-K-1P8PKuq8,305
 labmate/utils/errors.py,sha256=ly7-JQStTKmPiMuT0w3eXFw1O8-1kpTsqZT2jebpJ-I,140
-labmate/utils/file_read.py,sha256=DAalvKehwEqVZjWSPhKZm8Myh6gfFA5gGT6WM0dPmyw,1536
+labmate/utils/file_read.py,sha256=mRHRIyqejtDlfLuPyafEYcfKfb4bac7zHbt-DW091Vg,3155
 labmate/utils/lint.py,sha256=7llJbZUAM-ikEpmU_ZzraqOwGUuJPgk1wAf3aYMJdxg,9312
 labmate/utils/random_utils.py,sha256=ZA3gK9P-eTcd_a3BTS_ZeJI5A0GM_GXL7X3yUqnPTO4,690
-labmate/utils/title_parsing.py,sha256=RpbiZwuKnpIq-X5S5iS90oD8iOqocWcI27MGuB4kTLU,1988
-labmate-0.8.4.dist-info/LICENCE,sha256=J9XIxdJExlWYZuxhhKtk4oYILvUz8-JM0y_leRQCKUE,7488
-labmate-0.8.4.dist-info/METADATA,sha256=_VWg55ngbUh7P6kxlZ38iK3i89oWgIDis0PJ3EoDN4A,3210
-labmate-0.8.4.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-labmate-0.8.4.dist-info/top_level.txt,sha256=WWAn6t2zNWsp02gRq6f5cSsGebcs-4L6HBFk0XrcY0o,8
-labmate-0.8.4.dist-info/RECORD,,
+labmate/utils/title_parsing.py,sha256=5csdqiD6w6pzyqRon38V2WeGA00CifSrMMtoWZmk0Ok,2644
+labmate-0.10.0.dist-info/LICENCE,sha256=J9XIxdJExlWYZuxhhKtk4oYILvUz8-JM0y_leRQCKUE,7488
+labmate-0.10.0.dist-info/METADATA,sha256=_8Qsw4NxSoayjiPoPvdunyV-a_ovkwjxYaqThycQvVQ,3211
+labmate-0.10.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+labmate-0.10.0.dist-info/top_level.txt,sha256=WWAn6t2zNWsp02gRq6f5cSsGebcs-4L6HBFk0XrcY0o,8
+labmate-0.10.0.dist-info/RECORD,,

{labmate-0.8.4.dist-info → labmate-0.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

labmate/acquisition/logger_setup.py

@@ -1,5 +0,0 @@
-"""Setup logger for acquisition module."""
-import logging
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.WARNING)