zoomy-core 0.1.14__py3-none-any.whl

transformation/to_openfoam.py

@@ -0,0 +1,258 @@
+import os
+import re
+import textwrap
+import sympy as sp
+from sympy.printing.cxx import CXX11CodePrinter
+
+from zoomy_core.misc import misc as misc
+
+
+class FoamPrinter(CXX11CodePrinter):
+    """
+    Convert SymPy expressions to OpenFOAM 12 compatible C++ code.
+    - Q, Qaux: Foam::List<Foam::scalar>
+    - Matrices: Foam::List<Foam::List<Foam::scalar>>
+    - Vectors: Foam::vector (.x(), .y(), .z())
+    """
+
+    def __init__(self, model, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.n_dof_q = model.n_variables
+        self.n_dof_qaux = model.n_aux_variables
+
+        # Map variable names to Q[i], Qaux[i]
+        self.map_Q = {k: f"Q[{i}]" for i, k in enumerate(model.variables.values())}
+        self.map_Qaux = {k: f"Qaux[{i}]" for i, k in enumerate(model.aux_variables.values())}
+        self.map_param = {k: str(float(model.parameter_values[i])) for i, k in enumerate(model.parameters.values())}
+        
+        # Map normal/position to n.x(), n.y(), n.z()
+        self.map_normal = {k: ["n.x()", "n.y()", "n.z()"][i] for i, k in enumerate(model.normal.values())}
+        self.map_position = {k: ["X.x()", "X.y()", "X.z()"][i] for i, k in enumerate(model.position.values())}
+
+        self._std_regex = re.compile(r'std::([A-Za-z_]\w*)')
+        
+        self._argument_table = {"Q": "const Foam::List<Foam::scalar>& Q",
+        "Qaux": "const Foam::List<Foam::scalar>& Qaux",
+        "n": "const Foam::vector& n",
+        "X": "const Foam::vector& X",
+        "time": "const Foam::scalar& time",
+        "dX": "const Foam::scalar& dX",
+        "z": "const Foam::scalar& z"
+        }
+        
+    def create_lambertw(self):
+        return textwrap.dedent("""\
+        inline Foam::scalar lambertw(const Foam::scalar x)
+            {
+                // valid for x > -exp(-1)
+                Foam::scalar w = (x < 1.0 ? x : log(1.0 + x));  // good initial guess
+                for (int i = 0; i < 5; ++i)
+                {
+                    Foam::scalar ew = exp(w);
+                    Foam::scalar wew = w * ew;
+                    Foam::scalar diff = wew - x;
+                    w -= diff / (ew * (w + 1.0) - (w + 2.0) * diff / (2.0 * w + 2.0));
+                }
+                return w;
+            }
+    """)
+                   
+    def get_function_arguments(self, arguments):
+        out = ",\n".join([self._argument_table[arg] for arg in arguments])
+        return out
+
+    # --- Symbol printing --------------------------------------------------
+    def _print_Symbol(self, s):
+        for m in [self.map_Q, self.map_Qaux, self.map_param, self.map_normal, self.map_position]:
+            if s in m:
+                return m[s]
+        return super()._print_Symbol(s)
+
+    # --- Pow printing -----------------------------------------------------
+    def _print_Pow(self, expr):
+        base, exp = expr.as_base_exp()
+        if exp.is_Integer:
+            n = int(exp)
+            if n == 0:
+                return "1.0"
+            if n == 1:
+                return self._print(base)
+            if n < 0:
+                return f"(1.0 / Foam::pow({self._print(base)}, {abs(n)}))"
+            return f"Foam::pow({self._print(base)}, {n})"
+        return f"Foam::pow({self._print(base)}, {self._print(exp)})"
+    
+    # Print as a plain C function call "lambertw(...)"
+    def _print_LambertW(self, expr):
+        return f"lambertw({self._print(expr.args[0])})"
+
+    # --- Expression conversion --------------------------------------------
+    def convert_expression_body(self, expr, target='res'):
+        tmp_sym = sp.numbered_symbols('t')
+        temps, simplified = sp.cse(expr, symbols=tmp_sym)
+        lines = []
+        for lhs, rhs in temps:
+            lines.append(f"Foam::scalar {self.doprint(lhs)} = {self.doprint(rhs)};")
+        for i in range(expr.rows):
+            for j in range(expr.cols):
+                lines.append(f"{target}[{i}][{j}] = {self.doprint(simplified[0][i, j])};")
+        return "\n        ".join(lines)
+
+    # --- Matrix factory ---------------------------------------------------
+    def createMatrix(self, rows, cols):
+        return f"Foam::List<Foam::List<Foam::scalar>>({rows}, Foam::List<Foam::scalar>({cols}, 0.0))"
+
+    # --- Header / Footer --------------------------------------------------
+    def create_file_header(self, n_dof_q, n_dof_qaux, dim, list_sorted_function_names):
+        return textwrap.dedent(f"""\
+        #pragma once
+        #include "List.H"
+        #include "vector.H"
+        #include "scalar.H"
+
+        namespace Model
+        {{
+        constexpr int n_dof_q    = {n_dof_q};
+        constexpr int n_dof_qaux = {n_dof_qaux};
+        constexpr int dimension  = {dim};
+        const Foam::List<Foam::word> map_boundary_tag_to_function_index{{ {", ".join(f'"{item}"' for item in list_sorted_function_names)} }};
+        """)
+
+    def create_file_footer(self):
+        return "\n} // namespace Model\n"
+    
+    def create_generic_function(self, name, expr, arguments, n_dof_q, n_dof_qaux, target='res'):
+        if isinstance(expr, list):
+            dim = len(expr)
+            return [self.create_function(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    {self.get_function_arguments(arguments)})
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    # --- Function generators ---------------------------------------------
+    def create_function(self, name, expr, n_dof_q, n_dof_qaux, target='res'):
+        if isinstance(expr, list):
+            dim = len(expr)
+            return [self.create_function(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_normal(self, name, expr, n_dof_q, n_dof_qaux, dim, target='res'):
+        if isinstance(expr, list):
+            return [self.create_function_normal(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux, dim)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& n)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_interpolate(self, name, expr, n_dof_q, n_dof_qaux, target='res'):
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& X)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_boundary(self, name, expr, n_dof_q, n_dof_qaux, dim, target='res'):
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& n,
+    const Foam::vector& X,
+    const Foam::scalar& time,
+    const Foam::scalar& dX)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    # --- Full model generation ------------------------------------------
+    def create_model(self, model, additional_writes=None):
+        n_dof = model.n_variables
+        n_dof_qaux = model.n_aux_variables
+        dim = model.dimension
+        funcs = []
+        funcs.append(self.create_lambertw())
+        funcs += self.create_function('flux', model.flux(), n_dof, n_dof_qaux)
+        funcs += self.create_function('flux_jacobian', model.flux_jacobian(), n_dof, n_dof_qaux)
+        funcs += self.create_function('dflux', model.dflux(), n_dof, n_dof_qaux)
+        funcs += self.create_function('dflux_jacobian', model.dflux_jacobian(), n_dof, n_dof_qaux)
+        funcs += self.create_function('nonconservative_matrix', model.nonconservative_matrix(), n_dof, n_dof_qaux)
+        funcs += self.create_function('quasilinear_matrix', model.quasilinear_matrix(), n_dof, n_dof_qaux)
+        funcs.append(self.create_function_normal('eigenvalues', model.eigenvalues(), n_dof, n_dof_qaux, dim))
+        funcs.append(self.create_function('left_eigenvectors', model.left_eigenvectors(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('right_eigenvectors', model.right_eigenvectors(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('source', model.source(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('residual', model.residual(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('source_implicit', model.source_implicit(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function_interpolate('interpolate', model.project_2d_to_3d(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function_boundary(
+            'boundary_conditions',
+            model.boundary_conditions.get_boundary_condition_function(
+                model.time, model.position, model.distance,
+                model.variables, model.aux_variables, model.parameters, model.normal),
+            n_dof, n_dof_qaux, dim))
+        if additional_writes is not None:
+            for a in additional_writes:
+                funcs.append(self.create_generic_function(
+                    a['name'], a['expression'], a['arguments'], n_dof, n_dof_qaux))
+
+        return self.create_file_header(n_dof, n_dof_qaux, dim, model.boundary_conditions.list_sorted_function_names) + "\n".join(funcs) + self.create_file_footer()
+
+
+def write_code(model, settings, additional_writes=None):
+    printer = FoamPrinter(model)
+    code = printer.create_model(model, additional_writes=additional_writes)
+    main_dir = misc.get_main_directory()
+
+    path = os.path.join(main_dir, settings.output.directory, ".foam_interface")
+    os.makedirs(path, exist_ok=True)
+    file_path = os.path.join(path, "Model.H")
+    with open(file_path, "w+") as f:
+        f.write(code)

transformation/to_ufl.py

@@ -0,0 +1,67 @@
+from attrs import define
+import ufl
+from zoomy_core.transformation.to_numpy import NumpyRuntimeModel
+
+
+
+@define(kw_only=False, slots=True, frozen=True)
+class UFLRuntimeModel(NumpyRuntimeModel):
+    printer=None
+    
+    module = {
+        'ones_like': lambda x: 0*x + 1,
+        'zeros_like': lambda x: 0*x,
+        'array': ufl.as_vector,
+        'squeeze': lambda x: x,
+        
+        # --- Elementary arithmetic ---
+        "Abs": abs,
+        "sign": ufl.sign,
+        "Min": ufl.min_value,
+        "Max": ufl.max_value,
+        # --- Powers and roots ---
+        "sqrt": ufl.sqrt,
+        "exp": ufl.exp,
+        "ln": ufl.ln,
+        "pow": lambda x, y: x**y,
+        # --- Trigonometric functions ---
+        "sin": ufl.sin,
+        "cos": ufl.cos,
+        "tan": ufl.tan,
+        "asin": ufl.asin,
+        "acos": ufl.acos,
+        "atan": ufl.atan,
+        "atan2": ufl.atan2,
+        # --- Hyperbolic functions ---
+        "sinh": ufl.sinh,
+        "cosh": ufl.cosh,
+        "tanh": ufl.tanh,
+        # --- Piecewise / conditional logic ---
+        "Heaviside": lambda x: ufl.conditional(x >= 0, 1.0, 0.0),
+        "Piecewise": ufl.conditional,
+        "signum": ufl.sign,
+        # --- Vector & tensor ops ---
+        "dot": ufl.dot,
+        "inner": ufl.inner,
+        "outer": ufl.outer,
+        "cross": ufl.cross,
+        # --- Differential operators (used in forms) ---
+        "grad": ufl.grad,
+        "div": ufl.div,
+        "curl": ufl.curl,
+        # --- Common constants ---
+        "pi": ufl.pi,
+        "E": ufl.e,
+        # --- Matrix and linear algebra ---
+        "transpose": ufl.transpose,
+        "det": ufl.det,
+        "inv": ufl.inv,
+        "tr": ufl.tr,
+        # --- Python builtins (SymPy may emit these) ---
+        "abs": abs,
+        "min": ufl.min_value,
+        "max": ufl.max_value,
+        "sqrt": ufl.sqrt,
+        "sum": lambda x: ufl.Constant(sum(x)) if isinstance(x, (list, tuple)) else x,
+        "ImmutableDenseMatrix": lambda x: x,
+    }

zoomy_core-0.1.14.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: zoomy_core
+Version: 0.1.14
+Summary: A simulation software for dimensionally-reduced free surface flows.
+Author-email: Ingo Steldermann <steldermann@mbd.rwth-aachen.de>
+License: GNU
+Project-URL: Homepage, https://github.com/mbd-rwth/Zoomy
+Project-URL: Documentation, https://mbd-rwth.github.io/Zoomy
+Project-URL: Source, https://github.com/mbd-rwth/Zoomy
+Project-URL: Issues, https://github.com/mbd-rwth/Zoomy/issues
+Keywords: simulation,shallow flow,free surface flow,shallow moments,shallow water,VAM
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs
+Requires-Dist: sympy>=1.14
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: loguru
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: meshio
+Requires-Dist: pytest
+Provides-Extra: gui
+Requires-Dist: pyvista; extra == "gui"
+Requires-Dist: trame; extra == "gui"
+Requires-Dist: trame-vtk; extra == "gui"
+Requires-Dist: trame-vuetify; extra == "gui"
+Requires-Dist: panel; extra == "gui"
+Provides-Extra: coupling
+Requires-Dist: precice; extra == "coupling"
+Provides-Extra: testing
+Requires-Dist: swashes; extra == "testing"
+Requires-Dist: pyswashes; extra == "testing"
+Provides-Extra: mesh
+Requires-Dist: gmsh; extra == "mesh"
+Requires-Dist: python-gmsh; extra == "mesh"
+Requires-Dist: rasterio; extra == "mesh"
+Provides-Extra: dev
+Requires-Dist: watchfiles; extra == "dev"
+Requires-Dist: Cython; extra == "dev"
+Requires-Dist: pytest-html; extra == "dev"
+Dynamic: license-file
+
+# zoomy-core
+
+This repository is a submodule of the the [Zoomy Lab](https://github.com/ZoomyLab/Zoomy) repository.
+

zoomy_core-0.1.14.dist-info/RECORD

@@ -0,0 +1,57 @@
+decorators/decorators.py,sha256=4fmdDDkHKoRFRbxMpTdM3KqDMV-dOL02DH2Ig29cpR0,853
+fvm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fvm/flux.py,sha256=5EKXY_xqnH5T5o4cZTC-_SON14WLoXwygel8OTbPdAk,1888
+fvm/nonconservative_flux.py,sha256=80iRIOZ5xiRJ7yeVgzrlf-kNmLlrqnUzQTEZxsHPZyc,3359
+fvm/ode.py,sha256=Cx7DgLoWm7aqIjPtWUhoD9FnScZyPjKSuI4--uaiuU0,1453
+fvm/solver_numpy.py,sha256=y5szY7jz1FQ8kHQip5NvHy3ww4r68bSaz0jFoGa_Om4,10835
+fvm/timestepping.py,sha256=SqYjV0YAj4v5Ug2y7sEdZgF3DRH1lHPDa5BFsXzrm14,405
+mesh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mesh/mesh.py,sha256=TKYHl067O0mBvcIKy63epf9Echono7NyFjBUlOuLTDI,50259
+mesh/mesh_extrude.py,sha256=ln9bD5l_BEELUgx--j1I70Wv3tGgdqVcrxcDXKBMVyE,5992
+mesh/mesh_util.py,sha256=IOe5FZ2vhiCTGRsRxUHEoek1o6N2QQAceuLUhuioG_k,16174
+misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+misc/custom_types.py,sha256=l1kfQJWPzT0PEvW-8bh4MD4BaIspWmtfQ4Y8Oq2qcT4,141
+misc/interpolation.py,sha256=Z27uhcGRE_BWPm9voUbxHV5Ptj3cJnWd9vAWNqIfGIM,5095
+misc/io.py,sha256=Vz7mRGIGAOgyDLgLOQvu9vVnFVudufr_lXVx_sNHeOg,14559
+misc/logger_config.py,sha256=506zLc8d9hn7b-r55ZWHWWx7GY0NjayVGMLNcNJQr5E,478
+misc/misc.py,sha256=CP2PAGYEfn8LITTSZ7Xm3qQOngzPPW8RymRYN1GnNWo,7521
+model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model/analysis.py,sha256=qt7cs3s5ijen5I11ntS3Y5pVPI8ufijjCJj-7Is9YMo,5332
+model/basefunction.py,sha256=XtlKQCkamWnM_ohW0-3PYXrkK0_poIFHMtz-o52JYSo,3542
+model/basemodel.py,sha256=q1vJtqqBnvtB0soDyGWUcZs2AM9VMopWw-M86t1Whwo,16926
+model/boundary_conditions.py,sha256=_TFYppTc9Q8ANXCjsKxcVvNbLyqHKr-VYjdcLZxV3no,6608
+model/initial_conditions.py,sha256=3ZmJeABD1xHb-qZ2tBlIFnHVvHWJxygTgtIw5t7k1oM,5427
+model/model.py,sha256=RvYQig-8aFmUmY6eyUhQ-DZ9U2mc0ods4Zo-tVeERbI,1973
+model/models/GN.py,sha256=ymOlDpn8I5Xzk2GvXm2gvialSWTzxpPSvxzkP0qOMlc,1913
+model/models/advection.py,sha256=G-oDMNbKAahlW90ocyf-HGM55-JX59cMARV8JaRfe_g,2111
+model/models/basisfunctions.py,sha256=ZHeQYXwgpB8YAZ-8l3NYYvi8CSuvFzJ0xiyaai4WsCA,5410
+model/models/basismatrices.py,sha256=W6hJqNhxawfqN3wAFnXvbaclavJ0QKPgs1jeDcPwpUA,13074
+model/models/coupled_constrained.py,sha256=q2qOh7Vf3ryG0rS9VXD4oUDMaHEZ7g74AtgHQePXEC0,1741
+model/models/poisson.py,sha256=B_8qc_6FnEzB91-fdKzWlHo8Jiq1Kmjxp1xBC6YB-ag,1075
+model/models/shallow_moments.py,sha256=kSNxnAQnCmmFBggcXmOh1yVlF_1_8-QxDGLPvajcELo,27098
+model/models/shallow_moments_sediment.py,sha256=rt1ohClioEpPOYO0w1zB9VHGkjP0RWxM4M18BEA00rI,14292
+model/models/shallow_moments_topo.py,sha256=_5KWvT3iUbPU5zAZN4J904b1r5yJiMTFojmeVD7oxsg,17402
+model/models/shallow_moments_variants.py,sha256=NsRF9kaiYxQtV94oOZsMBDFXwzmm_R-rz6fAUuYQRxc,52059
+model/models/shallow_water.py,sha256=1Sn8mVCUiYZue2SvLfGfRMOsfD0G9hL72x_ENdA9QRU,8412
+model/models/shallow_water_topo.py,sha256=Y-ibbM9Hj7gPreZUmTEBcYlhM0AzIiMYKuEeJYi-Pxc,3455
+model/models/shear_shallow_flow.py,sha256=O2JZaK1E8qUPVJHYaTksMDV3IuxD9nez1hHmdKHRJng,17250
+model/models/sme_turbulent.py,sha256=8PzvbSdEYNEaz-9LCvahL_-Gt_tdGv3PPjBqYRz11V4,24048
+model/models/vam.py,sha256=aHI1LCkNQC8g8uEZujp36NYVuaKxfCapl9W-5fSzLWk,15114
+postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postprocessing/plotting.py,sha256=WJs_CCoeiWhGnVXQx8BBVmKxJkVFJYVnmVVdTDjz0J4,7005
+postprocessing/postprocessing.py,sha256=9-c-CJ1jevY74JatSjDRYWzIenxogS7jO3-7Ty_B9k4,2860
+preprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+preprocessing/openfoam_moments.py,sha256=22SRInpuk57VhWAFNVEPeNMy9F6ka5rnadBxNQSHBGM,14688
+transformation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/helpers.py,sha256=KClsyBc0LZNocKzbfknhhYPshA83cDLkzfAKkPGoy1o,915
+transformation/to_amrex.py,sha256=TZofZ9B-1ljIn3EVuMjZW21XJG2inlitGzSXz8LmE94,9639
+transformation/to_c.py,sha256=balvP-qJOqUIgI_cVVq4ie6cz1vd1tzPoljdVJ_nq28,7245
+transformation/to_jax.py,sha256=XkQHMv8hNm9kMcUm8xHZMhlsQqK9_4IDuUw8phFJviU,395
+transformation/to_numpy.py,sha256=cWs4uwg8w8fBHlNUYdayf03crrBYYWxpckxH-0t7tEU,4548
+transformation/to_openfoam.py,sha256=rbh7-p89zWS9Sk8HTm5PjCOV7bk2xK5x_EyVn79a114,10723
+transformation/to_ufl.py,sha256=U4TQpBStlR44bXP8_ochYYDSYk1kZTlpKl-aZ7WNTqw,1991
+zoomy_core-0.1.14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+zoomy_core-0.1.14.dist-info/METADATA,sha256=3VTd1UVauKzQKKadwu-LmMMWG5WDZBuVGAlyfwQ_y74,1847
+zoomy_core-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zoomy_core-0.1.14.dist-info/top_level.txt,sha256=a7udeQrjSnc2Y_GED5JOFjl8Cw6ATndPtiX5o1cvcF0,75
+zoomy_core-0.1.14.dist-info/RECORD,,

zoomy_core-0.1.14.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+