Saving/loading

def load_measurement(
    path: str | Path,
) -> Measurement:
    """Load a measurement from a session file (`.pssession`).

    To load multiple measurements, use [pypalmsens.load_session_file][].

    Parameters
    ----------
    path : Path | str
        Path to session file

    Returns
    -------
    measurement : Measurement
        Return measurement
    """
    measurements = load_session_file(path)

    if n := len(measurements) > 1:
        raise ValueError(
            f'File contains {n} measurements. Use `load_session_file()` to access all of them.'
        )

    return measurements[0]

def load_method_file(path: str | Path) -> MethodType:
    """Load a method file (.psmethod).

    Parameters
    ----------
    path : Path | str
        Path to method file

    Returns
    -------
    method : MethodType
        Return method parameters
    """
    method = _load_method_file(path)
    return method.to_settings()

def load_session_file(
    path: str | Path,
) -> list[Measurement]:
    """Load a session file (`.pssession`).

    Parameters
    ----------
    path : Path | str
        Path to session file

    Returns
    -------
    measurements : list[Measurement]
        Return list of measurements
    """
    path = Path(path)

    session = PalmSens.Data.SessionManager()

    try:
        with stream_reader(str(path), encoding=Encoding.Unicode) as stream:
            session.Load(stream.BaseStream, str(path))
    except System.IO.FileNotFoundException as exc:
        raise FileNotFoundError(exc.Message) from exc

    session.MethodForEditor.MethodFilename = str(path.absolute())

    for psmeasurement in session:
        psmeasurement.Method.MethodFilename = str(path.absolute())

    return [Measurement(psmeasurement=m) for m in session]

def load_stream_file(path: str | Path) -> Measurement:
    """Load JSON lines (filetype: jsonl) stream file.

    See also: https://jsonlines.org/

    Returns
    -------
    measurement : Measurement
        Dataclass containing data from jsonl file.
        The data structure mimicks `pypalmsens.data.measurement`.

    """
    measurement_metadata = None

    data_rows = defaultdict(list)
    curves_metadata = {}
    eisdatas_metadata = {}

    with open(path, encoding='utf-8') as lines:
        for i, line in enumerate(lines):
            parsed: Any = TypeAdapter(
                DataRow | CurveMetadata | EISDataMetadata | MeasurementMetadata
            ).validate_json(line)

            if isinstance(parsed, DataRow):
                data_rows[parsed.id].append(parsed.data)
            elif isinstance(parsed, CurveMetadata):
                curves_metadata[parsed.id] = parsed
            elif isinstance(parsed, MeasurementMetadata):
                measurement_metadata = parsed
            elif isinstance(parsed, EISDataMetadata):
                eisdatas_metadata[parsed.id] = parsed
            else:
                raise TypeError(f'Could not parse line {i}: {parsed}')

    assert measurement_metadata

    measurement = Measurement(metadata=measurement_metadata)

    for curve_id, curve_metadata in curves_metadata.items():
        data = [row for row in data_rows[curve_id]]
        curve = Curve(metadata=curve_metadata, data=data)
        measurement.curves.append(curve)

    for eisdata_id, eisdata_metadata in eisdatas_metadata.items():
        data = [row for row in data_rows[eisdata_id]]
        eis_data = EISData(metadata=eisdata_metadata, data=data)
        measurement.eis_data.append(eis_data)

    return measurement

def save_measurement(path: str | Path, measurement: Measurement):
    """Save measurement a session file (`.pssession`).

    To save multiple measurements, use [pypalmsens.save_session_file][].

    Parameters
    ----------
    path : Path | str
        Path to save the session file
    measurement : Measurement
        Measurements to save
    """
    if isinstance(measurement, Sequence):
        raise TypeError('To save multiple measurements, use pypalmsens.save_session_file().')

    save_session_file(path, [measurement])

def save_method_file(path: str | Path, method: MethodType):
    """Load a method file (.psmethod).

    Parameters
    ----------
    path : Path | str
        Path to save the method file
    method : MethodType
        Method to save
    """
    data = method._serialize()

    with open(path, 'w') as f:
        _ = f.write(data)

def save_session_file(path: str | Path, measurements: Sequence[Measurement]):
    """Save multiple measurements a session file (`.pssession`).

    Parameters
    ----------
    path : Path | str
        Path to save the session file
    measurements : Sequence[Measurement]
        List of measurements to save
    """
    path = Path(path)

    if any((measurement is None) for measurement in measurements):
        raise ValueError('cannot save null measurement')

    session = PalmSens.Data.SessionManager()
    session.MethodForEditor = measurements[0]._psmeasurement.Method
    session.MethodForEditor.MethodFilename = str(path.absolute())

    for measurement in measurements:
        session.AddMeasurement(measurement._psmeasurement)

    with stream_writer(str(path), append=False, encoding=Encoding.Unicode) as stream:
        session.Save(stream.BaseStream, str(path))