fmg 0.4.0__py3-none-any.whl

fmg/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+"""fmg -- Fast Memory Graphics for big images, used like OpenSlide."""
+from .__version__ import __version__
+from .core import (
+    AbstractSlide,
+    CorruptTileError,
+    FastMemoryGraphics,
+    FmgError,
+    FORMAT_VERSION,
+    configure,
+)
+
+__all__ = [
+    'open_slide', 'create_slide', 'FastMemoryGraphics', 'AbstractSlide',
+    'FmgError', 'CorruptTileError', 'configure', 'FORMAT_VERSION',
+    '__version__',
+]
+
+
+def open_slide(filename, **kwargs):
+    """Open an existing .fmg slide for reading (lazy, fork-safe)."""
+    return FastMemoryGraphics(filename, mode='r', **kwargs)
+
+
+def create_slide(filename, **kwargs):
+    """Create a writer for a new .fmg slide."""
+    return FastMemoryGraphics(filename, mode='w', **kwargs)

fmg/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 4, 0)
+
+__version__ = '.'.join(map(str, VERSION))

fmg/core.py

@@ -0,0 +1,757 @@
+# -*- coding: utf-8 -*-
+"""Fast Memory Graphics: a tiled, LMDB-backed whole-slide image.
+
+Storage layout (unchanged, so existing .fmg files stay readable)
+---------------------------------------------------------------
+    <basename>.fmg                 JSON metadata
+    <basename>/level0/            LMDB env, keys = str((x, y, x_max, y_max))
+    <basename>/level1/
+    ...
+
+A tile is encoded with ``cv2.imencode`` and decoded with ``cv2.imdecode``.
+The two are inverse operations, so the array that went in comes back out
+with the same channel order (the library treats it as RGB at the API edge).
+
+Concurrency contract
+--------------------
+* An ``Environment`` and its ``Transaction`` objects are never created in
+  ``__init__``; they are opened lazily, once per process.
+* If the object is inherited by a forked child (e.g. a PyTorch DataLoader
+  worker), the inherited handles are dropped without being closed and a
+  fresh environment is opened in the child.  Reusing a forked LMDB env is
+  undefined behaviour and is the usual cause of sporadic SIGBUS/SIGSEGV.
+* Every ``read_region`` uses its own short-lived read transaction, so the
+  same slide object is safe to use from multiple threads of one process.
+* Within one process, all slides pointing at the same directory share one
+  refcounted read-only Environment: py-lmdb refuses to open the same path
+  twice, and unpickling a slide in its parent process would otherwise fail.
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+import shutil
+import threading
+import warnings
+from collections import OrderedDict
+
+import cv2
+import lmdb
+import numpy as np
+from PIL import Image
+
+__all__ = [
+    'FmgError', 'CorruptTileError', 'AbstractSlide',
+    'FastMemoryGraphics', 'configure', 'FORMAT_VERSION',
+]
+
+FORMAT_VERSION = 2
+DEFAULT_PATCH_SIZE = 256
+# Readers pass map_size=0, so LMDB reads the real value from the file's meta
+# page (works for files written by 0.3.0 with a 1 TiB map too).  Writers get
+# a size derived from the actual image instead of blindly mapping 1 TiB per
+# level per process.
+MIN_WRITE_MAP_SIZE = 1 << 28       # 256 MiB
+MAX_WRITE_MAP_SIZE = 1 << 40       # 1 TiB, same as the original writer
+DEFAULT_COMMIT_EVERY = 2048
+SUPPORTED_EXT = {'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff', '.tif'}
+
+_cv2_pid = None
+_cv2_lock = threading.Lock()
+
+# ---------------------------------------------------------------------------
+# Process-local registry of read-only LMDB environments.
+#
+# py-lmdb refuses to open the same path twice in one process ("The environment
+# ... is already open in this process").  That happens as soon as two slide
+# objects point at the same .fmg: a Dataset plus a pickled/unpickled clone,
+# two Dataset instances over one slide, or a validation loader alongside the
+# training loader.  Sharing ONE read-only Environment (with a fresh short
+# transaction per read) is safe and avoids mapping the same file N times.
+# ---------------------------------------------------------------------------
+_env_registry = {}                 # (realpath, map_size) -> {'env': ..., 'refs': n}
+_env_registry_pid = os.getpid()
+_env_registry_lock = threading.RLock()
+
+
+def _after_fork_in_child():
+    """Drop inherited handles in the child; never close them here.
+
+    ``mdb_env_close()`` in a forked child may clear the parent's reader slot
+    / shared lock file, so the inherited Environment objects are simply
+    forgotten.  The child opens its own on first use.  Rebuilding the locks
+    also avoids a deadlock when another thread held one at fork time.
+    """
+    global _env_registry, _env_registry_pid, _env_registry_lock
+    global _cv2_pid, _cv2_lock
+    _env_registry = {}
+    _env_registry_pid = os.getpid()
+    _env_registry_lock = threading.RLock()
+    _cv2_pid = None
+    _cv2_lock = threading.Lock()
+
+
+if hasattr(os, 'register_at_fork'):
+    os.register_at_fork(after_in_child=_after_fork_in_child)
+
+
+def _acquire_read_env(path, map_size):
+    """Return a process-local read-only Environment shared by all slides."""
+    global _env_registry_pid
+    key = (os.path.realpath(path), int(map_size or 0))
+    with _env_registry_lock:
+        if _env_registry_pid != os.getpid():   # platforms without register_at_fork
+            _env_registry.clear()
+            _env_registry_pid = os.getpid()
+        entry = _env_registry.get(key)
+        if entry is not None:
+            entry['refs'] += 1
+            return entry['env']
+        env = lmdb.open(
+            path,
+            subdir=True,
+            readonly=True,
+            create=False,
+            lock=False,         # MDB_NOLOCK: no reader table, fork-safe
+            readahead=False,    # WSI reads are random, prefetch hurts
+            meminit=False,
+            map_size=map_size or 0,   # 0 = use the size stored in meta
+            max_spare_txns=8,        # makes begin() almost free
+        )
+        _env_registry[key] = {'env': env, 'refs': 1}
+        return env
+
+
+def _release_read_env(env):
+    """Release one reference; close only when the last user goes away."""
+    if env is None:
+        return
+    with _env_registry_lock:
+        for key, entry in list(_env_registry.items()):
+            if entry['env'] is env:
+                entry['refs'] -= 1
+                if entry['refs'] <= 0:
+                    del _env_registry[key]
+                    try:
+                        env.close()
+                    except Exception:
+                        pass
+                return
+        # Not registered (e.g. inherited across fork): leaving the reference
+        # alone is the safe choice, see _after_fork_in_child().
+
+
+def _tune_cv2_for_worker():
+    """Make OpenCV fork-safe, once per process.
+
+    OpenCV's internal thread pool / OpenCL context do not survive ``fork()``.
+    A child that inherits an initialised pool can deadlock or crash inside
+    ``imdecode``.  ``setNumThreads(0)`` disables the pool; it costs nothing
+    for single-image JPEG decoding.
+    """
+    global _cv2_pid
+    pid = os.getpid()
+    with _cv2_lock:
+        if _cv2_pid == pid:
+            return
+        try:
+            cv2.setNumThreads(0)
+        except Exception:  # pragma: no cover - exotic OpenCV builds
+            pass
+        try:
+            cv2.ocl.setUseOpenCL(False)
+        except Exception:  # pragma: no cover
+            pass
+        _cv2_pid = pid
+
+
+def configure(num_threads=0, use_opencl=False):
+    """Explicitly configure OpenCV for a DataLoader worker.
+
+    Normally the library calls this automatically when it detects that it is
+    running inside a forked child.  Call it yourself in ``worker_init_fn``
+    when using the ``spawn`` start method, or when you want to control the
+    setting from outside.
+    """
+    global _cv2_pid
+    with _cv2_lock:
+        try:
+            cv2.setNumThreads(int(num_threads))
+        except Exception:
+            pass
+        try:
+            cv2.ocl.setUseOpenCL(bool(use_opencl))
+        except Exception:
+            pass
+        _cv2_pid = os.getpid()
+    return os.getpid()
+
+
+class FmgError(Exception):
+    """Base exception for this package."""
+
+
+class CorruptTileError(FmgError):
+    """A tile is missing, empty or cannot be decoded."""
+
+
+def _tile_key(box):
+    """Key format is part of the on-disk format; keep tuple repr."""
+    return str(tuple(int(v) for v in box)).encode('ascii')
+
+
+def _default_params(ext):
+    if ext in ('.png',):
+        return [int(cv2.IMWRITE_PNG_COMPRESSION), 3]
+    return [int(cv2.IMWRITE_JPEG_QUALITY), 90]
+
+
+class AbstractSlide:
+    """Minimal OpenSlide-like interface."""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    def close(self):
+        raise NotImplementedError
+
+    @property
+    def level_count(self):
+        raise NotImplementedError
+
+    @property
+    def level_dimensions(self):
+        """[(width, height), ...] in level coordinates."""
+        raise NotImplementedError
+
+    @property
+    def dimensions(self):
+        """(width, height) of level 0."""
+        return self.level_dimensions[0]
+
+    @property
+    def level_downsamples(self):
+        """[float, ...], one downsample factor per level."""
+        raise NotImplementedError
+
+    @property
+    def properties(self):
+        raise NotImplementedError
+
+    def read_region(self, location, level, size):
+        """Return a PIL.Image.
+
+        location: (x, y) in the **level 0** reference frame (OpenSlide
+                  semantics).
+        level:    pyramid level.
+        size:     (width, height) in **level** coordinates.
+        """
+        raise NotImplementedError
+
+    def save_from_numpy(self, data, ext='.jpg', params=None, pyramid=False,
+                        mpp=None, patch_size=DEFAULT_PATCH_SIZE,
+                        commit_every=DEFAULT_COMMIT_EVERY, map_size=None):
+        raise NotImplementedError
+
+    def save_from_tiles(self, patches, locations, level, ext, params, txn=None):
+        raise NotImplementedError
+
+
+class FastMemoryGraphics(AbstractSlide):
+    """A tiled whole-slide image stored in LMDB.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the ``.fmg`` JSON file.
+    mode : {'r', 'w'}
+    patch_cache : int
+        Per-process LRU cache size for decoded tiles (0 disables it).  Very
+        effective for multi-epoch training, where every worker reads the
+        same tiles again and again.
+    map_size : int or None
+        Explicit LMDB map size.  ``None`` (default) means: use the size
+        stored in the file when reading, and derive a size from the image
+        when writing.  No more blind 1 TiB mapping per level per process.
+    strict : bool
+        Raise ``CorruptTileError`` on a missing/broken tile instead of
+        painting that tile black and warning once.
+    """
+
+    def __init__(self, filename, mode='r', *, patch_cache=128, map_size=None,
+                 strict=False, auto_worker_tuning=True):
+        if mode not in ('r', 'w'):
+            raise ValueError("mode must be 'r' or 'w'")
+        self._filename = os.fspath(filename)
+        self._mode = mode
+        self._data_dir = os.path.splitext(self._filename)[0]  # same as old [:-4] for '.fmg'
+        self._patch_cache_size = max(0, int(patch_cache))
+        self._map_size = int(map_size) if map_size else None
+        self._strict = bool(strict)
+        self._auto_worker_tuning = bool(auto_worker_tuning)
+
+        self._lock = threading.RLock()
+        self._cache = OrderedDict()
+        self._envs = None            # {level: lmdb.Environment} owned by THIS process
+        self._pid = None             # pid that owns self._envs
+        self._creator_pid = os.getpid()   # survives fork(), not pickling
+        self._closed = False
+        self._missing_warned = False
+
+        self._osr = {}
+        self._stored_dims = []       # (grid_x, grid_y) as written on disk
+        self._public_dims = []       # (width, height) exposed to callers
+        self._downsamples = []
+        self._legacy = False
+
+        if mode == 'r':
+            self._load_metadata()
+
+    # ------------------------------------------------------------------ #
+    # metadata
+    # ------------------------------------------------------------------ #
+    def _load_metadata(self):
+        # 'with' fixes the leaked file descriptor of the original code.
+        with open(self._filename, 'r', encoding='utf-8') as fh:
+            meta = json.load(fh)
+        if not isinstance(meta, dict) or 'level_dimensions' not in meta:
+            raise FmgError('not a valid .fmg metadata file: %s' % self._filename)
+        self._osr = meta
+        self._legacy = int(meta.get('format_version', 1)) < FORMAT_VERSION
+        self._stored_dims = [tuple(int(v) for v in d)
+                             for d in meta['level_dimensions']]
+        if any(len(d) != 2 or d[0] <= 0 or d[1] <= 0 for d in self._stored_dims):
+            raise FmgError('invalid level_dimensions in %s' % self._filename)
+        # Legacy files stored [height, width] AND used that order as the tile
+        # grid, so the grid itself is fine; only the public (w, h) view is
+        # reversed.  New files store (width, height) == grid (x, y).
+        if self._legacy:
+            self._public_dims = [(d[1], d[0]) for d in self._stored_dims]
+            warnings.warn(
+                '%s uses the legacy format (level_dimensions stored as '
+                '[height, width] and non-square images may miss tiles). '
+                'Re-write the slide with save_from_numpy() to upgrade.'
+                % self._filename, RuntimeWarning, stacklevel=2)
+        else:
+            self._public_dims = list(self._stored_dims)
+
+        raw_ds = meta.get('level_downsamples') or [1.0] * len(self._stored_dims)
+        self._downsamples = []
+        for v in raw_ds:
+            # legacy: [[dx, dy], ...]; new: [ds, ...]
+            self._downsamples.append(float(v[0] if isinstance(v, (list, tuple)) else v))
+        self._downsamples = (self._downsamples + [1.0] * len(self._stored_dims))[:len(self._stored_dims)]
+        for i, d in enumerate(self._downsamples):
+            if d <= 0 or not math.isfinite(d):
+                self._downsamples[i] = 1.0
+
+        self._osr.setdefault('patch_size', DEFAULT_PATCH_SIZE)
+        self._osr.setdefault('ext', '.jpg')
+        self._osr.setdefault('params', _default_params(self._osr['ext']))
+        self._osr.setdefault('mpp', None)
+        self._osr.setdefault('level_count', len(self._stored_dims))
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self._filename!r}, mode={self._mode!r})'
+
+    @property
+    def level_count(self):
+        return len(self._stored_dims)
+
+    @property
+    def level_dimensions(self):
+        return [list(d) for d in self._public_dims]
+
+    @property
+    def dimensions(self):
+        return self._public_dims[0]
+
+    @property
+    def level_downsamples(self):
+        return list(self._downsamples)
+
+    @property
+    def properties(self):
+        out = dict(self._osr)
+        out['level_dimensions'] = self.level_dimensions
+        out['dimension'] = list(self.dimensions)
+        out['level_downsamples'] = self.level_downsamples
+        return out
+
+    @property
+    def patch_size(self):
+        return int(self._osr.get('patch_size', DEFAULT_PATCH_SIZE))
+
+    # ------------------------------------------------------------------ #
+    # process / thread safe environment management
+    # ------------------------------------------------------------------ #
+    def _ensure_open(self, level):
+        """Return an LMDB Environment owned by the *current* process.
+
+        Only the requested level is opened, on first use.  A forked child
+        discards inherited handles and opens its own; this is the single most
+        important fix for DataLoader crashes.
+        """
+        if self._mode != 'r':
+            raise FmgError('slide is open for writing, not reading')
+        if self._closed:
+            raise FmgError('slide is closed')
+        pid = os.getpid()
+        is_forked_child = (self._creator_pid is not None
+                           and self._creator_pid != pid)
+        with self._lock:
+            if is_forked_child and self._auto_worker_tuning:
+                # Detected even when the parent never opened an env (lazy
+                # case): OpenCV's inherited thread pool is still unsafe.
+                _tune_cv2_for_worker()
+            if self._envs is None or self._pid != pid:
+                if self._envs is not None:
+                    # NEVER close an inherited env: mdb_env_close() in the
+                    # child may clear the parent's reader slot / shared lock
+                    # file.  Dropping the reference alone is safe because we
+                    # open with lock=False (no reader table is used at all).
+                    self._cache.clear()
+                self._envs = {}
+                self._pid = pid
+            env = self._envs.get(level)
+            if env is not None:
+                return env
+            path = os.path.join(self._data_dir, 'level' + str(level))
+            env = _acquire_read_env(path, self._map_size)
+            self._envs[level] = env
+            return env
+
+    def close(self):
+        """Idempotent.  Only closes handles owned by the current process."""
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            envs, owner = self._envs, self._pid
+            self._envs = None
+            self._cache.clear()
+        if not envs or owner != os.getpid():
+            return
+        for env in envs.values():
+            _release_read_env(env)
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------ #
+    # pickling: a forked/pickled slide must not carry an LMDB Environment.
+    # The clone reopens on first read; in the SAME process that read hits the
+    # shared registry, in a new process (spawn) it opens its own env.
+    # ------------------------------------------------------------------ #
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state['_envs'] = None
+        state['_pid'] = None
+        state['_creator_pid'] = None   # unpickled object is native to its process
+        state['_lock'] = None
+        state['_cache'] = OrderedDict()
+        state['_closed'] = False
+        state['_missing_warned'] = False
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._lock = threading.RLock()
+        self._cache = OrderedDict()
+        self._envs = None
+        self._pid = None
+        self._creator_pid = os.getpid()
+        self._closed = False
+        self._missing_warned = False
+
+    # ------------------------------------------------------------------ #
+    # tile cache
+    # ------------------------------------------------------------------ #
+    def _cache_get(self, key):
+        if not self._patch_cache_size:
+            return None
+        with self._lock:
+            tile = self._cache.get(key)
+            if tile is not None:
+                self._cache.move_to_end(key)
+            return tile
+
+    def _cache_put(self, key, tile):
+        if not self._patch_cache_size:
+            return
+        with self._lock:
+            self._cache[key] = tile
+            self._cache.move_to_end(key)
+            while len(self._cache) > self._patch_cache_size:
+                self._cache.popitem(last=False)
+
+    def _broken(self, level, box, reason):
+        msg = 'level %d tile %s: %s' % (level, tuple(box), reason)
+        if self._strict:
+            raise CorruptTileError(msg)
+        if not self._missing_warned:
+            warnings.warn(msg + ' (painted black)', RuntimeWarning, stacklevel=3)
+            self._missing_warned = True
+
+    # ------------------------------------------------------------------ #
+    # reading
+    # ------------------------------------------------------------------ #
+    def _read_tile(self, level, box, txn):
+        cache_key = b'%d/' % level + _tile_key(box)
+        tile = self._cache_get(cache_key)
+        if tile is not None:
+            return tile
+
+        raw = txn.get(key=_tile_key(box))
+        if raw is None or len(raw) == 0:
+            self._broken(level, box, 'missing or empty tile')
+            return None
+        try:
+            arr = np.frombuffer(raw, dtype=np.uint8)
+            tile = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+        except Exception as exc:  # pragma: no cover - defensive
+            self._broken(level, box, 'decode failed: %r' % (exc,))
+            return None
+        if tile is None or tile.ndim != 3 or tile.shape[2] != 3:
+            self._broken(level, box, 'invalid decoded tile')
+            return None
+        self._cache_put(cache_key, tile)
+        return tile
+
+    def read_region(self, location, level, size):
+        """Return a PIL.Image of ``size`` (width, height) in level coordinates.
+
+        ``location`` is given in the level-0 frame, as in OpenSlide.  Regions
+        outside the slide are padded with black instead of raising.
+        """
+        if self._mode != 'r':
+            raise FmgError('slide is open for writing, not reading')
+        if not 0 <= level < self.level_count:
+            raise ValueError('level %d out of range [0, %d)' % (level, self.level_count))
+        width, height = int(size[0]), int(size[1])
+        if width <= 0 or height <= 0:
+            raise ValueError('size must be positive, got %r' % (size,))
+        x0, y0 = int(location[0]), int(location[1])
+
+        env = self._ensure_open(level)
+
+        ds = self._downsamples[level]
+        lx0 = int(round(x0 / ds))
+        ly0 = int(round(y0 / ds))
+        lx1, ly1 = lx0 + width, ly0 + height
+
+        step = self.patch_size
+        grid_x, grid_y = self._stored_dims[level]
+        out = np.zeros((height, width, 3), dtype=np.uint8)
+
+        x_first = math.floor(lx0 / step) * step
+        y_first = math.floor(ly0 / step) * step
+        x_last = min(grid_x, math.ceil(lx1 / step) * step)
+        y_last = min(grid_y, math.ceil(ly1 / step) * step)
+
+        with env.begin(buffers=True) as txn:
+            for ty in range(y_first, y_last, step):
+                if ty < 0:
+                    continue
+                ty_max = min(ty + step, grid_y)
+                iy0, iy1 = max(ty, ly0), min(ty_max, ly1)
+                if iy0 >= iy1:
+                    continue
+                for tx in range(x_first, x_last, step):
+                    if tx < 0:
+                        continue
+                    tx_max = min(tx + step, grid_x)
+                    ix0, ix1 = max(tx, lx0), min(tx_max, lx1)
+                    if ix0 >= ix1:
+                        continue
+                    box = (tx, ty, tx_max, ty_max)
+                    tile = self._read_tile(level, box, txn)
+                    if tile is None:
+                        continue
+                    src = tile[iy0 - ty:iy1 - ty, ix0 - tx:ix1 - tx]
+                    dst = out[iy0 - ly0:iy1 - ly0, ix0 - lx0:ix1 - lx0]
+                    if src.shape != dst.shape:
+                        # Damaged / mismatched legacy tile; do not crash a
+                        # whole training job over one bad patch.
+                        self._broken(level, box, 'tile shape %s != %s'
+                                     % (src.shape, dst.shape))
+                        continue
+                    dst[:] = src
+        return Image.fromarray(out)
+
+    # ------------------------------------------------------------------ #
+    # writing
+    # ------------------------------------------------------------------ #
+    @staticmethod
+    def _as_uint8_hwc(data):
+        arr = np.asarray(data)
+        if arr.ndim == 2:
+            arr = arr[:, :, None]
+        if arr.ndim != 3:
+            raise ValueError('data must be HWC or HW, got shape %s' % (arr.shape,))
+        if arr.shape[2] == 1:
+            arr = np.repeat(arr, 3, axis=2)
+        elif arr.shape[2] == 4:
+            arr = arr[:, :, :3]
+        elif arr.shape[2] != 3:
+            raise ValueError('data must have 1, 3 or 4 channels, got %d' % arr.shape[2])
+        if arr.dtype != np.uint8:
+            arr = np.clip(arr, 0, 255).astype(np.uint8)
+        return arr
+
+    @staticmethod
+    def _put_tiles(txn, patches, locations, ext, params):
+        for patch, box in zip(patches, locations):
+            arr = np.ascontiguousarray(FastMemoryGraphics._as_uint8_hwc(patch))
+            ok, buff = cv2.imencode(ext, arr, params)
+            if not ok or buff is None or buff.size == 0:
+                raise FmgError('cv2.imencode failed for tile %s' % (tuple(box),))
+            # memoryview avoids the extra bytes() copy of the original code.
+            txn.put(key=_tile_key(box), value=memoryview(buff))
+
+    @staticmethod
+    def _estimate_map_size(dims):
+        raw = sum(w * h for w, h in dims) * 3       # 3 channels, uint8
+        return max(MIN_WRITE_MAP_SIZE,
+                   min(MAX_WRITE_MAP_SIZE, int(raw * 3 + (1 << 20) * len(dims))))
+
+    def _write_env(self, level, dims, map_size):
+        path = os.path.join(self._data_dir, 'level' + str(level))
+        env = lmdb.open(path, subdir=True, create=True,
+                        map_size=map_size, max_spare_txns=1)
+        txn = env.begin(write=True)
+        txn.put(b'patch_size', str(self._osr['patch_size']).encode())
+        txn.put(b'mpp', str(self._osr['mpp']).encode())
+        txn.put(b'dimension', str(list(dims)).encode())
+        txn.commit()
+        return env
+
+    def save_from_numpy(self, data, ext='.jpg', params=None, pyramid=False,
+                        mpp=None, patch_size=DEFAULT_PATCH_SIZE,
+                        commit_every=DEFAULT_COMMIT_EVERY, map_size=None):
+        """Write a whole slide.
+
+        ``level_dimensions`` is now stored as (width, height) and the tile
+        grid iterates x over width and y over height -- the original code
+        mixed the two up, which silently corrupted every non-square image.
+        """
+        if self._mode != 'w':
+            raise FmgError('slide is open for reading, not writing')
+        ext = ext.lower()
+        if ext not in SUPPORTED_EXT:
+            raise ValueError('unsupported ext %r, choose from %s' % (ext, sorted(SUPPORTED_EXT)))
+        params = [int(p) for p in params] if params is not None else _default_params(ext)
+        patch_size = int(patch_size)
+        if patch_size <= 0:
+            raise ValueError('patch_size must be positive')
+
+        level0 = self._as_uint8_hwc(data)
+        h, w, _ = level0.shape
+
+        dims = [(w, h)]
+        downsamples = [1.0]
+        nw, nh = w, h
+        # Only the *sizes* are planned here; each level image is generated
+        # once, directly from level 0, inside the write loop below.  The old
+        # code kept a list of full copies of every level in RAM.
+        while pyramid and max(nw, nh) > 512 and len(dims) < 12:
+            nw, nh = max(1, nw // 2), max(1, nh // 2)
+            dims.append((nw, nh))
+            downsamples.append(downsamples[-1] * 2.0)
+
+        map_size = int(map_size) if map_size else (
+            self._map_size or self._estimate_map_size(dims))
+        map_size = max(MIN_WRITE_MAP_SIZE, map_size)
+
+        properties = {
+            'format_version': FORMAT_VERSION,
+            'map_size': map_size,
+            'grid_axes': 'xy',           # level_dimensions == tile grid (x, y)
+            'level_count': len(dims),
+            'level_dimensions': [list(d) for d in dims],
+            'dimension': list(dims[0]),
+            'level_downsamples': downsamples,
+            'mpp': float(mpp) if mpp is not None else None,
+            'ext': ext,
+            'params': params,
+            'patch_size': patch_size,
+            'channels': 3,
+            'tile_codec': 'opencv',
+        }
+        self._osr = properties
+        self._stored_dims = [tuple(d) for d in dims]
+        self._public_dims = [tuple(d) for d in dims]
+        self._downsamples = list(downsamples)
+        self._legacy = False
+
+        if os.path.exists(self._data_dir):
+            shutil.rmtree(self._data_dir)
+        os.makedirs(self._data_dir)
+
+        for level, (gw, gh) in enumerate(dims):
+            layer = (level0 if level == 0 else
+                     cv2.resize(level0, (gw, gh), interpolation=cv2.INTER_AREA))
+            env = self._write_env(level, (gw, gh), map_size)
+            try:
+                txn = env.begin(write=True)
+                written = 0
+                for x in range(0, gw, patch_size):
+                    for y in range(0, gh, patch_size):
+                        x_max, y_max = min(x + patch_size, gw), min(y + patch_size, gh)
+                        arr = np.ascontiguousarray(layer[y:y_max, x:x_max, :])
+                        ok, buff = cv2.imencode(ext, arr, params)
+                        if not ok or buff is None or buff.size == 0:
+                            raise FmgError('cv2.imencode failed for tile (%d,%d,%d,%d)'
+                                           % (x, y, x_max, y_max))
+                        txn.put(key=_tile_key((x, y, x_max, y_max)), value=memoryview(buff))
+                        written += 1
+                        if written % commit_every == 0:
+                            txn.commit()
+                            txn = env.begin(write=True)
+                txn.commit()
+                env.sync()
+            finally:
+                env.close()
+
+        # Atomic metadata write: never leave a .fmg pointing at half-written data.
+        tmp = self._filename + '.tmp'
+        with open(tmp, 'w', encoding='utf-8') as fh:
+            json.dump(properties, fh, separators=(',', ':'))
+        os.replace(tmp, self._filename)
+        return properties
+
+    def save_from_tiles(self, patches, locations, level, ext, params=None, txn=None):
+        """Append tiles to ``level``.
+
+        Existing callers work unchanged.  A write transaction may be supplied
+        (``txn=``) so a caller can batch thousands of tiles into one commit.
+        """
+        if self._mode != 'w':
+            raise FmgError('slide is open for reading, not writing')
+        if not 0 <= level < self.level_count:
+            raise ValueError('level %d out of range' % level)
+        ext = ext.lower()
+        if ext not in SUPPORTED_EXT:
+            raise ValueError('unsupported ext %r' % ext)
+        params = [int(p) for p in params] if params is not None else _default_params(ext)
+        if txn is not None:
+            self._put_tiles(txn, patches, locations, ext, params)
+            return
+        path = os.path.join(self._data_dir, 'level' + str(level))
+        map_size = self._map_size or self._estimate_map_size(self._stored_dims)
+        env = lmdb.open(path, subdir=True, create=True,
+                        map_size=map_size, max_spare_txns=1)
+        try:
+            with env.begin(write=True) as t:
+                self._put_tiles(t, patches, locations, ext, params)
+            env.sync()
+        finally:
+            env.close()

fmg-0.4.0.dist-info/METADATA

@@ -0,0 +1,340 @@
+Metadata-Version: 2.4
+Name: fmg
+Version: 0.4.0
+Summary: Fast Memory Graphics for big image, use like OpenSlide
+Home-page: https://github.com/khtao/fmg
+Author: khtao
+Author-email: khtao@live.cn
+Maintainer: khtao
+Maintainer-email: khtao@live.cn
+License: MIT
+Project-URL: Source, https://github.com/khtao/fmg
+Project-URL: Issues, https://github.com/khtao/fmg/issues
+Project-URL: Optimization notes, https://github.com/khtao/fmg/blob/main/OPTIMIZATION.md
+Project-URL: Release guide, https://github.com/khtao/fmg/blob/main/RELEASE.md
+Keywords: whole slide image,WSI,digital pathology,LMDB,OpenSlide,tiled image,microscopy,remote sensing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+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: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lmdb>=1.0
+Requires-Dist: opencv-python>=4.0
+Requires-Dist: numpy>=1.17
+Requires-Dist: pillow>=7.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# fmg
+
+[![PyPI version](https://img.shields.io/pypi/v/fmg.svg)](https://pypi.org/project/fmg/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fmg.svg)](https://pypi.org/project/fmg/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> 把超大图像切成 tile 存进 LMDB，用 OpenSlide 的方式读，然后——在 `num_workers=8` 的 DataLoader 里，忘掉它的存在。
+
+**fmg 0.4.0** · Python ≥ 3.7 · MIT · LMDB / OpenCV / NumPy / Pillow
+
+面向数字病理全切片（WSI）、遥感大图、高分辨率扫描件这类「一张图几十 GB」的场景。它不把整图塞进内存，而是按 tile 随机读取，并提供一个你和 OpenSlide 一样熟悉的接口。
+
+---
+
+## 你有没有被这几个报错折磨过
+
+```
+DataLoader worker (pid 12345) exited unexpectedly
+lmdb.BadRslotError: MDB_BAD_RSLOT
+lmdb.Error: The environment '.../level0' is already open in this process
+```
+
+然后是更隐蔽的那种：**不报错，但非正方形图像写出来就是错的**——宽方向多出空 patch、高方向少了 tile，训练安静地喂进一堆黑块。
+
+这些不是你的代码写错了。0.3.0 在父进程就打开 LMDB 并长期持有一个事务，`fork` 出来的 worker 共享同一个 env、同一段 mmap 和同一个 reader slot；再加一个 `[h, w]` 当成 `[w, h]` 的笔误，问题就齐了。
+
+**0.4.0 把这一整类问题从库里拿掉了。** 你要做的只是把 `open_slide()` 放回 `Dataset.__init__`。
+
+---
+
+## 为什么值得换过来
+
+### 🛡 多 worker 是安全的，不再靠运气
+
+| 做法 | 效果 |
+|---|---|
+| 懒打开 | `open_slide()` 只读 JSON 元数据，不碰 LMDB；第一次 `read_region()` 才建环境 |
+| 进程感知重开 | 检测到 pid 变化就丢弃继承来的句柄（**不调用 `close()`**，以免清掉父进程的 reader slot），在子进程重新 `lmdb.open()` |
+| 短事务 | 每次读取一个独立只读事务，`max_spare_txns=8` 让创建近乎零成本，天然线程安全 |
+| `lock=False` | MDB_NOLOCK 完全绕开 reader lock table，多进程只读没有 slot 竞争 |
+| OpenCV fork 处理 | 子进程自动 `setNumThreads(0)` + 关闭 OpenCL，线程池不再在 `imdecode` 里挂住 |
+| 可 pickle | 剔除 env 与锁，`fork` / `spawn` 两种启动方式都能用 |
+
+### 🤝 同一张片子开几次，只占一份映射
+
+进程内按 `(路径, map_size)` 共享**一个**只读 Environment，引用计数管理生命周期：`close()` 只减引用，最后一个使用者离开才真正关闭。于是这些场景全部不再冲突——
+
+- `pickle` 往返产生的克隆对象
+- train / val 两个 Dataset 指向同一张 slide
+- 多个 Dataset 实例、多个 loader
+- `spawn` 反序列化出的 slide
+
+`os.register_at_fork` 会在子进程清空注册表并重建锁，避免 fork 时恰好有人持锁导致死锁。
+
+### ⚡ 读得更快，而且省内存
+
+零拷贝（`buffers=True` + `memoryview`）、直接分配目标画布 + 只拷贝相交 tile 的源/目标交集（不再先铺整个包围盒）、按 level 懒开环境、`map_size=0` 从文件 meta 页自动读真实尺寸、`readahead=False` 避免随机读时的无用预读。
+
+写侧则是**流式金字塔**：每层由 level-0 一次 `cv2.INTER_AREA` 降采样得到、用完即弃，不再同时持有所有层的完整 numpy 副本（老写法峰值约 1.33× 原图，WSI 上就是几十 GB）；配合每 2048 个 tile 批量提交、`memoryview` 代替 `tobytes()`。
+
+### ✅ 正确性与健壮性
+
+- **宽高顺序彻底修正**：新格式统一 `(width, height)`，网格 x 遍历宽、y 遍历高；`h, w, _ = data.shape`；`level_downsamples` 存标量。
+- **OpenSlide 语义**：`location` 是 level-0 坐标，`size` 是 level 坐标尺寸，内部按 downsample 缩放；越界区域补黑而不是切片错乱。
+- **坏 tile 不拖垮训练**：缺 tile / 解码失败 / 形状不符默认涂黑并只警告一次；`strict=True` 改为抛 `CorruptTileError`。
+- **不会留下半个文件**：元数据先写 `.tmp` 再 `os.replace()` 原子替换；`imencode` / `imdecode` 返回值全部检查。
+- **向后兼容**：0.3.0 写出的旧 `.fmg` 直接可读，自动把对外视图翻回 `(w, h)`、把 downsample 取成标量并给一次警告；新版写入 `format_version=2`。
+- `close()` 幂等、`__del__` 补齐、`with slide:` 正常可用；`mpp=None` 不再 `TypeError`；`os.path.splitext()` 代替硬切 `[:-4]`。
+
+---
+
+## 性能
+
+1024×1024 图像、`patch_size=256`，随机读 200 个 512×512 区域：
+
+| 项目 | 0.3.0 | 0.4.0 |
+|---|---|---|
+| 写入一张图 | 2.11 s | 1.94 s |
+| 随机读 200 个区域 | 1.54 s | **0.48 s**（约 3.2×，关缓存） |
+| 同上，`patch_cache=256` | — | 0.04 s |
+
+复测（py-lmdb 3.0.0）读侧为 2.10 s → 0.64 s / 0.06 s，约 3.3×，与上表一致。
+
+> **口径提醒**：带缓存那一行是「同一批 tile 被反复读」的理想场景，多 epoch 训练接近这个收益；单 epoch 顺序遍历全图时命中率会低很多，别按这个数字估吞吐。写侧瓶颈在 `cv2.imencode`，小图提升有限，大图上批量提交与流式金字塔的收益才明显。数字受硬件与文件系统影响，请以自己数据上的 `selftest.py` / `_bench.py` 为准。
+
+另外，用原版跑 fork 对照时**有时 4 个 worker 会全部正常退出**——这恰恰说明它是低概率崩溃，取决于时序。别因为「我这儿没崩」就认为旧写法安全。
+
+---
+
+## 快速开始
+
+### 安装
+
+```bash
+pip install fmg==0.4.0
+```
+
+从源码安装（或想跑自测 / 基准）：
+
+```bash
+git clone https://github.com/khtao/fmg.git && cd fmg
+pip install .
+python selftest.py
+```
+
+依赖会自动装上：`lmdb>=1.0`、`opencv-python>=4.0`、`numpy>=1.17`、`pillow>=7.0`。无 GUI 的服务器若装不上 `opencv-python`（缺 `libGL`），可在自己的环境里改用 `opencv-python-headless`。
+
+想给项目做一次发布？作者操作手册见 [`RELEASE.md`](https://github.com/khtao/fmg/blob/main/RELEASE.md)。
+
+### 写入一张图
+
+```python
+import numpy as np
+import fmg
+
+img = np.imread('huge.png')            # HWC，uint8 / 其它 dtype 均可
+
+meta = fmg.create_slide('slide.fmg').save_from_numpy(
+    img,
+    ext='.png',          # jpg / jpeg / png / webp / bmp / tiff / tif
+    pyramid=True,        # 用 INTER_AREA 生成金字塔，不再是隔点采样的锯齿
+    mpp=0.25,            # 可省略（None 也合法）
+    patch_size=256,
+)
+print(meta['level_dimensions'])        # [[w, h], [w/2, h/2], ...]
+```
+
+也可以只补写若干 tile：`save_from_tiles(patches, locations, level, ext, params=None, txn=None)`，外部传入 `txn=` 就能把成千上万个 tile 并进一次提交。
+
+### 读取
+
+```python
+import fmg
+
+slide = fmg.open_slide('slide.fmg', patch_cache=256)
+w, h = slide.dimensions                       # (宽, 高)
+print(slide.level_count, slide.level_dimensions, slide.level_downsamples)
+
+patch = slide.read_region((1000, 2000), 0, (512, 512))   # -> PIL.Image
+# location 是 level-0 坐标；size 是 level 坐标尺寸
+low   = slide.read_region((1000, 2000), 1, (256, 256))   # 自动按 downsample 缩放
+
+with slide:                                   # 或者 slide.close()
+    pass
+```
+
+### 接进 PyTorch DataLoader
+
+```python
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader, get_worker_info
+import fmg
+
+class SlideDataset(Dataset):
+    def __init__(self, path, size=512):
+        # 放心放在 __init__：这里只读元数据，不打开 LMDB
+        self.slide = fmg.open_slide(path, patch_cache=256)
+        self.w, self.h = self.slide.dimensions
+        self.size = size
+
+    def __len__(self):
+        return (self.w // self.size) * (self.h // self.size)
+
+    def __getitem__(self, i):
+        x = (i % (self.w // self.size)) * self.size
+        y = (i // (self.w // self.size)) * self.size
+        arr = np.asarray(self.slide.read_region((x, y), 0, (self.size, self.size)))
+        return torch.from_numpy(np.ascontiguousarray(arr.transpose(2, 0, 1)))
+
+def worker_init_fn(worker_id):
+    # fork 下库会自动处理；spawn 下必须显式调用这一句
+    fmg.configure(num_threads=0)
+    info = get_worker_info()
+    if info is not None:
+        seed = info.seed if info.seed is not None else torch.initial_seed()
+        np.random.seed(seed % (2 ** 32))
+        info.dataset.slide.read_region((0, 0), 0, (1, 1))   # 预热，错开首次开 env
+
+loader = DataLoader(
+    SlideDataset('slide.fmg'),
+    batch_size=128, shuffle=True,
+    num_workers=4,
+    persistent_workers=True,     # 每 epoch 不重开 env / 不清缓存
+    pin_memory=True,
+    prefetch_factor=2,
+    worker_init_fn=worker_init_fn,
+    multiprocessing_context='fork',   # 换成 'spawn' 也行，slide 可 pickle
+)
+for batch in loader:
+    ...
+```
+
+完整可运行版本见 [`test.py`](https://github.com/khtao/fmg/blob/main/test.py)。
+
+---
+
+## API 速查
+
+| 入口 | 说明 |
+|---|---|
+| `fmg.open_slide(path, **kw)` | 打开已有 `.fmg`（只读，懒打开） |
+| `fmg.create_slide(path, **kw)` | 创建写对象 |
+| `fmg.configure(num_threads=0, use_opencl=False)` | 在 `worker_init_fn` 里显式配置 OpenCV |
+| `slide.read_region(location, level, size)` | 返回 `PIL.Image`；越界补黑 |
+| `slide.dimensions` / `level_dimensions` | `(w, h)` / `[[w, h], ...]` |
+| `slide.level_count` / `level_downsamples` / `properties` / `patch_size` | 元数据 |
+| `save_from_numpy(...)` / `save_from_tiles(...)` | 整图写入 / 追加 tile |
+| `slide.close()` / `with slide:` | 幂等关闭，只释放本进程持有的引用 |
+| `fmg.FmgError` / `fmg.CorruptTileError` | 异常类型 |
+| `fmg.FORMAT_VERSION` | 当前为 `2` |
+
+**`open_slide` 参数**
+
+| 参数 | 默认 | 含义 |
+|---|---|---|
+| `patch_cache` | `128` | 进程内解码 tile 的 LRU 缓存大小，`0` 关闭 |
+| `map_size` | `None` | 显式 LMDB map size；默认从文件 meta 页读真实值（含旧版 1 TiB 文件） |
+| `strict` | `False` | 坏 tile 改为抛 `CorruptTileError` 而不是涂黑 |
+| `auto_worker_tuning` | `True` | fork 子进程自动关闭 OpenCV 线程池 / OpenCL |
+
+---
+
+## 磁盘格式
+
+```
+slide.fmg                 JSON 元数据（格式版本、各层尺寸、downsample、mpp、编码参数…）
+slide/
+├── level0/               LMDB，key = str((x, y, x_max, y_max))
+│   ├── data.mdb
+│   └── lock.mdb
+├── level1/
+└── ...
+```
+
+每个 tile 由 `cv2.imencode` 编码、读时 `cv2.imdecode` 还原，二者互逆，通道顺序保持一致。格式版本 2 与 1 的目录布局相同，因此**旧文件可以直接读**。
+
+---
+
+## 从 0.3.0 迁移
+
+1. 旧 `.fmg` 可以直接读，无需转换。但旧文件的 `level_dimensions` 是 `[h, w]`，且非正方形图像的 tile 本来就不完整——**建议用新版 `save_from_numpy` 重灌一次**以获得正确格式。
+2. `level_dimensions` / `dimensions` 现在严格返回 `(width, height)`；`level_downsamples` 返回标量列表。
+3. `level>0` 时 `location` 按 OpenSlide 语义解释为 level-0 坐标。若你的代码依赖旧行为（把 location 当 level 坐标），乘上 `level_downsamples[level]` 即可等价。
+4. `read_region` 的签名是 `read_region(location, level, size)`，不是五个位置参数。
+5. `map_size` 一般不用再指定：读侧自适应、写侧按数据量估算。
+6. `spawn` 启动时记得在 `worker_init_fn` 里调 `fmg.configure(num_threads=0)`；`fork` 下自动处理。
+7. 覆盖写一张正在被读的 `.fmg` 时，先 `close()` 所有读句柄——`save_from_numpy` 会删除并重建底层目录。
+
+完整的根因分析、修复清单与迁移细节见 [`OPTIMIZATION.md`](https://github.com/khtao/fmg/blob/main/OPTIMIZATION.md)。
+
+---
+
+## 常见问题
+
+**`patch_cache` 开多大？** 多 epoch 训练很值，单 epoch 顺序遍历全图命中率低。它是进程内的，不跨进程共享内存；显存紧张时给 `0` 也不会错。
+
+**为什么 `spawn` 还要手动 `configure`？** 新进程里库检测不到「pid 变了」这件事（对象是被反序列化出来的，不是继承来的），所以 OpenCV 线程池需要你显式关掉。`fork` 路径下这一步是自动的。
+
+**一个进程里开两个 slide 会冲突吗？** 不会，共享同一个 env。但别在还有读句柄时覆盖写同一个文件。
+
+**`strict` 什么时候用？** 数据入库校验阶段打开它，坏 tile 立刻暴露；训练阶段保持默认 `False`，一个坏 patch 不该中断整轮训练。
+
+**坏 tile 会静默吗？** 不会，第一次会发 `RuntimeWarning` 并打印 level 与 tile 坐标，之后只涂黑不刷屏。
+
+---
+
+## 验证
+
+```bash
+python selftest.py     # 35 项检查：非方形图一致性、越界补黑、level>0 语义、
+                       # pickle / spawn / fork 4 worker 并发、共享 env、
+                       # JPEG 路径、0.3.0 旧文件兼容
+python _bench.py       # 0.3.0 / 0.4.0 读写对照基准
+```
+
+`selftest.py` 里有一组专门复现原崩溃场景的用例：**父进程已打开 LMDB，fork 出 4 个 worker 各读 250 次，父进程同时读 200 次**，每个 worker 都在自己的 pid 下重新持有 Environment。
+
+---
+
+## 参考
+
+- LMDB Reader Lock Table / MDB_NOLOCK：<http://www.lmdb.tech/doc/group__readers.html>
+- py-lmdb 并发与线程模型：<https://deepwiki.com/jnwatson/py-lmdb/4.3-concurrency-and-threading>
+- `MDB_BAD_RSLOT` 多进程案例：<https://stackoverflow.com/questions/56905502/>
+- PyTorch DataLoader + LMDB 懒打开：<https://blog.csdn.net/evilfromshadow/article/details/119537968>
+
+原项目：<https://github.com/khtao/fmg> · 作者 khtao · MIT

fmg-0.4.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fmg/__init__.py,sha256=AHEY-02IM3EQ_bcI_ueBTtpKITz2bl44gntfpkXISuQ,757
+fmg/__version__.py,sha256=Hz9hqlnehve1l3B0uhkko4gq3haSC1MwFHMRBO6BJhE,63
+fmg/core.py,sha256=0CVB3rgu4Ok1CSdSlkalkNdzCK4bFlMNut93D7QF2xU,30100
+fmg-0.4.0.dist-info/licenses/LICENSE,sha256=jsr7I2LK-hm_tCDQCfjIsDol6l00fzz5yZaidMXCs0c,1062
+fmg-0.4.0.dist-info/METADATA,sha256=-AsxtQpQAFLSDvxXHKXm49dVmU9lMyeRw2-lTMSBi30,15643
+fmg-0.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fmg-0.4.0.dist-info/top_level.txt,sha256=XM6f5rNKsWRNU5f-fIRMEGbCrEPSMbXm9VjpuJ8F-yA,4
+fmg-0.4.0.dist-info/RECORD,,

fmg-0.4.0.dist-info/WHEEL

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

fmg-0.4.0.dist-info/licenses/LICENSE

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

fmg-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fmg