pymagnetos 0.1.0__py3-none-any.whl

pymagnetos/core/utils.py

@@ -0,0 +1,85 @@
+"""Utility functions."""
+
+from collections.abc import Mapping
+from typing import Any
+
+
+def merge_dict_nested(
+    dic_user: Mapping[str, Any], dic_default: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Merge two dictionaries.
+
+    Keep elements from `dic_user` if it exists, with a fallback on elements in
+    `dic_default`. All nested dictionaries are also treated like this.
+
+    Parameters
+    ----------
+    dic_user : dict-like
+        Dict being merged, its values have priority over `dic_default`.
+    dic_default : dict-like
+        Dict being merged, its values are used if they are not in `dic_user`.
+
+    Returns
+    -------
+    dic : dict
+        Merged dict.
+    """
+    dic_copy = dic_default.copy()
+    for key, value in dic_user.items():
+        if key in dic_default:
+            if isinstance(value, Mapping):
+                dic_copy[key] = merge_dict_nested(value, dic_default[key])
+            else:
+                if key in dic_user:
+                    dic_copy[key] = dic_user[key]
+
+        else:
+            dic_copy[key] = dic_user[key]
+
+    return dic_copy
+
+
+def cast_type_dict(
+    dic: dict[str, Any], in_type: type, out_type: type
+) -> dict[str, Any]:
+    """
+    Convert `in_type` value to `out_type` values in a dictionary.
+
+    Nested dictionaries are supported, so the casted types can't be `dict`.
+
+    Parameters
+    ----------
+    dic : dict
+        Dict in which values are casted.
+    in_type, out_type : type
+        `in_type` types are casted to `out_type`. Can't be `dict`.
+    """
+    dic_copy = dic.copy()
+    for key, value in dic.items():
+        if isinstance(value, dict):
+            dic_copy[key] = cast_type_dict(value, in_type, out_type)
+        else:
+            if isinstance(dic_copy[key], in_type):
+                dic_copy[key] = out_type(dic[key])
+
+    return dic_copy
+
+
+def strip_none_dict(dic: dict) -> dict:
+    """
+    Strip elements that are None from `dic`.
+
+    Parameters
+    ----------
+    dic : dict
+        Dict in which None values are removed.
+    """
+    dic_copy = dic.copy()
+    for key, value in dic.items():
+        if isinstance(value, dict):
+            dic_copy[key] = strip_none_dict(value)
+        elif value is None:
+            dic_copy.pop(key)
+
+    return dic_copy

pymagnetos/log.py

@@ -0,0 +1,126 @@
+"""Logging utilities."""
+
+import logging
+import sys
+import warnings
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from types import TracebackType
+from typing import Literal
+
+from rich.logging import RichHandler
+
+__all__ = ["configure_logger"]
+
+# Setup logging directory
+APP_DIR = Path.home() / ".pymagnetos"
+APP_DIR.mkdir(parents=True, exist_ok=True)
+
+APP_NAME = "pymagnetos"
+LOGGING_FORMAT = "{asctime}.{msecs:3g} [{levelname}] : {message}"
+CONSOLE_HANDLER = RichHandler(log_time_format="%H:%m:%S.%f")
+FILE_FORMATTER = logging.Formatter(
+    LOGGING_FORMAT, style="{", datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+
+def configure_logger(
+    logger: logging.Logger, filename: str, log_level: str = "INFO"
+) -> None:
+    """
+    Configure logger handlers.
+
+    Parameters
+    ----------
+    filename : str
+        Name of the file in which log will be written to. The file will be created under
+        $HOME/.pymagnetos/.
+    log_level : str, optional
+        Logging level to choose from ("DEBUG", "INFO", "WARNING", "ERROR"). Default is
+        "INFO".
+    """
+    # Define the file handler
+    log_file = APP_DIR / filename
+    file_handler = RotatingFileHandler(
+        log_file, mode="a", encoding="utf-8", maxBytes=int(1e6), backupCount=1
+    )
+    file_handler.setLevel(log_level)
+    file_handler.setFormatter(FILE_FORMATTER)
+
+    # Add handlers and set log levels
+    remove_file_handlers(logger, log_file, mode="same")
+    CONSOLE_HANDLER.setLevel(log_level)
+    logger.addHandler(CONSOLE_HANDLER)
+    logger.addHandler(file_handler)
+    logger.setLevel(log_level)
+
+    # Get the core logger and add the same handlers
+    core_logger = logging.getLogger(APP_NAME + ".core")
+    remove_file_handlers(core_logger, str(log_file), mode="all")
+    core_logger.addHandler(CONSOLE_HANDLER)
+    core_logger.addHandler(file_handler)
+    core_logger.setLevel(log_level)
+
+    # Set the logger to log exceptions
+    log_uncaugth_exceptions(logger)
+
+    logger.info(f"Logging to {log_file}")
+
+
+def remove_file_handlers(
+    logger: logging.Logger,
+    file: str | Path,
+    mode: Literal["same", "all"] = "same",
+    warn: bool = True,
+) -> None:
+    """
+    Remove file handlers from a logger.
+
+    In mode "same", only handlers that log to the same file will be removed, in mode
+    "all", all file handlers are removed.
+
+    Parameters
+    ----------
+    logger : logging.Logger
+        Logger instance.
+    file : str or Path
+        Path to the log file.
+    mode : {"same", "all"}, optional
+        "same" : remove the handler only if it logs to the same file (default).
+        "all": remove all file handlers.
+    warn : bool, optional
+        Issue a warning when removing a handler set to a different file. Default is
+        True.
+    """
+    file = str(file)
+    for idx in range(len(logger.handlers)):
+        handler = logger.handlers[idx]
+        if isinstance(handler, logging.FileHandler):
+            if handler.baseFilename == file:
+                logger.removeHandler(handler)
+            else:
+                if mode == "all":
+                    if warn:
+                        warnings.warn(
+                            f"The logger was writing to {handler.baseFilename}, "
+                            "it will stop"
+                        )
+                    logger.removeHandler(handler)
+
+
+def log_uncaugth_exceptions(logger: logging.Logger) -> None:
+    """Make uncaugth exceptions to be logged by the logger."""
+
+    def handle_exception(
+        exc_type: type[BaseException],
+        exc_value: BaseException,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        if not issubclass(exc_type, KeyboardInterrupt):
+            logger.critical(
+                "Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)
+            )
+
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+
+    sys.excepthook = handle_exception

pymagnetos/pytdo/__init__.py

@@ -0,0 +1,6 @@
+"""The `pytdo` module, an app for TDO experiments."""
+
+from ._config import TDOConfig
+from ._tdoprocessor import TDOProcessor
+
+__all__ = ["TDOConfig", "TDOProcessor"]

pymagnetos/pytdo/_config.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Any
+
+from ..core import BaseConfig
+from ._config_models import TDOConfiguration
+
+CONFIG_DEFAULT = Path(__file__).parent / "assets" / "config_default.toml"
+
+
+class TDOConfig(BaseConfig):
+    def __init__(
+        self,
+        user_file: str | Path | None = None,
+        default_file: str | Path | None = None,
+        **overrides: Any,
+    ) -> None:
+        if not default_file:
+            default_file = CONFIG_DEFAULT
+
+        super().__init__(TDOConfiguration, user_file, default_file, **overrides)
+
+    @classmethod
+    def loads(cls, json_data: str | bytes, **kwargs) -> "TDOConfig":
+        return super()._loads(TDOConfiguration, json_data, **kwargs)

pymagnetos/pytdo/_config_models.py

@@ -0,0 +1,59 @@
+"""Pydantic models for the TDOProcessor Config."""
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from ..core.config_models import File, Metadata, Nexus, Parameters
+
+
+class Settings(BaseModel):
+    """Settings for signal extraction, analysis and plotting."""
+
+    # Extraction
+    max_time: float
+
+    spectro_nperseg: int
+    spectro_win_size: int
+    spectro_noverlap: int
+
+    barycenters_fwindow: float
+    barycenters_fast: bool
+
+    time_offset: float
+
+    # Analysis
+    poly_window: Sequence[float]
+    poly_deg: int
+    npoints_interp_inverse: int
+    fft_window: Sequence[float]
+    fft_pad_mult: int
+    max_bfreq: float
+
+    # Display
+    offset: float
+
+
+class TDOConfiguration(BaseModel):
+    """A model specialized for TDO experiments."""
+
+    expid: str
+    data_directory: Path
+
+    filenames: dict[str, str | Path] = dict()
+
+    files: dict[str, File]
+
+    measurements: dict[str, int]
+
+    parameters: Parameters
+    settings: Settings
+
+    metadata: Metadata
+
+    nx: dict[str, dict[str, Any]]
+    nexus: Nexus
+
+    model_config = ConfigDict(validate_assignment=True)