quant-met 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

quant_met/mean_field/{graphene.py → hamiltonians/graphene.py}

@@ -4,46 +4,60 @@
 
 """Provides the implementation for Graphene."""
 
+import pathlib
 from typing import Any
 
+import h5py
 import numpy as np
 import numpy.typing as npt
 
-from ._utils import _check_valid_array, _validate_float
+from quant_met.geometry import GrapheneLattice
+from quant_met.mean_field._utils import _check_valid_array, _validate_float
+from quant_met.parameters.hamiltonians import GrapheneParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class GrapheneHamiltonian(BaseHamiltonian):
+class Graphene(BaseHamiltonian):
     """Hamiltonian for Graphene."""
 
     def __init__(
         self,
-        hopping: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int_gr: float,
-        delta: npt.NDArray[np.float64] | None = None,
+        parameters: GrapheneParameters,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
         del args
         del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
+        self._name = parameters.name
+        self.hopping = _validate_float(parameters.hopping, "Hopping")
+        if parameters.lattice_constant <= 0:
             msg = "Lattice constant must be positive"
             raise ValueError(msg)
-        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
-        self.hubbard_int_gr = _validate_float(hubbard_int_gr, "hubbard_int interaction")
-        self._hubbard_int_orbital_basis = np.array([self.hubbard_int_gr, self.hubbard_int_gr])
+        self._lattice = GrapheneLattice(
+            lattice_constant=np.float64(
+                _validate_float(parameters.lattice_constant, "Lattice constant")
+            )
+        )
+        self.lattice_constant = self._lattice.lattice_constant
+        self.chemical_potential = _validate_float(
+            parameters.chemical_potential, "Chemical potential"
+        )
+        self.hubbard_int = _validate_float(parameters.hubbard_int, "Hubbard interaction")
+        self._hubbard_int_orbital_basis = np.array([self.hubbard_int, self.hubbard_int])
         self._number_of_bands = 2
-        if delta is None:
+        if parameters.delta is None:
             self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
         else:
-            if delta.shape != (self.number_of_bands,):
-                msg = "Invalid input value for gaps."
-                raise ValueError(msg)
-            self._delta_orbital_basis = np.astype(delta, np.complex64)
+            self._delta_orbital_basis = np.astype(parameters.delta, np.complex64)
+
+    @property
+    def name(self) -> str:  # noqa: D102
+        return self._name
+
+    @property
+    def lattice(self) -> GrapheneLattice:  # noqa: D102
+        return self._lattice
 
     @property
     def number_of_bands(self) -> int:  # noqa: D102
@@ -61,6 +75,14 @@ class GrapheneHamiltonian(BaseHamiltonian):
     def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
         self._delta_orbital_basis = new_delta
 
+    @classmethod
+    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":  # noqa: D102
+        with h5py.File(f"{filename}", "r") as f:
+            config_dict = dict(f.attrs.items())
+            config_dict["delta"] = f["delta"][()]
+        parameters = GrapheneParameters.model_validate(config_dict)
+        return cls(parameters=parameters)
+
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
         Return the normal state Hamiltonian in orbital basis.
@@ -78,7 +100,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
         """
         assert _check_valid_array(k)
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
@@ -120,7 +142,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
         assert direction in ["x", "y"]
 
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 

quant_met/mean_field/{one_band_tight_binding.py → hamiltonians/one_band_tight_binding.py}

@@ -4,46 +4,58 @@
 
 """Provides the implementation for Graphene."""
 
+import pathlib
 from typing import Any
 
+import h5py
 import numpy as np
 import numpy.typing as npt
 
-from ._utils import _check_valid_array, _validate_float
+from quant_met.geometry import SquareLattice
+from quant_met.mean_field._utils import _check_valid_array, _validate_float
+from quant_met.parameters import OneBandParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class OneBandTightBindingHamiltonian(BaseHamiltonian):
+class OneBand(BaseHamiltonian):
     """Hamiltonian for Graphene."""
 
     def __init__(
         self,
-        hopping: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int: float,
-        delta: npt.NDArray[np.float64] | None = None,
+        parameters: OneBandParameters,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
         del args
         del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
+        self._name = parameters.name
+        self.hopping = _validate_float(parameters.hopping, "Hopping")
+        if parameters.lattice_constant <= 0:
             msg = "Lattice constant must be positive"
             raise ValueError(msg)
-        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
-        self.hubbard_int = _validate_float(hubbard_int, "hubbard_int interaction")
+        self._lattice = SquareLattice(
+            np.float64(_validate_float(parameters.lattice_constant, "Lattice constant"))
+        )
+        self.lattice_constant = self._lattice.lattice_constant
+        self.chemical_potential = _validate_float(
+            parameters.chemical_potential, "Chemical potential"
+        )
+        self.hubbard_int = _validate_float(parameters.hubbard_int, "Hubbard interaction")
         self._hubbard_int_orbital_basis = np.array([self.hubbard_int])
         self._number_of_bands = 1
-        if delta is None:
+        if parameters.delta is None:
             self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
         else:
-            if delta.shape != (self.number_of_bands,):
-                msg = "Invalid input value for gaps."
-                raise ValueError(msg)
-            self._delta_orbital_basis = np.astype(delta, np.complex64)
+            self._delta_orbital_basis = np.astype(parameters.delta, np.complex64)
+
+    @property
+    def name(self) -> str:  # noqa: D102
+        return self._name
+
+    @property
+    def lattice(self) -> SquareLattice:  # noqa: D102
+        return self._lattice
 
     @property
     def number_of_bands(self) -> int:  # noqa: D102
@@ -61,6 +73,14 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
     def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
         self._delta_orbital_basis = new_delta
 
+    @classmethod
+    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":  # noqa: D102
+        with h5py.File(f"{filename}", "r") as f:
+            config_dict = dict(f.attrs.items())
+            config_dict["delta"] = f["delta"][()]
+        parameters = OneBandParameters.model_validate(config_dict)
+        return cls(parameters=parameters)
+
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
         Return the normal state Hamiltonian in orbital basis.
@@ -78,7 +98,7 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
         """
         assert _check_valid_array(k)
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
@@ -115,7 +135,7 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
         assert direction in ["x", "y"]
 
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 

quant_met/mean_field/quantum_metric.py

@@ -7,22 +7,21 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 
 
 def quantum_metric(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[int]
 ) -> npt.NDArray[np.float64]:
     """Calculate the quantum metric in the normal state.
 
     Parameters
     ----------
+    bands
     h : :class:`~quant_met.BaseHamiltonian`
         Hamiltonian object.
     k_grid : :class:`numpy.ndarray`
         List of k points.
-    band : int
-        Index of band for which the quantum metric is calculated.
 
     Returns
     -------
@@ -36,25 +35,26 @@ def quantum_metric(
 
     quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex64)
 
-    for i, direction_1 in enumerate(["x", "y"]):
-        h_derivative_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
-        for j, direction_2 in enumerate(["x", "y"]):
-            h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
-            for k_index in range(len(k_grid)):
-                for n in [i for i in range(h.number_of_bands) if i != band]:
-                    quantum_geom_tensor[i, j] += (
-                        (
-                            bloch[k_index][:, band].conjugate()
-                            @ h_derivative_direction_1[k_index]
-                            @ bloch[k_index][:, n]
-                        )
-                        * (
-                            bloch[k_index][:, n].conjugate()
-                            @ h_derivative_direction_2[k_index]
-                            @ bloch[k_index][:, band]
+    for band in bands:
+        for i, direction_1 in enumerate(["x", "y"]):
+            h_derivative_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
+            for j, direction_2 in enumerate(["x", "y"]):
+                h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
+                for k_index in range(len(k_grid)):
+                    for n in [i for i in range(h.number_of_bands) if i != band]:
+                        quantum_geom_tensor[i, j] += (
+                            (
+                                bloch[k_index][:, band].conjugate()
+                                @ h_derivative_direction_1[k_index]
+                                @ bloch[k_index][:, n]
+                            )
+                            * (
+                                bloch[k_index][:, n].conjugate()
+                                @ h_derivative_direction_2[k_index]
+                                @ bloch[k_index][:, band]
+                            )
+                            / (energies[k_index][band] - energies[k_index][n]) ** 2
                         )
-                        / (energies[k_index][band] - energies[k_index][n]) ** 2
-                    )
 
     return np.real(quantum_geom_tensor) / number_k_points
 
@@ -66,12 +66,11 @@ def quantum_metric_bdg(
 
     Parameters
     ----------
+    bands
     h : :class:`~quant_met.BaseHamiltonian`
         Hamiltonian object.
     k_grid : :class:`numpy.ndarray`
         List of k points.
-    band : int
-        Index of band for which the quantum metric is calculated.
 
     Returns
     -------
@@ -91,7 +90,7 @@ def quantum_metric_bdg(
             for j, direction_2 in enumerate(["x", "y"]):
                 h_derivative_dir_2 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_2)
                 for k_index in range(len(k_grid)):
-                    for n in [i for i in range(h.number_of_bands) if i != band]:
+                    for n in [i for i in range(2 * h.number_of_bands) if i != band]:
                         quantum_geom_tensor[i, j] += (
                             (
                                 bdg_functions[k_index][:, band].conjugate()

quant_met/mean_field/self_consistency.py

@@ -5,41 +5,45 @@
 """Self-consistency loop."""
 
 import numpy as np
+import numpy.typing as npt
 
-from quant_met import geometry
-
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 
 
 def self_consistency_loop(
-    h: BaseHamiltonian, beta: np.float64, number_of_k_points: int, epsilon: float
+    h: BaseHamiltonian,
+    k_space_grid: npt.NDArray[np.float64],
+    beta: np.float64,
+    epsilon: float,
+    q: npt.NDArray[np.float64] | None = None,
 ) -> BaseHamiltonian:
     """Self-consistency loop.
 
     Parameters
     ----------
+    lattice
+    q
     beta
     number_of_k_points
     h
     epsilon
     """
-    lattice = geometry.Graphene(lattice_constant=np.sqrt(3))
-    k_space_grid = lattice.generate_bz_grid(ncols=number_of_k_points, nrows=number_of_k_points)
+    if q is None:
+        q = np.array([0, 0])
+
     rng = np.random.default_rng()
-    delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.float64)
-    rng.random(size=h.delta_orbital_basis.shape, out=delta_init)
-    h.delta_orbital_basis = delta_init.astype(np.float64)
+    delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.complex64)
+    delta_init += (
+        2 * rng.random(size=h.delta_orbital_basis.shape)
+        - 1
+        + 1.0j * (2 * rng.random(size=h.delta_orbital_basis.shape) - 1)
+    )
+    h.delta_orbital_basis = delta_init
 
     while True:
-        new_gap = h.gap_equation(k=k_space_grid, beta=beta)
-        if (np.abs(h.delta_orbital_basis - np.abs(new_gap)) < epsilon).all():
+        new_gap = h.gap_equation(k=k_space_grid, q=q, beta=beta)
+        if (np.abs(h.delta_orbital_basis - new_gap) < epsilon).all():
             h.delta_orbital_basis = new_gap
-            print("Finished")
             return h
-        """
-        print(f"Old: {h.delta_orbital_basis}")
-        print(f"New: {new_gap}")
-        print(f"Difference {np.abs(h.delta_orbital_basis) - np.abs(new_gap)}")
-        """
-        mixing_greed = 0.2
+        mixing_greed = 0.1
         h.delta_orbital_basis = mixing_greed * new_gap + (1 - mixing_greed) * h.delta_orbital_basis

quant_met/mean_field/superfluid_weight.py

@@ -7,7 +7,7 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 
 
 def superfluid_weight(

quant_met/parameters/__init__.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Parameters (:mod:`quant_met.parameters`)
+========================================
+
+.. autosummary::
+   :toctree: generated/parameters/
+
+    DressedGrapheneParameters
+    GrapheneParameters
+    OneBandParameters
+    Parameters
+"""  # noqa: D205, D400
+
+from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+from .main import Parameters
+
+__all__ = ["Parameters", "DressedGrapheneParameters", "GrapheneParameters", "OneBandParameters"]

quant_met/parameters/hamiltonians.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Pydantic models to hold parameters for Hamiltonians."""
+
+from typing import Literal
+
+import numpy as np
+from numpydantic import NDArray, Shape
+from pydantic import BaseModel
+
+
+class DressedGrapheneParameters(BaseModel):
+    """Parameters for the dressed Graphene model."""
+
+    name: Literal["DressedGraphene"] = "DressedGraphene"
+    hopping_gr: float
+    hopping_x: float
+    hopping_x_gr_a: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int_gr: float
+    hubbard_int_x: float
+    delta: NDArray[Shape["3"], np.complex64] | None = None
+
+
+class GrapheneParameters(BaseModel):
+    """Parameters for Graphene model."""
+
+    name: Literal["Graphene"] = "Graphene"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int: float
+    delta: NDArray[Shape["2"], np.complex64] | None = None
+
+
+class OneBandParameters(BaseModel):
+    """Parameters for Graphene model."""
+
+    name: Literal["OneBand"] = "OneBand"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int: float
+    delta: NDArray[Shape["1"], np.complex64] | None = None

quant_met/parameters/main.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Pydantic models to hold parameters to run a simulation."""
+
+import pathlib
+
+from numpydantic import NDArray, Shape
+from pydantic import BaseModel, Field
+
+from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+
+
+class Control(BaseModel):
+    """Control for the calculation."""
+
+    calculation: str
+    prefix: str
+    outdir: pathlib.Path
+    conv_treshold: float
+    beta: float
+    q: NDArray[Shape["2"], int | float] | None = None
+
+
+class KPoints(BaseModel):
+    """Control for k points."""
+
+    nk1: int
+    nk2: int
+
+
+class Parameters(BaseModel):
+    """Class to hold the parameters for a calculation."""
+
+    control: Control
+    model: DressedGrapheneParameters | GrapheneParameters | OneBandParameters = Field(
+        ..., discriminator="name"
+    )
+    k_points: KPoints

quant_met/utils.py

@@ -14,7 +14,7 @@ Functions
 .. autosummary::
    :toctree: generated/
 
-    generate_uniform_grid - Generate a uniform grid of points in 2D.
+    generate_uniform_grid
 """  # noqa: D205, D400
 
 import numpy as np

{quant_met-0.0.6.dist-info → quant_met-0.0.8.dist-info}/METADATA

@@ -1,19 +1,22 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.6
+Version: 0.0.8
 Summary: Calculate superconductivity in flat-band systems.
 Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
-Requires-Python: >=3.11,<4.0
+Requires-Python: >=3.11,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: h5py (>=3.11.0,<4.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
-Requires-Dist: numpy (>=2.0.0,<3.0.0)
-Requires-Dist: pandas (>=2.2.2,<3.0.0)
-Requires-Dist: scipy (>=1.14.0,<2.0.0)
+Requires-Dist: numpy (>=2.1.2,<3.0.0)
+Requires-Dist: numpydantic (>=1.6.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: scipy (>=1.14.1,<2.0.0)
 Project-URL: Repository, https://github.com/Ruberhauptmann/quant-met
 Description-Content-Type: text/markdown
 

quant_met-0.0.8.dist-info/RECORD

@@ -0,0 +1,31 @@
+quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
+quant_met/cli/__init__.py,sha256=If5Jdi7mG-5PbIyjQGxnt9o2bsY5VyE3qtdcO5yTGnQ,321
+quant_met/cli/main.py,sha256=EZTRRTfrN3z-srgbG2BoDg64iYBjzZLuuMtrxTdZU8s,698
+quant_met/cli/scf.py,sha256=x9qxjQizXAKH7217dBuHTlA26eGenzcC2LDpN1q7030,1435
+quant_met/geometry/__init__.py,sha256=uCLEDBrYuMUkEgJmPnLAvR2WlmvoM9X9_cV_Q2zMzoA,620
+quant_met/geometry/base_lattice.py,sha256=QVHuZVy6bOvBSITY_mKhr7hYW1jHJ5UAm3sMCFClYZ0,2276
+quant_met/geometry/bz_path.py,sha256=q_eNhKYjhKLeFNjio8BdKVsseO6slQKlwKKSQQYTVJQ,2497
+quant_met/geometry/graphene.py,sha256=86C1LiYFunoSGSS1_A79dPq24FiiOxpHvOLUVrdRq_E,1271
+quant_met/geometry/square.py,sha256=1fSrHab07uB6ildNzlbTwINJvPa5C2Az0B0uuOVJmMc,1216
+quant_met/mean_field/__init__.py,sha256=yH_UovKDaP5c06cb1uWPtvIO2WQ76pi6ZTsNBzE8oso,793
+quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
+quant_met/mean_field/hamiltonians/__init__.py,sha256=FcqhV5fG_gzngVuiVfBucripdbNTzOxPRafu7sZ4ueA,644
+quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=fL1dl1ZX3I_4gzARiQl5o2eCTIr-udRA23qZo4VWq0k,13622
+quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=zzHRVmp8749I2ll5N-wjks8l5dJLdtmhWR7smR7ezM0,6542
+quant_met/mean_field/hamiltonians/graphene.py,sha256=Zg_S9xTMYi_7v_6PBK7NUdiwgmyqyCPElUfezuiozm0,5611
+quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=kBYqthKUPby754PhOwf0mzHLTHNVbdKZbtJhvp2yc3E,4766
+quant_met/mean_field/quantum_metric.py,sha256=5FC3NU_ObbHlUUZMCAP1DyZuyifgnEr3s2cSH6cA8-8,3903
+quant_met/mean_field/self_consistency.py,sha256=xkZIWkOopekhDufJnSGK6ARsro6XaIuVhhrnJmb6sk8,1291
+quant_met/mean_field/superfluid_weight.py,sha256=m_x2uVYcEVdbItwEV3-Ml80Qad7X-YWLgb38fJKLJsY,4004
+quant_met/parameters/__init__.py,sha256=DvzEtTAnHcRcJufZV7bwYGZUeA-0Q2B8N9syGA9uNRM,552
+quant_met/parameters/hamiltonians.py,sha256=Q5uGTzxM8kIdUnRuIpEJNPmSHF27Zj7LBV3kgKd5dP4,1213
+quant_met/parameters/main.py,sha256=yrDME_KfDZ_9xf3ofTt7V8kw_8qbgD9EfVlxLcymcNE,899
+quant_met/plotting/__init__.py,sha256=s-DS22impzozKiS7p-v3yCmeccDQfXmBbtPiYMKwH0Y,620
+quant_met/plotting/plotting.py,sha256=_SqL8GrDqlBtccHnUWpZPqdSJy0Yd_4dhFdUOxOzPpY,7447
+quant_met/utils.py,sha256=JG_tShSL1JIi-Fn-N6mVD6J0sl7Egf-zuHnOSEKu7VA,1666
+quant_met-0.0.8.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.8.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.8.dist-info/METADATA,sha256=vh99nVcyAhUECV32kkXxfDjne2LvBufs6ekW60m8pYs,2953
+quant_met-0.0.8.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quant_met-0.0.8.dist-info/entry_points.txt,sha256=fuVnEk5wiqPMEhn-Cc7q0Hdk2s_OniOn0zfdFPicH4Y,47
+quant_met-0.0.8.dist-info/RECORD,,

{quant_met-0.0.6.dist-info → quant_met-0.0.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

quant_met-0.0.8.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+quant-met=quant_met.cli:cli
+