labmate 0.9.0__tar.gz → 0.10.1__tar.gz

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

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

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

{labmate-0.9.0 → labmate-0.10.1}/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-0.9.0 → labmate-0.10.1}/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-0.9.0 → labmate-0.10.1}/labmate/acquisition/analysis_data.py

@@ -6,12 +6,11 @@ from typing import List, Literal, Optional, Protocol, Tuple, TypedDict, TypeVar,
 
 from dh5 import DH5
 from dh5.path import Path
-from matplotlib.backends.backend_pdf import PdfPages
 
 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")
 
@@ -216,6 +215,9 @@ class AnalysisData(DH5):
         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 {}

{labmate-0.9.0 → labmate-0.10.1}/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,10 +319,20 @@ 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)
@@ -368,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)
@@ -408,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)
 
@@ -537,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
@@ -558,7 +579,7 @@ class AcquisitionAnalysisManager(AcquisitionManager):
             param_eq = f"{param.strip()} = "
             res = self.find_param_in_config(param_eq)
             if res is None:
-                logger.warning(
+                self.logger.warning(
                     "Parameter '%s' cannot be found in default config files.", param
                 )
                 continue

labmate-0.10.1/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-0.9.0 → labmate-0.10.1}/labmate/utils/file_read.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 from typing import Any, Dict, List, Optional
 
 from ..parsing.brackets_score import BracketsScore
@@ -76,12 +77,20 @@ def update_file_variable(file, params: Dict[str, Any]):
             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
+            end_comment = "#".join(line.split("#")[1:]).strip() if "#" in line else None
             del lines[start_line : end_line + 1]
             value_str = json.JSONEncoder().encode(params[current_param])
+
+            print("value_str", value_str)
+            if re.match(
+                r"^['\"]?[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?['\"]?$", value_str
+            ):
+                value_str = value_str.replace('"', "")
+
             lines.insert(
                 start_line,
                 (

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: labmate
-Version: 0.9.0
+Version: 0.10.1
 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.9.0 → labmate-0.10.1}/labmate.egg-info/SOURCES.txt

@@ -50,7 +50,6 @@ labmate/acquisition/analysis_data.py
 labmate/acquisition/analysis_loop.py
 labmate/acquisition/config_file.py
 labmate/acquisition/custom_lint.py
-labmate/acquisition/logger_setup.py
 labmate/acquisition_notebook/__init__.py
 labmate/acquisition_notebook/acquisition_analysis_manager.py
 labmate/acquisition_notebook/display_widget.py
@@ -63,6 +62,7 @@ labmate/display/links.py
 labmate/display/main.py
 labmate/display/platform_utils/__init__.py
 labmate/display/platform_utils/windows_utils.py
+labmate/logger/__init__.py
 labmate/parsing/__init__.py
 labmate/parsing/brackets_score.py
 labmate/parsing/parsed_value.py

labmate-0.9.0/labmate/acquisition/logger_setup.py

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