edmkit 0.0.0__py3-none-any.whl

edmkit/__init__.py

@@ -0,0 +1,4 @@
+# ruff: noqa: F401
+from .embedding import lagged_embed
+from .simplex_projection import simplex_projection
+from .smap import smap

edmkit/ccm.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from edmkit.embedding import lagged_embed
+from edmkit.tensor import Tensor, dtypes
+from edmkit.util import pad, pairwise_distance, topk
+
+
+def calculate_rho(observations: np.ndarray, predictions: np.ndarray):
+    assert len(observations) == len(predictions), "observations and predictions must have the same length"
+    return np.corrcoef(observations.T, predictions.T)[0, 1]
+
+
+def search_best_embedding(
+    x: np.ndarray, tau_list: list[int], e_list: list[int], Tp: int, max_L: int | None = None, rng: np.random.Generator | None = None
+):
+    assert all(tau > 0 for tau in tau_list), f"tau must be positive, got tau_list={tau_list}"
+    assert all(e > 0 for e in e_list), f"e must be positive, got e_list={e_list}"
+    assert max_L is None or max_L <= len(x), f"max_L must be less than or equal to len(x), got max_L={max_L} and len(x)={len(x)}"
+
+    if rng is None:
+        rng = np.random.default_rng()
+
+    if max_L is not None:
+        x = x[rng.choice(len(x), min(len(x), max_L), replace=False)]
+
+    # lagged_embed(x, tau, e).shape[0] == len(x) - (e - 1) * tau
+    min_L = len(x) - (max(e_list) - 1) * max(tau_list)
+    assert min_L > 0, (
+        f"Not enough data points to embed, got len(x)(={len(x)}) - max(e)(={max(e_list)}) * max(tau)(={max(tau_list)}) = min_L(={min_L})"
+    )
+
+    embeddings: list[np.ndarray] = []
+    for tau in tau_list:
+        for e in e_list:
+            # align the time indices of the embeddings. note that the time index of the first embedding is `1 + (e - 1) * tau`
+            embeddings.append(lagged_embed(x, tau, e)[-min_L:])  # (min_L, e)
+
+    X = pad(embeddings)  # X.shape == (len(tau_list) * len(e_list), min_L, max(e_list))
+    D = pairwise_distance(Tensor(X, dtype=dtypes.float32)).numpy()
+
+    L = min_L
+    seq = np.arange(L)
+    lib_size = L // 2
+
+    rho = np.zeros((len(tau_list), len(e_list)))
+
+    for i, tau in enumerate(tau_list):
+        for j, e in enumerate(e_list):
+            batch = i * len(e_list) + j
+
+            samples_indecies = np.arange(lib_size, L)
+
+            observations = X[batch, samples_indecies, :e]
+            predictions = np.zeros((len(samples_indecies), e), dtype=x.dtype)
+
+            for k, t in enumerate(samples_indecies):
+                # [0, 1, 2, 3, 4 | 5, 6, 7, 8, 9, 10]; initialize mask, `|` separates lib and test
+                mask = np.ones(L, dtype=bool)
+
+                # [0, 1, 2, 3, 4 | 5, F, 7, 8, 9, 10], t = 6; exclude self
+                mask[t] = False
+
+                # [0, 1, 2, 3, 4 | 5, F, 7, 8, F, F ], Tp = 2; exclude last Tp points to prevent out-of-bound indexing on predictions
+                mask[-Tp:] = False
+
+                # [0, 1, 2, 3, 4 | F, F, F, F, F, F ], lib_size = 5; exclude test points
+                mask[lib_size:] = False
+
+                # find k(=e+1) nearest neighbors in phase space for simplex projection
+                indices_masked, _ = topk(D[batch, t, mask], e + 1, largest=False)
+                indices = seq[mask][indices_masked]
+                predictions[k] = X[batch, indices + Tp, :e].mean()
+
+            rho[i, j] = calculate_rho(observations, predictions)
+
+    return rho

edmkit/embedding.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+
+def lagged_embed(x: np.ndarray, tau: int, e: int):
+    """Lagged embedding of a time series `x`.
+
+    Parameters
+    ----------
+        `x` : `np.ndarray` of shape `(N,)`
+        `tau` : `int`
+        `e` : `int`
+
+    Returns
+    -------
+        `np.ndarray` of shape `(N - (e - 1) * tau, e)`
+
+    Raises
+    ------
+    AssertionError
+        - If `x` is not a 1D array.
+        - If `tau` or `e` is not positive.
+        - If `e * tau >= len(x)`.
+
+    Notes
+    -----
+    - While open to interpretation, it's generally more intuitive to consider the embedding as starting from the `(e - 1) * tau`th element of the original time series and ending at the `len(x) - 1`th element (the last value), rather than starting from the 0th element and ending at `len(x) - 1 - (e - 1) * tau`.
+    - This distinction reflects whether we think of "attaching past values to the present" or "attaching future values to the present". The information content of the result is the same either way.
+    - The use of `reversed` in the implementation emphasizes this perspective.
+
+    Examples
+    --------
+    ```
+    import numpy as np
+    from edm.embedding import lagged_embed
+
+    x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    tau = 2
+    e = 3
+
+    E = lagged_embed(x, tau, e)
+    print(E)
+    print(E.shape)
+    # [[4 2 0]
+    #  [5 3 1]
+    #  [6 4 2]
+    #  [7 5 3]
+    #  [8 6 4]
+    #  [9 7 5]]
+    # (6, 3)
+    ```
+    """
+    assert len(x.shape) == 1, f"X must be a 1D array, got x.shape={x.shape}"
+    assert tau > 0 and e > 0, f"tau and e must be positive, got tau={tau}, e={e}"
+    assert (e - 1) * tau <= x.shape[0], f"e and tau must satisfy `(e - 1) * tau < len(X)`, got e={e}, tau={tau}"
+
+    return np.array([x[tau * (e - 1) :]] + [x[tau * i : -tau * ((e - 1) - i)] for i in reversed(range(e - 1))]).transpose()

edmkit/generate/__init__.py

@@ -0,0 +1,4 @@
+# ruff: noqa: F401
+from .double_pendulum import double_pendulum, to_xy
+from .lorenz import lorenz
+from .mackey_glass import mackey_glass

edmkit/generate/double_pendulum.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+
+def double_pendulum(
+    m1: float,
+    m2: float,
+    L1: float,
+    L2: float,
+    g: float,
+    X0: np.ndarray,  # (theta1, theta2, omega1, omega2)
+    dt: float,
+    t_max: int,
+):
+    def f(x: np.ndarray):
+        theta1, theta2, omega1, omega2 = x
+        delta = theta1 - theta2
+
+        denom = 2 * m1 + m2 - m2 * np.cos(2 * delta)
+
+        dtheta1_dt = omega1
+        dtheta2_dt = omega2
+
+        domega1_dt = (
+            -g * (2 * m1 + m2) * np.sin(theta1)
+            - m2 * g * np.sin(theta1 - 2 * theta2)
+            - 2 * np.sin(delta) * m2 * (omega2**2 * L2 + omega1**2 * L1 * np.cos(delta))
+        ) / (L1 * denom)
+
+        domega2_dt = (2 * np.sin(delta) * (omega1**2 * L1 * (m1 + m2) + g * (m1 + m2) * np.cos(theta1) + omega2**2 * L2 * m2 * np.cos(delta))) / (
+            L2 * denom
+        )
+
+        return np.array([dtheta1_dt, dtheta2_dt, domega1_dt, domega2_dt])
+
+    t = np.arange(0, t_max, dt)
+    X = np.zeros((len(t), 4))
+    X[0] = X0
+
+    for i in range(1, len(t)):
+        X[i] = X[i - 1] + dt * f(X[i - 1])
+
+    return t, X
+
+
+def to_xy(L1: float, L2: float, theta1: np.ndarray, theta2: np.ndarray):
+    x1 = L1 * np.sin(theta1)
+    y1 = -L1 * np.cos(theta1)
+
+    x2 = x1 + L2 * np.sin(theta2)
+    y2 = y1 - L2 * np.cos(theta2)
+
+    return x1, y1, x2, y2

edmkit/generate/lorenz.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+
+def lorenz(
+    sigma: float,
+    rho: float,
+    beta: float,
+    X0: np.ndarray,
+    dt: float,
+    t_max: int,
+):
+    def f(x: np.ndarray):
+        return np.array([[-sigma, sigma, 0], [rho, -1, -x[0]], [0, x[0], -beta]]) @ x
+
+    t = np.arange(0, t_max, dt)
+    X = np.zeros((len(t), 3))
+    X[0] = X0
+
+    for i in range(1, len(t)):
+        X[i] = X[i - 1] + dt * f(X[i - 1])
+
+    return t, X

edmkit/generate/mackey_glass.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+
+def mackey_glass(tau: float, n: int, beta: float, gamma: float, x0: float, dt: float, t_max: int):
+    def f(x, x_tau):
+        return beta * x_tau / (1 + x_tau**n) - gamma * x
+
+    t = np.arange(0, t_max, dt)
+    x = np.zeros_like(t)
+
+    tau_idx = int(tau / dt)
+    x[:tau_idx] = x0
+
+    for i in range(tau_idx, len(t)):
+        x[i] = x[i - 1] + dt * f(x[i - 1], x[i - tau_idx])
+
+    return t, x

edmkit/simplex_projection.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from edmkit.tensor import Tensor, dtypes
+from edmkit.util import pairwise_distance, topk
+
+
+def simplex_projection(
+    X: np.ndarray,
+    Y: np.ndarray,
+    query_points: np.ndarray,
+):
+    """
+    Perform simplex projection from `X` to `Y` using the nearest neighbors of the points specified by `query_points`.
+
+    Parameters
+    ----------
+    `X` : `np.ndarray`
+        The input data
+    `Y` : `np.ndarray`
+        The target data
+    `query_points` : `np.ndarray`
+        The query points for which to find the nearest neighbors in `X`.
+
+    Returns
+    -------
+    predictions : `np.ndarray`
+        The predicted values based on the weighted mean of the nearest neighbors in `Y`.
+
+    Raises
+    ------
+    AssertionError
+        - If the input arrays `X` and `Y` do not have the same number of points.
+    """
+    assert X.shape[0] == Y.shape[0], f"X and Y must have the same length, got X.shape={X.shape} and Y.shape={Y.shape}"
+
+    D = pairwise_distance(Tensor(query_points, dtype=dtypes.float32), Tensor(X, dtype=dtypes.float32)).numpy()
+    D = np.sqrt(D)
+
+    k: int = X.shape[1] + 1
+    predictions = np.zeros(len(query_points))
+
+    for i in range(len(query_points)):
+        # find k nearest neighbors
+        indices, distances = topk(D[i], k, largest=False)
+
+        d_min = np.fmax(distances[0], 1e-6)  # clamp to avoid division by zero
+        weights = np.exp(-distances / d_min)
+
+        predictions[i] = np.sum(weights * Y[indices]) / np.sum(weights)
+
+    return predictions

edmkit/smap.py

@@ -0,0 +1,72 @@
+import numpy as np
+
+from edmkit.tensor import Tensor, dtypes
+from edmkit.util import pairwise_distance
+
+
+def smap(
+    X: np.ndarray,
+    Y: np.ndarray,
+    query_points: np.ndarray,
+    theta: float,
+):
+    """
+    Perform S-Map (local linear regression) from `X` to `Y`.
+
+    Parameters
+    ----------
+    `X` : `np.ndarray`
+        The input data
+    `Y` : `np.ndarray`
+        The target data
+    `query_points` : `np.ndarray`
+        The query points for which to make predictions.
+    `theta` : `float`
+        Locality parameter. (0: global linear, >0: local linear)
+
+    Returns
+    -------
+    predictions : `np.ndarray`
+        The predicted values based on the weighted linear regression.
+
+    Raises
+    ------
+    AssertionError
+        - If the input arrays `X` and `Y` do not have the same number of points.
+    """
+    assert X.shape[0] == Y.shape[0], f"X and Y must have the same length, got X.shape={X.shape} and Y.shape={Y.shape}"
+    X = X[:, None] if X.ndim == 1 else X
+    Y = Y[:, None] if Y.ndim == 1 else Y
+    query_points = query_points[:, None] if query_points.ndim == 1 else query_points
+
+    D = pairwise_distance(Tensor(query_points, dtype=dtypes.float32), Tensor(X, dtype=dtypes.float32)).numpy()
+    D = np.sqrt(D)
+
+    N_pred = len(query_points)
+    predictions = np.zeros(N_pred)
+
+    X = np.insert(X, 0, 1, axis=1)  # add intercept term
+    query_points = np.insert(query_points, 0, 1, axis=1)  # add intercept term
+
+    for i in range(N_pred):
+        distances = D[i]
+
+        if theta == 0:
+            weights = np.ones(X.shape[0])
+        else:
+            d_mean = np.fmax(np.mean(distances), 1e-6)  # clamp to avoid division by zero
+            weights = np.exp(-theta * distances / d_mean)
+        weights = weights[:, None]
+
+        A = weights * X  # A.shape = (N, E+1)
+        B = weights * Y  # B.shape = (N, E')
+
+        try:
+            C, residuals, rank, s = np.linalg.lstsq(A, B)
+        except np.linalg.LinAlgError:
+            # If singular, fallback to pseudo-inverse
+            C = np.linalg.pinv(A) @ B
+
+        predictions[i] = query_points[i] @ C
+
+    return predictions

edmkit/tensor.py

@@ -0,0 +1,15 @@
+# ruff: noqa: F401
+import platform
+
+# workaround
+if platform.system() == "Darwin" and platform.processor() != "arm":
+    import os
+
+    os.environ["METAL_XCODE"] = "1"
+    os.environ["DISABLE_COMPILER_CACHE"] = "1"
+
+    print("Running on macOS, setting METAL_XCODE=1 and DISABLE_COMPILER_CACHE=1")
+
+
+from tinygrad import Tensor
+from tinygrad.dtype import dtypes

edmkit/util.py

@@ -0,0 +1,190 @@
+import numpy as np
+
+from edmkit.tensor import Tensor
+
+
+def pad(As: list[np.ndarray]):
+    """Pad the `np.ndarray` in `Xs` to merge them into a single `np.ndarray`.
+
+    Parameters
+    ----------
+        `As` : `list` of `np.ndarray` of shape `(L, D_i)`
+
+    Returns
+    -------
+        Single `np.ndarray` of shape `(B, L, max(D))` where `B` is `len(As)`
+
+    Raises
+    ------
+    AssertionError
+        - If any array in `As` is not 2D.
+        - If the first dimension of all arrays in `As` are not equal.
+    """
+    assert all(A.ndim == 2 for A in As), f"All arrays must be 2D, got {[A.ndim for A in As]}"
+    assert all(A.shape[0] == As[0].shape[0] for A in As), f"All arrays must have the same length, got {[A.shape[0] for A in As]}"
+
+    B = len(As)
+    L = As[0].shape[0]
+    max_D = max(t.shape[-1] for t in As)  # type: ignore
+
+    A = np.zeros((B, L, max_D), dtype=As[0].dtype)
+    for i, x in enumerate(As):
+        A[i, :, : x.shape[-1]] = x
+
+    return np.ascontiguousarray(A)
+
+
+def pairwise_distance(A: Tensor, B: Tensor | None = None) -> Tensor:
+    """Compute the pairwise squared Euclidean distance between points in `A` (or between points in `A` and `B`).
+
+    Parameters
+    ----------
+    `A` : `Tensor` of shape `(L, D)` or `(B, L, D)`
+        - `B`: batch size
+        - `L`: number of points
+        - `D`: dimension of each point
+    `B` : `Tensor` of shape `(L', D)` or `(B, L', D)`
+        - `B`: batch size
+        - `L'`: number of points
+        - `D`: dimension of each point
+
+    Returns
+    -------
+    When `A` is of shape `(L, D)`:
+        `Tensor` of shape `(L, L)` [or `(L, L')`] where the element at position `(i, j)` is the squared Euclidean distance between `A[i]` and `A[j]` [or between `A[i]` and `B[j]`].
+    When `A` is of shape `(B, L, D)`:
+        `Tensor` of shape `(B, L, L)` [or `(B, L, L')`] where the element at position `(b, i, j)` is the squared Euclidean distance between `A[b, i]` and `A[b, j]`.
+
+    Raises
+    ------
+    AssertionError
+        - If `A` is not a 2D or 3D tensor.
+        - If `B` is not `None` and `A` and `B` have different number of dimensions.
+    """
+    assert A.ndim == 2 or A.ndim == 3, f"A must be a 2D or 3D tensor, got A.ndim={A.ndim}"
+    assert B is None or (A.ndim == B.ndim), f"A and B must have the same number of dimensions, got A.ndim={A.ndim}, B.ndim={B.ndim}"
+
+    if B is None:
+        B = A
+
+    A_sq = A.pow(2).sum(-1, keepdim=True)
+    B_sq = B.pow(2).sum(-1, keepdim=True).transpose(-1, -2)
+
+    D = A_sq + B_sq - 2 * A.matmul(B.transpose(-1, -2))
+
+    return D.clamp(min_=0)
+
+
+def dtw(A: Tensor, B: Tensor):
+    """
+    Computes the Dynamic Time Warping (DTW) distance between two sequences `x` and `y`.
+
+    Parameters
+    ----------
+        `A` : Tensor of shape `(N,D)`
+        `B` : Tensor of shape `(M,D)`
+
+    Returns
+    -------
+        distance : float
+    """
+    N = A.shape[0]
+    M = B.shape[0]
+
+    D: np.ndarray = pairwise_distance(A, B).numpy()
+
+    dp = np.full((N + 1, M + 1), np.inf)
+    dp[0, 0] = 0.0  # left-top corner
+
+    # Process the DP table along anti-diagonals
+    # Grouping by anti-diagonals allows for vectorized computation: i + j = k
+    for k in range(2, N + M + 1):
+        i_start = max(1, k - M)
+        i_end = min(N, k - 1)
+        if i_start > i_end:
+            continue
+
+        # i and j are vectors of indices that satisfy i + j = k
+        i = np.arange(i_start, i_end + 1)
+        j = k - i
+
+        # Vectorized version of dp[i,j] = D[i-1, j-1] + min(dp[i-1,j], dp[i,j-1], dp[i-1,j-1])
+        #                                               top            left       top-left
+        min_prev = np.minimum(np.minimum(dp[i - 1, j], dp[i, j - 1]), dp[i - 1, j - 1])
+        dp[i, j] = D[i - 1, j - 1] + min_prev
+
+    return dp[N, M]
+
+
+def topk(x: np.ndarray, k: int, largest=True):
+    """Find the `k` largest or smallest elements in `x`.
+
+    Parameters
+    ----------
+    `x` : `np.ndarray` of shape (N,)
+    `k` : `int`
+    `largest` : `bool`
+
+    Returns
+    -------
+    `indices` : `np.ndarray` of shape `(k,)`
+    `values` : `np.ndarray` of shape `(k,)`
+
+    Raises
+    ------
+    AssertionError
+        - If `x` is not a 1D array.
+        - If `k` is not in the range `(0, len(x)]`.
+
+    Notes
+    -----
+    `values` are sorted in ascending order. (i.e. `values[0]` is the smallest value in `values`)
+    """
+    assert x.ndim == 1, f"x must be a 1D array, got x.ndim={x.ndim}"
+    assert k > 0 and k <= len(x), f"k must satisfy 0 < k <= len(x), got k={k}, len(x)={len(x)}"
+
+    if largest:
+        indices = np.argpartition(-x, k - 1)[:k]
+    else:
+        indices = np.argpartition(x, k - 1)[:k]
+
+    argsort = np.argsort(x[indices], kind="stable")
+
+    indices = indices[argsort]
+    values = x[indices]
+
+    return indices, values
+
+
+def autocorrelation(x: np.ndarray, max_lag: int, step: int = 1):
+    """
+    Computes the autocorrelation of a given 1D numpy array up to a specified maximum lag.
+
+    Parameters
+    ----------
+        `x` : `np.ndarray` The input array for which to compute the autocorrelation.
+        `max_lag` : `int` The maximum lag up to which the autocorrelation is computed.
+        `step` : `int`, `optional` The step size for the lag. Default is 1.
+
+    Returns
+    -------
+        `np.ndarray` of shape `(max_lag // step + 1,)` containing the autocorrelation values.
+    """
+    x = x - np.mean(x)
+
+    n = len(x)
+    # next_pow2 is the next power of 2 greater than or equal to 2 * n - 1 for efficient FFT computation
+    next_pow2 = int(2 ** np.ceil(np.log2(2 * n - 1)))
+    padded = np.zeros(next_pow2)
+    padded[:n] = x
+
+    f = np.fft.fft(padded)
+    # Wiener-Khinchin theorem
+    acf = np.fft.ifft(f * np.conjugate(f)).real
+    acf = acf[:n]
+
+    # Normalization
+    acf = acf / (n * np.var(x))
+
+    lags = np.arange(0, min(max_lag, n), step)
+    return acf[lags]

edmkit-0.0.0.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: edmkit
+Version: 0.0.0
+Summary: Simple EDM (Empirical Dynamic Modeling) library
+Author-email: FUJISHIGE TEMMA <tenma.x0@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: tinygrad>=0.11.0
+Description-Content-Type: text/markdown
+
+# edmkit
+
+This library is a collection of tools and utilities that are useful for Empirical Data Modeling (EDM) and related tasks. The library is designed to be fast and lightweight, and easy to use.
+
+::: warning
+This library is still under intensive development so API may change in the future.
+:::
+
+## Installation
+
+To install the library, you can use pip:
+
+```bash
+pip install edmkit
+```
+
+Or you can also use [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add edmkit
+```
+
+## Usage
+
+Most of the functions accept and return `numpy` arrays or `edmkit.Tensor`(alias to `tinygrad.Tensor`).

edmkit-0.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+edmkit/__init__.py,sha256=LmFQcNU-qPKJKy7KO_wNDhv_ce5uL_qvyDIiiq6-p7w,129
+edmkit/ccm.py,sha256=6KL9wvP5NjFYURiUyJ100uUYcQXpp8j-r1utHcFiMjg,3159
+edmkit/embedding.py,sha256=kKxhe5q7EQ7EsjIMCxkStMt_ZZNe2510CHs_pqP_bAQ,1834
+edmkit/simplex_projection.py,sha256=q9RLLZm0_WNkF4LzsY5B8hUwTSry__gRMKDdVDOaNUE,1519
+edmkit/smap.py,sha256=DQuJJyJmQmItzDDAV8kyM75v7M3Zmqzxio-YOiXhbC4,2133
+edmkit/tensor.py,sha256=BL5KIVQQHwBK1DngXlJljRtjYElpRnp_8eKv82T709Q,362
+edmkit/util.py,sha256=xmD2h_cpWIZfVnppLkdFfSZuAsb3MTyKD0i0dZvWVpo,5853
+edmkit/generate/__init__.py,sha256=eltkZ54rCqYo1fFOizcZAPNIebBoQKBRq8KjSD2-VEM,137
+edmkit/generate/double_pendulum.py,sha256=Hj9ZHakGcp1lZjwGFHjg7i6kJcJdoBqSQ4yoqTWI-ok,1310
+edmkit/generate/lorenz.py,sha256=Mu0Dh8NVpSvnE3NtgjF6HCS9FdMSHOQqVhrhXNzE8UM,419
+edmkit/generate/mackey_glass.py,sha256=oDG9qdDKp3Hbm0NcN3e_y9Yw6xBcekEKN5C99ofKz8c,420
+edmkit-0.0.0.dist-info/METADATA,sha256=l5u88ztbuMi1Heu3HhptNJW40QxBuYLsyjmbdkYQhM0,892
+edmkit-0.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+edmkit-0.0.0.dist-info/licenses/LICENSE,sha256=AUUYs0rQU_1YkfukMYuOHPTN33XjUc881t5Xl-u-i1k,1062
+edmkit-0.0.0.dist-info/RECORD,,

edmkit-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

edmkit-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 temma
+
+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.