seiscode-models 0.1.0__py3-none-any.whl

seiscode_models/__init__.py

@@ -0,0 +1,42 @@
+"""SeisCode Models: Synthetic subsurface velocity model generators."""
+from .models.primitives import (
+    gradient_background,
+    add_gaussian_anomaly,
+    add_fault_offset,
+)
+from .models.geological import (
+    dipping_layers,
+    sinusoidal_interface,
+    faulted_layers,
+    checkerboard,
+    salt_dome,
+    low_velocity_layer,
+    heterogeneous_anomaly_model
+)
+from .utils.dtypes import parse_dtype
+from .utils.validation import validate_model
+from .utils.io import (
+    export_model,
+    load_model
+)
+from .utils.visualization import quick_view
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "gradient_background",
+    "add_gaussian_anomaly",
+    "add_fault_offset",
+    "parse_dtype",
+    "validate_model",
+    "dipping_layers",
+    "sinusoidal_interface",
+    "faulted_layers",
+    "checkerboard",
+    "salt_dome",
+    "low_velocity_layer",
+    "heterogeneous_anomaly_model",
+    "export_model",
+    "load_model",
+    "quick_view"
+]

seiscode_models/models/__init__.py

@@ -0,0 +1,82 @@
+"""Primitive building blocks for subsurface velocity models with dtype support."""
+import numpy as np
+from ..utils.dtypes import parse_dtype
+
+def gradient_background(nx: int, nz: int, v0: float = 1500.0, v1: float = 4500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a linear velocity gradient with depth.
+
+    Parameters
+    ----------
+    nx : int
+        Number of cells along x (horizontal direction).
+    nz : int
+        Number of cells along z (vertical direction, positive downward).
+    v0 : float, optional
+        Velocity at the surface, in m/s. Default is 1500.0.
+    v1 : float, optional
+        Velocity at the bottom of the model, in m/s. Default is 4500.0.
+    dtype : str or np.dtype, optional
+        Data type precision ('f32', 'f64', etc.). Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Velocity field in m/s with the requested dtype.
+    """
+    dt = parse_dtype(dtype)
+    z = np.linspace(0.0, 1.0, nz, dtype=dt)
+    v_col = v0 + (v1 - v0) * z
+    return np.broadcast_to(v_col, (nx, nz)).copy()
+
+def add_gaussian_anomaly(v: np.ndarray, cx: float, cz: float, sigma_x: float, sigma_z: float, dv: float, vmin: float = 200.0, vmax: float = 8000.0) -> np.ndarray:
+    """Add a Gaussian velocity anomaly to an existing model.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity field to modify (not modified in place).
+    cx, cz : float
+        Center position along x and z, in cells.
+    sigma_x, sigma_z : float
+        Gaussian standard deviation along x and z, in cells.
+    dv : float
+        Amplitude of the anomaly at the center, in m/s.
+    vmin, vmax : float, optional
+        Clipping velocity bounds, in m/s.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Copy of v with the anomaly added, preserving dtype and clipped.
+    """
+    nx, nz = v.shape
+    dt = v.dtype
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    g = dv * np.exp(-((ii - cx) ** 2 / (2 * sigma_x ** 2) + (jj - cz) ** 2 / (2 * sigma_z ** 2)))
+    return np.clip(v + g, vmin, vmax).astype(dt)
+
+def add_fault_offset(v: np.ndarray, ix_fault: int, throw: int) -> np.ndarray:
+    """Shift layers on either side of a vertical fault.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Stratified velocity field to shift.
+    ix_fault : int
+        Column index of the fault.
+    throw : int
+        Fault throw in cells along z.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Shifted field preserving original dtype.
+    """
+    out = v.copy()
+    left, right = slice(None, ix_fault), slice(ix_fault, None)
+    if throw >= 0:
+        out[left, throw:] = v[left, :out.shape[1] - throw]
+    else:
+        out[right, :throw] = v[right, -throw:]
+    return out

seiscode_models/models/geological.py

@@ -0,0 +1,92 @@
+"""Geological velocity models supporting f32/f64 precision."""
+import numpy as np
+from .primitives import gradient_background, add_gaussian_anomaly, add_fault_offset
+from ..utils.dtypes import parse_dtype
+
+def dipping_layers(nx: int = 201, nz: int = 51, dx: float = 1.0, dz: float = 1.0,
+                   v: tuple = (1800.0, 2400.0, 3200.0, 4200.0), dip_deg: float = 8.0, dtype=np.float32) -> np.ndarray:
+    """Generate dipping planar layers with the same dip angle."""
+    dt = parse_dtype(dtype)
+    v_arr = np.asarray(v, dtype=dt)
+    x = np.arange(nx, dtype=dt) * dx
+    dip = np.deg2rad(dip_deg)
+    v_out = np.full((nx, nz), v_arr[-1], dtype=dt)
+    depths = [0.0]
+    for k in range(1, len(v_arr)):
+        depths.append(depths[-1] + 10.0 * k)
+    for k in range(len(v_arr) - 2, -1, -1):
+        z_int = depths[k] + (x - x.mean()) * np.tan(dip)
+        k_int = np.clip((z_int / dz).astype(int), 0, nz - 1)
+        for i in range(nx):
+            v_out[i, :k_int[i]] = v_arr[k]
+    return v_out
+
+def sinusoidal_interface(nx: int = 201, nz: int = 51, period: float = 100.0, amplitude: float = 8.0,
+                         v_top: float = 2000.0, v_bottom: float = 3500.0, dtype=np.float32) -> np.ndarray:
+    """Generate two layers separated by a sinusoidal interface."""
+    dt = parse_dtype(dtype)
+    x = np.arange(nx, dtype=dt)
+    z_int = nz * 0.45 + amplitude * np.sin(2 * np.pi * x / period)
+    k_int = z_int.astype(int)
+    v = np.full((nx, nz), v_bottom, dtype=dt)
+    for i in range(nx):
+        v[i, :k_int[i]] = v_top
+    return v
+
+def faulted_layers(nx: int = 201, nz: int = 51, ix_fault: int = 120, throw: int = 8,
+                   v: tuple = (1800.0, 2400.0, 3200.0, 4200.0), dtype=np.float32) -> np.ndarray:
+    """Generate stratigraphic layers with a normal fault."""
+    dt = parse_dtype(dtype)
+    base = np.zeros((nx, nz), dtype=dt)
+    bounds = [0, 12, 28, 40, nz]
+    vs = np.asarray(v, dtype=dt)
+    for k in range(4):
+        base[:, bounds[k]:bounds[k + 1]] = vs[k]
+    return add_fault_offset(base, ix_fault, throw).astype(dt)
+
+def checkerboard(nx: int = 201, nz: int = 51, cell: int = 20, v0: float = 3000.0,
+                 dv: float = 600.0, dtype=np.float32) -> np.ndarray:
+    """Generate a checkerboard pattern for resolution testing."""
+    dt = parse_dtype(dtype)
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    pat = ((ii // cell) + (jj // cell)) % 2
+    return np.where(pat == 0, v0 + dv, v0 - dv).astype(dt)
+
+def salt_dome(nx: int = 201, nz: int = 51, cx: int = 140, width: float = 40.0,
+              v_salt: float = 4500.0, v_sed: float = 2500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a salt dome model with semi-elliptical shape."""
+    dt = parse_dtype(dtype)
+    v = gradient_background(nx, nz, v_sed, 4000.0, dtype=dt)
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    r = ((ii - cx) / width) ** 2 + np.clip((nz * 0.9 - jj) / (nz * 0.9), 0, None) ** 2
+    v[r < 1.0] = v_salt
+    return v
+
+def low_velocity_layer(nx: int = 201, nz: int = 51, k0: int = 20, thickness: int = 8,
+                       v_slow: float = 1200.0, dtype=np.float32) -> np.ndarray:
+    """Generate a model with a buried low-velocity channel."""
+    dt = parse_dtype(dtype)
+    v = gradient_background(nx, nz, 1800.0, 4500.0, dtype=dt)
+    v[:, k0:k0 + thickness] = v_slow
+    return v
+
+def heterogeneous_anomaly_model(nx: int = 384, nz: int = 122, seed: int = 7, dtype=np.float32) -> np.ndarray:
+    """Generate a complex synthetic model."""
+    dt = parse_dtype(dtype)
+    rng = np.random.default_rng(seed)
+    v = gradient_background(nx, nz, 1500.0, 4800.0, dtype=dt)
+    v = add_gaussian_anomaly(v, nx * 0.72, nz * 0.35, 30.0, 12.0, 1200.0)
+    v = add_gaussian_anomaly(v, nx * 0.25, nz * 0.55, 25.0, 10.0, -700.0)
+    v = add_gaussian_anomaly(v, nx * 0.5, nz * 0.75, 40.0, 15.0, 900.0)
+    noise = rng.normal(0.0, 1.0, (nx, nz)).astype(dt)
+    k = 7
+    pad = k // 2
+    padded = np.pad(noise, pad, mode="edge")
+    smooth = np.zeros_like(noise)
+    for di in range(k):
+        for dj in range(k):
+            smooth += padded[di:di + nx, dj:dj + nz]
+    smooth /= (k * k)
+    return np.clip(v * (1.0 + 0.05 * smooth / smooth.std()), 500.0, 6000.0).astype(dt)

seiscode_models/models/primitives.py

@@ -0,0 +1,82 @@
+"""Primitive building blocks for subsurface velocity models with dtype support."""
+import numpy as np
+from ..utils.dtypes import parse_dtype
+
+def gradient_background(nx: int, nz: int, v0: float = 1500.0, v1: float = 4500.0, dtype=np.float32) -> np.ndarray:
+    """Generate a linear velocity gradient with depth.
+
+    Parameters
+    ----------
+    nx : int
+        Number of cells along x (horizontal direction).
+    nz : int
+        Number of cells along z (vertical direction, positive downward).
+    v0 : float, optional
+        Velocity at the surface, in m/s. Default is 1500.0.
+    v1 : float, optional
+        Velocity at the bottom of the model, in m/s. Default is 4500.0.
+    dtype : str or np.dtype, optional
+        Data type precision ('f32', 'f64', etc.). Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Velocity field in m/s with the requested dtype.
+    """
+    dt = parse_dtype(dtype)
+    z = np.linspace(0.0, 1.0, nz, dtype=dt)
+    v_col = v0 + (v1 - v0) * z
+    return np.broadcast_to(v_col, (nx, nz)).copy()
+
+def add_gaussian_anomaly(v: np.ndarray, cx: float, cz: float, sigma_x: float, sigma_z: float, dv: float, vmin: float = 200.0, vmax: float = 8000.0) -> np.ndarray:
+    """Add a Gaussian velocity anomaly to an existing model.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity field to modify (not modified in place).
+    cx, cz : float
+        Center position along x and z, in cells.
+    sigma_x, sigma_z : float
+        Gaussian standard deviation along x and z, in cells.
+    dv : float
+        Amplitude of the anomaly at the center, in m/s.
+    vmin, vmax : float, optional
+        Clipping velocity bounds, in m/s.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Copy of v with the anomaly added, preserving dtype and clipped.
+    """
+    nx, nz = v.shape
+    dt = v.dtype
+    ii = np.arange(nx, dtype=dt)[:, None]
+    jj = np.arange(nz, dtype=dt)[None, :]
+    g = dv * np.exp(-((ii - cx) ** 2 / (2 * sigma_x ** 2) + (jj - cz) ** 2 / (2 * sigma_z ** 2)))
+    return np.clip(v + g, vmin, vmax).astype(dt)
+
+def add_fault_offset(v: np.ndarray, ix_fault: int, throw: int) -> np.ndarray:
+    """Shift layers on either side of a vertical fault.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Stratified velocity field to shift.
+    ix_fault : int
+        Column index of the fault.
+    throw : int
+        Fault throw in cells along z.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Shifted field preserving original dtype.
+    """
+    out = v.copy()
+    left, right = slice(None, ix_fault), slice(ix_fault, None)
+    if throw >= 0:
+        out[left, throw:] = v[left, :out.shape[1] - throw]
+    else:
+        out[right, :throw] = v[right, -throw:]
+    return out

seiscode_models/utils/dtypes.py

@@ -0,0 +1,45 @@
+"""Precision management utilities for velocity models."""
+from typing import Union
+
+import numpy as np
+
+
+def parse_dtype(dtype: Union[str, np.dtype] = np.float32) -> np.dtype:
+    """Parse and validate the requested floating-point precision dtype.
+
+    Parameters
+    ----------
+    dtype : str or np.dtype, optional
+        Target precision, e.g., 'f32', 'float32', 'f64', 'float64',
+        or np.float32, np.float64. Default is np.float32.
+
+    Returns
+    -------
+    np.dtype
+        Normalized NumPy floating-point dtype.
+
+    Raises
+    ------
+    ValueError
+        If the dtype is not supported or not a floating-point type.
+    """
+    if isinstance(dtype, str):
+        dtype_lower = dtype.lower()
+
+        if dtype_lower in ("f32", "float32"):
+            return np.dtype(np.float32)
+        elif dtype_lower in ("f64", "float64"):
+            return np.dtype(np.float64)
+        else:
+            raise ValueError(
+                f"Unsupported string dtype: '{dtype}'. Use 'f32' or 'f64'."
+            )
+
+    dt = np.dtype(dtype)
+
+    if dt == np.dtype(np.float32) or dt == np.dtype(np.float64):
+        return dt
+
+    raise ValueError(
+        f"Unsupported dtype: {dt}. Only float32 (f32) and float64 (f64) are allowed."
+    )

seiscode_models/utils/io.py

@@ -0,0 +1,68 @@
+"""Input/Output utilities for exporting velocity models to seismic solvers."""
+from pathlib import Path
+import numpy as np
+from typing import Union, Tuple
+from .validation import validate_model
+
+def export_model(
+    v: np.ndarray, 
+    filepath: Union[str, Path], 
+    format: str = "bin", 
+    dx: float = 1.0, 
+    dz: float = 1.0
+) -> None:
+    """Export a velocity model to a file compatible with seismic solvers.
+
+    Parameters
+    ----------
+    v : ndarray (nx, nz)
+        Velocity model array.
+    filepath : str or Path
+        Destination file path.
+    format : str, optional
+        Export format:
+        - 'bin' or 'raw': Flat binary file (C-contiguous or Fortran-contiguous depending on solver needs).
+        - 'npy': Standard NumPy binary format preserving dtype and shape.
+        Default is 'bin'.
+    dx, dz : float, optional
+        Grid spacing (validated before export).
+    """
+    validate_model(v, dx=dx, dz=dz)
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    fmt = format.lower()
+    if fmt in ("bin", "raw"):
+        # Enregistrement en binaire brut (souvent attendu en float32/float64 pur par les solveurs C/Fortran)
+        v.tofile(filepath)
+    elif fmt == "npy":
+        np.save(filepath, v)
+    else:
+        raise ValueError(f"Unsupported export format: '{format}'. Use 'bin', 'raw', or 'npy'.")
+
+def load_model(filepath: Union[str, Path], shape: Tuple[int, int], dtype=np.float32) -> np.ndarray:
+    """Load a velocity model from a raw binary file.
+
+    Parameters
+    ----------
+    filepath : str or Path
+        Path to the binary file.
+    shape : tuple of int
+        Expected shape (nx, nz) of the model.
+    dtype : str or np.dtype, optional
+        Data type of the binary file. Default is np.float32.
+
+    Returns
+    -------
+    ndarray (nx, nz)
+        Loaded velocity model.
+    """
+    filepath = Path(filepath)
+    if filepath.suffix == ".npy":
+        return np.load(filepath)
+    
+    v = np.fromfile(filepath, dtype=dtype)
+    expected_size = shape[0] * shape[1]
+    if v.size != expected_size:
+        raise ValueError(f"File size mismatch: expected {expected_size} elements for shape {shape}, got {v.size}.")
+    return v.reshape(shape)

seiscode_models/utils/validation.py

@@ -0,0 +1,32 @@
+"""Model validation utilities."""
+import numpy as np
+
+def validate_model(v: np.ndarray, dx: float = 1.0, dz: float = 1.0, v_min: float = 200.0, v_max: float = 8000.0) -> None:
+    """Validate a velocity model array and its parameters.
+
+    Parameters
+    ----------
+    v : ndarray
+        Velocity model array (nx, nz).
+    dx, dz : float
+        Grid spacing in meters.
+    v_min, v_max : float
+        Acceptable velocity limits in m/s.
+
+    Raises
+    ------
+    ValueError
+        If the model structure, dtype, or bounds are invalid.
+    """
+    if not isinstance(v, np.ndarray):
+        raise ValueError("Model must be a NumPy array.")
+    if v.ndim != 2:
+        raise ValueError(f"Model must be 2D, got {v.ndim}D.")
+    if v.dtype not in (np.dtype(np.float32), np.dtype(np.float64)):
+        raise ValueError(f"Model dtype must be float32 or float64, got {v.dtype}.")
+    if not np.all(np.isfinite(v)):
+        raise ValueError("Model contains non-finite values (NaN or Inf).")
+    if np.any(v < v_min) or np.any(v > v_max):
+        raise ValueError(f"Velocities out of range [{v_min}, {v_max}] m/s.")
+    if dx <= 0 or dz <= 0:
+        raise ValueError("Grid spacing dx and dz must be positive.")

seiscode_models/utils/visualization.py

@@ -0,0 +1,39 @@
+"""Visualization utilities compatible with Python 3.8+."""
+import numpy as np
+from .validation import validate_model
+
+def quick_view(
+    velocities: np.ndarray, 
+    dx: float = 1.0, 
+    dz: float = 1.0, 
+    title: str = "Velocity model"
+) -> None:
+    """Display a velocity field with depth positive downward.
+
+    Parameters
+    ----------
+    velocities : ndarray (nx, nz)
+        Velocity field to display, in m/s.
+    dx : float, optional
+        Grid spacing along x, in meters. Default is 1.0.
+    dz : float, optional
+        Grid spacing along z, in meters. Default is 1.0.
+    title : str, optional
+        Figure title. Default is "Velocity model".
+    """
+    import matplotlib.pyplot as plt
+    validate_model(velocities, dx=dx, dz=dz)
+    
+    nx, nz = velocities.shape
+    fig, ax = plt.subplots(figsize=(12, 6))
+    im = ax.imshow(
+        velocities.T,
+        extent=[0, (nx - 1) * dx, (nz - 1) * dz, 0],
+        aspect="auto",
+        cmap="viridis"
+    )
+    ax.set_xlabel("x (m)")
+    ax.set_ylabel("Depth z (m)")
+    ax.set_title(title)
+    fig.colorbar(im, ax=ax, label="Velocity (m/s)")
+    plt.show()

seiscode_models-0.1.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: seiscode-models
+Version: 0.1.0
+Summary: Synthetic subsurface velocity model generators for seismic testing
+Author-email: Damien Pageot <damien.pageot@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/PageotD/seiscode-models
+Project-URL: Repository, https://github.com/PageotD/seiscode-models
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# SeisCode Models

seiscode_models-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+seiscode_models/__init__.py,sha256=4J8B9idUJGVrIPCx_2Bjy5mLjQRq4B4Bq74O3RtcGWQ,937
+seiscode_models/models/__init__.py,sha256=kjmCkZ2QldahaopnNbM_a2Ksq1uld3Ujn_oJnuV0AI0,2770
+seiscode_models/models/geological.py,sha256=gDvfw__0XeYsj3dNNuSui6woVQRrSu6oDcIQcivVre4,4281
+seiscode_models/models/primitives.py,sha256=kjmCkZ2QldahaopnNbM_a2Ksq1uld3Ujn_oJnuV0AI0,2770
+seiscode_models/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seiscode_models/utils/dtypes.py,sha256=ykk7dnOnj961-vwi1Tzfif6MReoz5yftMPM8vBh86Rw,1242
+seiscode_models/utils/io.py,sha256=Vg9TwwKpPK6C72zKc5iudPHrfOhk8TQmVWh13mD-iCk,2236
+seiscode_models/utils/validation.py,sha256=OCGNRvOPam0EMtNJd9opFPgLvv6Im9ukd1zOI6127FQ,1206
+seiscode_models/utils/visualization.py,sha256=apOR9kQHH4SHmYpiT9EtcP0sPukwtv_AZXfRjQu76Co,1128
+seiscode_models-0.1.0.dist-info/licenses/LICENSE,sha256=nWmkmlLKRYqs-P25ka5_7FH30mxPfdX8V3vROLVlqZw,1070
+seiscode_models-0.1.0.dist-info/METADATA,sha256=3zDgmUSrORII6qyqS88plpS3luWfk1K8EAC06UnQA_8,1189
+seiscode_models-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+seiscode_models-0.1.0.dist-info/top_level.txt,sha256=-mTq28wC7E8Y7_B7zGDQ805k6oggIRGO4sUJPuVZiTc,16
+seiscode_models-0.1.0.dist-info/RECORD,,

seiscode_models-0.1.0.dist-info/WHEEL

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

seiscode_models-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Damien Pageot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

seiscode_models-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seiscode_models