pytestlab 0.2.1__py3-none-any.whl

pytestlab/__init__.py

@@ -0,0 +1,69 @@
+"""
+pytestlab – scientific measurement toolbox
+=========================================
+
+This file now **re-exports** the new high-level measurement builder so that
+users can simply write
+
+>>> from pytestlab import Measurement
+
+or
+
+>>> from pytestlab.measurements import Measurement
+"""
+
+__version__ = "0.2.1"  # Update this line to change the version
+
+from importlib import metadata as _metadata
+import logging # Required for set_log_level
+from ._log import get_logger, set_log_level, reinitialize_logging
+
+
+
+# ─── Public re-exports from existing sub-packages ──────────────────────────
+from .config import *
+from .experiments import *
+from .instruments import *
+from .errors import *
+from .bench import Bench
+
+# ─── New high-level builder ────────────────────────────────────────────────
+from .measurements.session import Measurement, MeasurementSession  # noqa: E402  pylint: disable=wrong-import-position
+
+__all__ = [
+    # Config
+    "OscilloscopeConfig",
+    "MultimeterConfig",
+    "PowerSupplyConfig",
+    "WaveformGeneratorConfig",
+    # Instruments
+    "Oscilloscope",
+    "Multimeter",
+    "PowerSupply",
+    "WaveformGenerator",
+    "AutoInstrument",
+    "InstrumentManager",
+    # Experiments
+    "Experiment",
+    "MeasurementResult",
+    # Errors
+    "InstrumentError",
+    "InstrumentConfigurationError",
+    "InstrumentParameterError",
+    # Bench System
+    "Bench",
+    # New measurement system
+    "Measurement",
+    "MeasurementSession",
+    "set_log_level",
+]
+
+# Version is defined statically above, but we can still try to get it from metadata
+# try:  # pragma: no cover
+#     __version__ = _metadata.version(__name__)
+# except _metadata.PackageNotFoundError:  # pragma: no cover
+#     __version__ = "0.1.0"
+
+# needs to be imported after the MeasurementResult class is defined
+from . import compliance
+compliance.initialize()

pytestlab/_log.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+import logging
+import sys
+import os
+
+_root_logger = logging.getLogger("pytestlab")
+
+def setup_logging():
+    """
+    Set up logging for pytestlab.
+    This function is called automatically when the first logger is requested.
+    It can also be called manually to reconfigure logging.
+    """
+    level_name = os.getenv("PYTESTLAB_LOG_LEVEL", os.getenv("PYTESTLAB_LOG", "WARNING")).upper()
+    log_level = getattr(logging, level_name, logging.WARNING)
+    log_file = os.getenv("PYTESTLAB_LOG_FILE")
+
+    # Remove all handlers from our logger to reconfigure
+    for handler in _root_logger.handlers[:]:
+        _root_logger.removeHandler(handler)
+
+    if log_file:
+        handler: logging.Handler = logging.FileHandler(log_file)
+    else:
+        handler = logging.StreamHandler(sys.stderr)
+
+    formatter = logging.Formatter("%(asctime)s %(name)s %(levelname)s – %(message)s")
+    handler.setFormatter(formatter)
+    _root_logger.addHandler(handler)
+    _root_logger.setLevel(log_level)
+    # Enable propagation so pytest caplog can capture logs
+    _root_logger.propagate = True
+
+def reinitialize_logging():
+    """
+    Reinitialize logging configuration, useful for tests that modify environment variables.
+    """
+    setup_logging()
+
+def set_log_level(level: int | str):
+    """
+    Sets the logging level for the pytestlab logger.
+    :param level: The logging level, e.g., "DEBUG", "INFO", logging.DEBUG, logging.INFO.
+    """
+    try:
+        if isinstance(level, str):
+            level = level.upper()
+        _root_logger.setLevel(level)
+    except ValueError as e:
+        # Log the warning and keep the current level
+        _root_logger.warning(f"Invalid log level: {level}")
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Retrieves a logger instance, configuring the root logger on first call.
+    """
+    if not _root_logger.handlers:
+        setup_logging()
+    return _root_logger.getChild(name)
+
+# Initial setup when module is loaded.
+setup_logging()

pytestlab/analysis/__init__.py

@@ -0,0 +1,7 @@
+# PyTestLab Analysis Submodule
+# This submodule contains common signal processing and analysis functions.
+
+__all__ = ["fft", "fr_analysis"]
+
+from . import fft
+from . import fr_analysis

pytestlab/analysis/fft.py

@@ -0,0 +1,91 @@
+# pytestlab/analysis/fft.py
+import numpy as np
+from typing import Tuple, Optional
+
+def compute_fft(
+    time_array: np.ndarray, 
+    voltage_array: np.ndarray, 
+    window: Optional[str] = 'hann' # Example: allow windowing
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Computes the Fast Fourier Transform (FFT) of a given time-domain signal.
+
+    Args:
+        time_array: NumPy array of time values.
+        voltage_array: NumPy array of voltage (or other signal) values.
+        window: Optional windowing function to apply before FFT (e.g., 'hann', 'hamming').
+                Set to None or an empty string to disable windowing.
+
+    Returns:
+        A tuple containing:
+            - frequency_array: NumPy array of frequency bins.
+            - magnitude_array: NumPy array of FFT magnitudes (linear).
+    """
+    # Ensure time_array and voltage_array are of the same size
+    if not isinstance(time_array, np.ndarray) or not isinstance(voltage_array, np.ndarray):
+        raise TypeError("Input arrays must be NumPy ndarrays.")
+    if time_array.size != voltage_array.size:
+        raise ValueError("Time and voltage arrays must have the same size.")
+    if time_array.ndim != 1 or voltage_array.ndim != 1:
+        raise ValueError("Input arrays must be 1-dimensional.")
+    
+    N = voltage_array.size
+    if N == 0:
+        return np.array([]), np.array([])
+    if N <= 1: # FFT not meaningful for 0 or 1 sample
+            return np.array([]), np.array([])
+
+    # Apply windowing if specified
+    if window:
+        if window == 'hann':
+            voltage_array_windowed = voltage_array * np.hanning(N)
+        elif window == 'hamming':
+            voltage_array_windowed = voltage_array * np.hamming(N)
+        # Add other windows or raise error for unsupported window
+        # elif window is None or window == '': # No window
+        #    voltage_array_windowed = voltage_array
+        else:
+            raise ValueError(f"Unsupported window function: {window}. Supported: 'hann', 'hamming', None.")
+    else: # No window
+        voltage_array_windowed = voltage_array
+
+
+    # Compute FFT
+    fft_values = np.fft.fft(voltage_array_windowed)
+    # Take only positive frequencies (first N // 2 points)
+    # For real inputs, the FFT is symmetric, so we only need half.
+    fft_magnitudes = np.abs(fft_values)[:N // 2]
+
+    # Compute frequency bins
+    # This requires sampling frequency Fs.
+    # A more robust way if time_array is uniformly spaced:
+    if N > 1 and (time_array[-1] - time_array[0]) > 0:
+            # Total duration T = time_array[-1] - time_array[0]
+            # Number of sampling intervals = N - 1
+            # Sampling interval dt = T / (N - 1)
+            # Sampling frequency Fs = 1 / dt = (N - 1) / T
+            dt = (time_array[-1] - time_array[0]) / (N - 1)
+            if dt <= 0: # Avoid division by zero or negative dt if time_array is not monotonic
+                # This case should ideally be caught by pre-checks or handled by requiring Fs
+                return np.array([]), np.array([]) 
+            Fs = 1 / dt
+    elif N == 1 and time_array.size == 1: # Single point, Fs is undefined, Nyquist is 0
+        # Return empty or a specific representation for a single point "spectrum"
+        # For FFT, typically need >1 points.
+        # Or, if Fs is *known* (e.g. from instrument settings), it could be passed in.
+        # For now, aligning with N<=1 check above.
+        return np.array([]), np.array([])
+    else: # Cannot determine Fs (e.g., N > 1 but time_array[-1] == time_array[0]), or N is too small
+            # Or if time_array is not sorted, (time_array[-1] - time_array[0]) could be non-positive.
+            # Consider requiring Fs as an input for more robustness if time_array properties are not guaranteed.
+            # For now, returning empty as a safe default.
+            return np.array([]), np.array([])
+
+
+    # d = sampling interval = 1/Fs
+    frequency_array = np.fft.fftfreq(N, d=1/Fs)[:N // 2]
+
+    # fft_magnitudes are linear. User can convert to dB if needed:
+    # fft_magnitudes_db = 20 * np.log10(fft_magnitudes)
+
+    return frequency_array, fft_magnitudes

pytestlab/analysis/fr_analysis.py

@@ -0,0 +1,38 @@
+# pytestlab/analysis/fr_analysis.py
+# Placeholder for Frequency Response Analysis functions.
+
+# Example conceptual function (not implemented yet):
+# import numpy as np
+# from typing import Tuple
+#
+# def compute_frequency_response(
+#     input_time_array: np.ndarray,
+#     input_voltage_array: np.ndarray,
+#     output_time_array: np.ndarray,
+#     output_voltage_array: np.ndarray,
+#     window: Optional[str] = 'hann'
+# ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+#     """
+#     Computes the frequency response (e.g., gain and phase) from input and output signals.
+#
+#     Args:
+#         input_time_array: NumPy array of time values for the input signal.
+#         input_voltage_array: NumPy array of voltage values for the input signal.
+#         output_time_array: NumPy array of time values for the output signal.
+#         output_voltage_array: NumPy array of voltage values for the output signal.
+#         window: Optional windowing function to apply before FFT.
+#
+#     Returns:
+#         A tuple containing:
+#             - frequency_array: NumPy array of frequency bins.
+#             - gain_array: NumPy array of gain values (e.g., in dB).
+#             - phase_array: NumPy array of phase values (e.g., in degrees or radians).
+#     """
+#     # This would involve:
+#     # 1. Aligning or ensuring consistent sampling of input and output signals.
+#     # 2. Computing FFT of both input and output signals (e.g., using compute_fft from .fft).
+#     # 3. Calculating the transfer function H(f) = FFT(output) / FFT(input).
+#     # 4. Deriving gain (magnitude of H(f)) and phase (angle of H(f)).
+#     pass
+
+__all__ = [] # No functions exported yet