qupled 1.3.2__cp313-cp313-macosx_14_0_arm64.whl → 1.3.4__cp313-cp313-macosx_14_0_arm64.whl

qupled/qstls.py

@@ -2,20 +2,22 @@ from __future__ import annotations
 
 from . import database
 from . import native
+from . import serialize
 from . import stls
 
 
-class Qstls(stls.Stls):
+class Solver(stls.Solver):
     """
     Class used to solve the Qstls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Qstls
+    native_inputs_cls = native.QstlsInput
+
     def __init__(self):
         super().__init__()
         self.results: stls.Result = stls.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.Qstls
-        self.native_inputs_cls = native.QstlsInput
 
     def compute(self, inputs: Input):
         self.find_fixed_adr_in_database(inputs)
@@ -55,14 +57,15 @@ class Qstls(stls.Stls):
                 return
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(stls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qstls.Qstls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        # Undocumented default values
-        self.fixed_run_id: int | None = None
-        self.theory = "QSTLS"
+    fixed_run_id: int | None = None
+    theory: str = "QSTLS"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, stls.Result)

qupled/qstlsiet.py

@@ -2,36 +2,39 @@ from __future__ import annotations
 
 from . import native
 from . import qstls
+from . import serialize
 from . import stlsiet
 
 
-class QstlsIet(qstls.Qstls):
+class Solver(qstls.Solver):
     """
     Class used to solve the Qstls-IET schemes.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.QstlsIet
+    native_inputs_cls = native.QstlsIetInput
+
     def __init__(self):
         super().__init__()
         self.results: stlsiet.Result = stlsiet.Result()
-        self.native_scheme_cls = native.QstlsIet
-        self.native_inputs_cls = native.QstlsIetInput
 
     @staticmethod
     def get_initial_guess(
         run_id: str, database_name: str | None = None
     ) -> stlsiet.Guess:
-        return stlsiet.StlsIet.get_initial_guess(run_id, database_name)
+        return stlsiet.Solver.get_initial_guess(run_id, database_name)
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(stlsiet.Input, qstls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qstlsiet.QStlsIet` class.
     Accepted theories: ``QSTLS-HNC``, ``QSTLS-IOI`` and ``QSTLS-LCT``.
     """
 
-    def __init__(self, coupling: float, degeneracy: float, theory: str):
-        super().__init__(coupling, degeneracy, "STLS-HNC")
-        if theory not in {"QSTLS-HNC", "QSTLS-IOI", "QSTLS-LCT"}:
-            raise ValueError("Invalid dielectric theory")
-        self.theory = theory
+    allowed_theories = {"QSTLS-HNC", "QSTLS-IOI", "QSTLS-LCT"}
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, stlsiet.Result)

qupled/qvsstls.py

@@ -3,19 +3,21 @@ from __future__ import annotations
 from . import native
 from . import qstls
 from . import vsstls
+from . import serialize
 
 
-class QVSStls(vsstls.VSStls):
+class Solver(vsstls.Solver):
     """
     Class used to solve the QVStls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.QVSStls
+    native_inputs_cls = native.QVSStlsInput
+
     def __init__(self):
         super().__init__()
         self.results: vsstls.Result = vsstls.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.QVSStls
-        self.native_inputs_cls = native.QVSStlsInput
 
     def compute(self, inputs: Input):
         """
@@ -24,7 +26,7 @@ class QVSStls(vsstls.VSStls):
         Args:
             inputs: Input parameters.
         """
-        qstls.Qstls.find_fixed_adr_in_database(self, inputs)
+        qstls.Solver.find_fixed_adr_in_database(self, inputs)
         super().compute(inputs)
 
     def _update_input_data(self, inputs: Input):
@@ -46,14 +48,14 @@ class QVSStls(vsstls.VSStls):
             inputs.fixed_run_id = self.run_id
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(vsstls.Input, qstls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qvsstls.QVSStls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        vsstls.Input.__init__(self, coupling, degeneracy)
-        qstls.Input.__init__(self, coupling, degeneracy)
-        # Undocumented default values
-        self.theory: str = "QVSSTLS"
+    theory: str = "QVSSTLS"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, vsstls.Result)

qupled/rpa.py

@@ -2,26 +2,30 @@ from __future__ import annotations
 
 from . import hf
 from . import native
+from . import serialize
 
 
-class Rpa(hf.HF):
+class Solver(hf.Solver):
     """
     Class used to solve the RPA scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Rpa
+
     def __init__(self):
         super().__init__()
         self.results: hf.Result = hf.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.Rpa
 
 
+@serialize.serializable_dataclass
 class Input(hf.Input):
     """
     Class used to manage the input for the :obj:`qupled.rpa.Rpa` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        # Undocumented default values
-        self.theory = "RPA"
+    theory: str = "RPA"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, hf.Result)

qupled/serialize.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from dataclasses import dataclass
+from typing import get_type_hints
+
+
+def serializable_dataclass(cls):
+
+    cls = dataclass(cls)
+
+    def to_dict(self):
+        result = {}
+        for key, value in self.__dict__.items():
+            if hasattr(value, "to_dict") and callable(value.to_dict):
+                result[key] = value.to_dict()
+            elif isinstance(value, np.ndarray):
+                result[key] = value.tolist()
+            else:
+                result[key] = value
+        return result
+
+    @classmethod
+    def from_dict(cls, d):
+        obj = cls.__new__(cls)
+        annotations = get_type_hints(cls)
+        for key, value in d.items():
+            expected_type = annotations.get(key)
+            from_dict_fn = getattr(expected_type, "from_dict", None)
+            convert_to_np_array = expected_type is np.ndarray and isinstance(
+                value, list
+            )
+            call_from_dict = callable(from_dict_fn) and isinstance(value, dict)
+            if convert_to_np_array:
+                setattr(obj, key, np.array(value))
+            elif call_from_dict:
+                setattr(obj, key, from_dict_fn(value))
+            else:
+                setattr(obj, key, value)
+        return obj
+
+    cls.to_dict = to_dict
+    cls.from_dict = from_dict
+    return cls

qupled/stls.py

@@ -1,24 +1,27 @@
 from __future__ import annotations
 
+from dataclasses import field
 import numpy as np
 
 from . import hf
 from . import native
 from . import output
 from . import rpa
+from . import serialize
 
 
-class Stls(rpa.Rpa):
+class Solver(rpa.Solver):
     """
     Class used to solve the Stls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Stls
+    native_inputs_cls = native.StlsInput
+
     def __init__(self):
         super().__init__()
         self.results: Result = Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.Stls
-        self.native_inputs_cls = native.StlsInput
 
     @staticmethod
     def get_initial_guess(run_id: int, database_name: str | None = None) -> Guess:
@@ -37,43 +40,39 @@ class Stls(rpa.Rpa):
         return Guess(data[names[0]], data[names[1]])
 
 
+@serialize.serializable_dataclass
 class Input(rpa.Input):
     """
     Class used to manage the input for the :obj:`qupled.stls.Stls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        self.error: float = 1.0e-5
-        """Minimum error for convergence. Default = ``1.0e-5``"""
-        self.mixing: float = 1.0
-        """Mixing parameter. Default = ``1.0``"""
-        self.iterations: int = 1000
-        """Maximum number of iterations. Default = ``1000``"""
-        self.guess: Guess = Guess()
-        """Initial guess. Default = ``stls.Guess()``"""
-        # Undocumented default values
-        self.theory: str = "STLS"
+    error: float = 1.0e-5
+    """Minimum error for convergence. Default = ``1.0e-5``"""
+    mixing: float = 1.0
+    """Mixing parameter. Default = ``1.0``"""
+    iterations: int = 1000
+    """Maximum number of iterations. Default = ``1000``"""
+    guess: Guess = field(default_factory=lambda: Guess())
+    """Initial guess. Default = ``stls.Guess()``"""
+    theory: str = "STLS"
 
 
+@serialize.serializable_dataclass
 class Result(hf.Result):
     """
     Class used to store the results for the :obj:`qupled.stls.Stls` class.
     """
 
-    def __init__(self):
-        super().__init__()
-        self.error: float = None
-        """Residual error in the solution"""
+    error: float = None
+    """Final error of the scheme. Default = ``None``"""
 
 
+@serialize.serializable_dataclass
 class Guess:
-
-    def __init__(self, wvg: np.ndarray = None, ssf: np.ndarray = None):
-        self.wvg = wvg
-        """ Wave-vector grid. Default = ``None``"""
-        self.ssf = ssf
-        """ Static structure factor. Default = ``None``"""
+    wvg: np.ndarray = None
+    """Wave-vector grid. Default = ``None``"""
+    ssf: np.ndarray = None
+    """Static structure factor. Default = ``None``"""
 
     def to_native(self) -> native.Guess:
         """
@@ -92,3 +91,7 @@ class Guess:
             if value is not None:
                 setattr(native_guess, attr, value)
         return native_guess
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, Result)

qupled/stlsiet.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 
+from dataclasses import field
 import numpy as np
 
 from . import native
 from . import output
 from . import stls
+from . import serialize
 
 
-class StlsIet(stls.Stls):
+class Solver(stls.Solver):
     """
     Class used to solve the StlsIet schemes.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.StlsIet
+    native_inputs_cls = native.StlsIetInput
+
     def __init__(self):
         super().__init__()
         self.results: Result = Result()
-        self.native_scheme_cls = native.StlsIet
-        self.native_inputs_cls = native.StlsIetInput
 
     @staticmethod
     def get_initial_guess(run_id: str, database_name: str | None = None) -> Guess:
@@ -42,19 +46,15 @@ class StlsIet(stls.Stls):
         )
 
 
+@serialize.serializable_dataclass
 class Input(stls.Input):
     """
     Class used to manage the input for the :obj:`qupled.stlsiet.StlsIet` class.
     Accepted theories: ``STLS-HNC``, ``STLS-IOI`` and ``STLS-LCT``.
     """
 
-    def __init__(self, coupling: float, degeneracy: float, theory: str):
-        super().__init__(coupling, degeneracy)
-        if theory not in {"STLS-HNC", "STLS-IOI", "STLS-LCT"}:
-            raise ValueError("Invalid dielectric theory")
-        self.theory = theory
-        self.mapping = "standard"
-        r"""
+    mapping: str = "standard"
+    r"""
         Mapping for the classical-to-quantum coupling parameter
         :math:`\Gamma` used in the iet schemes. Allowed options include:
 
@@ -69,29 +69,38 @@ class Input(stls.Input):
         the ground state they can differ significantly (the standard
         mapping diverges). Default = ``standard``.
         """
-        self.guess: Guess = Guess()
-        """Initial guess. Default = ``stlsiet.Guess()``"""
+    guess: Guess = field(default_factory=lambda: Guess())
+    allowed_theories = {"STLS-HNC", "STLS-IOI", "STLS-LCT"}
+
+    def __post_init__(self):
+        if self.is_default_theory():
+            raise ValueError(
+                f"Missing dielectric theory, choose among {self.allowed_theories} "
+            )
+        if self.theory not in self.allowed_theories:
+            raise ValueError(
+                f"Invalid dielectric theory {self.theory}, choose among {self.allowed_theories}"
+            )
+
+    def is_default_theory(self) -> bool:
+        return self.theory == Input.__dataclass_fields__["theory"].default
 
 
+@serialize.serializable_dataclass
 class Result(stls.Result):
     """
     Class used to store the results for the :obj:`qupled.stlsiet.StlsIet` class.
     """
 
-    def __init__(self):
-        super().__init__()
-        self.bf: np.ndarray = None
-        """Bridge function adder"""
+    bf: np.ndarray = None
+    """Bridge function adder"""
 
 
+@serialize.serializable_dataclass
 class Guess(stls.Guess):
+    lfc: np.ndarray = None
+    """ Local field correction. Default = ``None``"""
+
 
-    def __init__(
-        self,
-        wvg: np.ndarray = None,
-        ssf: np.ndarray = None,
-        lfc: np.ndarray = None,
-    ):
-        super().__init__(wvg, ssf)
-        self.lfc = lfc
-        """ Local field correction. Default = ``None``"""
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, Result)

qupled/timer.py

@@ -0,0 +1,33 @@
+import time
+
+
+def timer(func):
+    """
+    A decorator that measures and prints the execution time of the decorated function.
+
+    The elapsed time is displayed in hours, minutes, and seconds as appropriate.
+
+    Args:
+        func (callable): The function whose execution time is to be measured.
+
+    Returns:
+        callable: A wrapper function that executes the original function and prints the elapsed time.
+    """
+
+    def wrapper(*args, **kwargs):
+        tic = time.perf_counter()
+        result = func(*args, **kwargs)
+        toc = time.perf_counter()
+        dt = toc - tic
+        hours = int(dt // 3600)
+        minutes = int((dt % 3600) // 60)
+        seconds = dt % 60
+        if hours > 0:
+            print(f"Elapsed time: {hours} h, {minutes} m, {seconds:.1f} s.")
+        elif minutes > 0:
+            print(f"Elapsed time: {minutes} m, {seconds:.1f} s.")
+        else:
+            print(f"Elapsed time: {seconds:.1f} s.")
+        return result
+
+    return wrapper

qupled/vsstls.py

@@ -1,23 +1,26 @@
 from __future__ import annotations
 
+from dataclasses import field
 import numpy as np
 
 from . import native
 from . import output
+from . import serialize
 from . import stls
 
 
-class VSStls(stls.Stls):
+class Solver(stls.Solver):
     """
     Class used to solve the VSStls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.VSStls
+    native_inputs_cls = native.VSStlsInput
+
     def __init__(self):
         super().__init__()
         self.results: Result = Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.VSStls
-        self.native_inputs_cls = native.VSStlsInput
 
     def compute(self, inputs: Input):
         """
@@ -130,58 +133,53 @@ class VSStls(stls.Stls):
         return FreeEnergyIntegrand(data[names[0]], data[names[1]])
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(stls.Input):
     """
     Class used to manage the input for the :obj:`qupled.vsstls.VSStls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        self.alpha: list[float] = [0.5, 1.0]
-        """Initial guess for the free parameter. Default = ``[0.5, 1.0]``"""
-        self.coupling_resolution: float = 0.1
-        """Resolution of the coupling parameter grid. Default = ``0.1``"""
-        self.degeneracy_resolution: float = 0.1
-        """Resolution of the degeneracy parameter grid. Default = ``0.1``"""
-        self.error_alpha: float = 1.0e-3
-        """Minimum error for convergence in the free parameter. Default = ``1.0e-3``"""
-        self.iterations_alpha: int = 50
-        """Maximum number of iterations to determine the free parameter. Default = ``50``"""
-        self.free_energy_integrand: FreeEnergyIntegrand = FreeEnergyIntegrand()
-        """Pre-computed free energy integrand."""
-        self.threads: int = 9
-        """Number of threads. Default = ``9``"""
-        # Undocumented default values
-        self.theory: str = "VSSTLS"
-
-
+    alpha: list[float] = field(default_factory=lambda: [0.5, 1.0])
+    """Initial guess for the free parameter. Default = ``[0.5, 1.0]``"""
+    coupling_resolution: float = 0.1
+    """Resolution of the coupling parameter grid. Default = ``0.1``"""
+    degeneracy_resolution: float = 0.1
+    """Resolution of the degeneracy parameter grid. Default = ``0.1``"""
+    error_alpha: float = 1.0e-3
+    """Minimum error for convergence in the free parameter. Default = ``1.0e-3``"""
+    iterations_alpha: int = 50
+    """Maximum number of iterations to determine the free parameter. Default = ``50``"""
+    free_energy_integrand: FreeEnergyIntegrand = field(
+        default_factory=lambda: FreeEnergyIntegrand()
+    )
+    """Pre-computed free energy integrand."""
+    threads: int = 9
+    """Number of threads. Default = ``9``"""
+    # Undocumented default values
+    theory: str = "VSSTLS"
+
+
+@serialize.serializable_dataclass
 class Result(stls.Result):
     """
     Class used to store the results for the :obj:`qupled.vsstls.VSStls` class.
     """
 
-    def __init__(self):
-        super().__init__()
-        self.free_energy_grid = None
-        """Free energy grid"""
-        self.free_energy_integrand = None
-        """Free energy integrand"""
-        self.alpha = None
-        """Free parameter"""
+    free_energy_grid: np.ndarray = None
+    """Free energy grid"""
+    free_energy_integrand: np.ndarray = None
+    """Free energy integrand"""
+    alpha: float = None
+    """Free parameter"""
 
 
+@serialize.serializable_dataclass
 class FreeEnergyIntegrand:
 
-    def __init__(
-        self,
-        grid: np.ndarray | None = None,
-        integrand: np.ndarray | None = None,
-    ):
-        self.grid = grid
-        """ Coupling parameter grid. Default = ``None``"""
-        self.integrand = integrand
-        """ Free energy integrand. Default = ``None``"""
+    grid: np.ndarray = None
+    """ Coupling parameter grid. Default = ``None``"""
+    integrand: np.ndarray = None
+    """ Free energy integrand. Default = ``None``"""
 
     def to_native(self) -> native.FreeEnergyIntegrand:
         """
@@ -201,3 +199,7 @@ class FreeEnergyIntegrand:
             if value is not None:
                 setattr(native_guess, attr, value)
         return native_guess
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, Result)

{qupled-1.3.2.dist-info → qupled-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qupled
-Version: 1.3.2
+Version: 1.3.4
 Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
 Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
 License-Expression: GPL-3.0-or-later

qupled-1.3.4.dist-info/RECORD

@@ -0,0 +1,45 @@
+qupled-1.3.4.dist-info/RECORD,,
+qupled-1.3.4.dist-info/WHEEL,sha256=ZQJAUvKl3_G657Vy_VrVH7Krx2Keg1PVu64bdERsotU,136
+qupled-1.3.4.dist-info/top_level.txt,sha256=HLJfvnCPZQVptCRuekWA_3Z98SMkCNCXViGiGh8VenA,7
+qupled-1.3.4.dist-info/METADATA,sha256=d75nW7MqQlfhF7evEanAi4GrVI2YqjjOdhmh241ptxA,4559
+qupled-1.3.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+qupled/qstls.py,sha256=G2A5e_PUP1lsUaKEajrH3ZuY2lD5wxmsyYi8n7IN6nQ,2424
+qupled/serialize.py,sha256=uNGQnAE2ABQnWSV-yjtEecByaaW1OzQ7I_Hp7g6z-_0,1325
+qupled/rpa.py,sha256=5QwdMpqEj8WIR3Ncu605XzNr2Cw3afpqrK3OXSkgCPs,606
+qupled/timer.py,sha256=q1X9mpvSaq2NxFk6P22ceclTSd2tkdofF1lPdENLuJ8,985
+qupled/database.py,sha256=soPmbMpIYS7oELwOKU-W61LtwxLwu5xvwOFTb7LXzdI,26636
+qupled/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+qupled/stlsiet.py,sha256=4zJMMhz1lmqcAGVz2OqwDKZa00jD1wJ5TXnW7siFKbs,3254
+qupled/native.cpython-313-darwin.so,sha256=E1vlGpL0bc6DvApY4_tYJoq1ST8-9FDgbOmv2wgWKLQ,748880
+qupled/qstlsiet.py,sha256=UInCZT6jpTot8TQ6arpgqNMIg_KetCf3NL1r5xwxZhw,1039
+qupled/esa.py,sha256=5LpHu4zdIe2p9DBnpYAqdW7KDeL75tPmsEbM3C5_nMA,684
+qupled/mpi.py,sha256=fvFQr0fuQaIOo9si7-AGgctTPxpDvqo1RcsnBkNN4Cc,2998
+qupled/stls.py,sha256=pxsqQG2yI_I59kCf8QdUbrSat53gX63u-sgFLPzAflQ,2878
+qupled/vsstls.py,sha256=E07rQGF8HReVioWIw54vitm5lYP_hbEOi2MhoQC4aKk,7607
+qupled/qvsstls.py,sha256=ygJilrCV6d6byYerPhkDCccapDlqaBqu9k5O_lg8BB0,1642
+qupled/output.py,sha256=VP_7oKPuULYa0UB-wX_J_cLnGd2mZZxrYeeTpNY-iwE,3602
+qupled/hf.py,sha256=NYjLdeMpXHpNUuuECVGnMHlZGMi8fNESPtrrL2eHXOo,12157
+qupled/include/fmt/ostream.h,sha256=-DnzYoGzasnlFOTG2UT29mmaIQG7NunUgJqt5L0l_2E,7305
+qupled/include/fmt/format-inl.h,sha256=w5DfUohEgLEx3_0XhCrz3ejq5s1_Gq_aMLY--jadbmE,73646
+qupled/include/fmt/ranges.h,sha256=h6mRGvU1Jz6fm-0A1towg7ce7DSRyaVAEyWKiCNCtvM,24446
+qupled/include/fmt/xchar.h,sha256=57OfmYZ5IUZ2BZZxuQhdKrJUljSsDkn4_5QCiho-adw,9962
+qupled/include/fmt/core.h,sha256=FD1ZHfY9tbIHhuuMp1YBLgt-LG2rfwAkiOLHAeiXqR8,99931
+qupled/include/fmt/chrono.h,sha256=o41sAvZOKvNoQ2mtTfariL4gOg1L379R_eVC-DVG6sk,74011
+qupled/include/fmt/os.h,sha256=ibepg2W5ASfhHV6EwvpYRDCIFk7JyZziYu0wOnwZfu0,13291
+qupled/include/fmt/color.h,sha256=AUydrMUh-cN2hGj0anFUXRDaHzxKi4JrhZa4oDWIp3o,24531
+qupled/include/fmt/args.h,sha256=QYtkXpAiJ3pYWIQcB6PGUjcFPUUxGowJlXOsUXtD0cI,7458
+qupled/include/fmt/printf.h,sha256=0SHCtbSPaN45bKOsX6MrfH3XfdjY6WhOhgSoh1bmgOU,20837
+qupled/include/fmt/compile.h,sha256=aapCl7QvJzu_rPXJ7r5Laia1UtBvt0zRUcRyYMN7aFA,18974
+qupled/include/fmt/format.h,sha256=Y71aNNE5v8oXJ7-6-UGvu1dRyHGtqqkbd9zlinByMHM,164588
+qupled/include/fmt/std.h,sha256=BkZ7QF9AKR9A8mxuRsFddWJUWBw5dBOnfAKyt9Yty0E,16239
+qupled/.dylibs/libgsl.28.dylib,sha256=rcTB771UsiEC1W_E5mVMYKo6G91p0OD5GaUssM8gfk8,2241424
+qupled/.dylibs/libomp.dylib,sha256=Ic_m8yVNxvjHQ-51C9MX9Bzl0wJAEsBdkx4V0_P_z7Y,735616
+qupled/.dylibs/libsqlite3.3.50.2.dylib,sha256=Ae6aDP7MmVuBJwO7tcSfvaycvjWi5Dn4Xapjnw_bgzI,1241152
+qupled/.dylibs/libgslcblas.0.dylib,sha256=3ATUzchJ3MFYqtB5KC07P7gu8g-GTlQ62fUwbNrZqMY,239760
+qupled/.dylibs/libSQLiteCpp.0.dylib,sha256=neCBZ7UIgUr36H01mQ4E-eW8rgtddKk1q6NQRD0QYvc,94368
+qupled/lib/libfmt.a,sha256=dzFG_ncHRFujJn7z5JfVOviFq8fkTWISRrvuxA77PaI,214704
+qupled/lib/pkgconfig/fmt.pc,sha256=oIUJk5rSV9wH2-UZA7sI6iHKKEDfCJcv8T6awxvCr4o,351
+qupled/lib/cmake/fmt/fmt-targets-release.cmake,sha256=0hurnnAYtVc8r8yvaxkXAS5Op01RPnwKE6SFNOL1nYA,807
+qupled/lib/cmake/fmt/fmt-config.cmake,sha256=Cd-Xn_HSZ-Lk5ZBDX8q49OQKSvnS0_k4r0-tb6G8LW4,999
+qupled/lib/cmake/fmt/fmt-config-version.cmake,sha256=O6qhq-qInAAjYQ6y2xLwA_dJQ1CQDmj9zJYcmxuY6dU,1862
+qupled/lib/cmake/fmt/fmt-targets.cmake,sha256=rRXShlK4V1JpSsyAg0wbt1HHWe1pap-HtHlniem2l0I,4464