flexray-mlx 0.2.1__py3-none-any.whl

flexray_mlx/mlx_model.py

@@ -0,0 +1,168 @@
+"""Native MLX execution of the pinned FleXray v1.0.2 U-Net checkpoint.
+
+The released network is fixed to seven encoder stages and six decoder stages.
+PyTorch is used by the source preprocessing and TTA code, never for this forward pass.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import yaml
+from medmlx_core import import_mlx
+
+from flexray_mlx._kernels import upsample_concat
+from flexray_mlx._types import FloatArray
+
+if TYPE_CHECKING:
+    from mlx.core import array
+
+    from flexray_mlx._types import NativeRuntime, NeuralRuntime, SafetensorsRuntime
+
+# Namespaces stay lazy until this native implementation is admitted.
+mx = cast("NativeRuntime", import_mlx())
+nn = cast("NeuralRuntime", import_module("mlx.nn"))
+safetensors = cast("SafetensorsRuntime", import_module("safetensors"))
+
+_FILTERS = (64, 128, 256, 512, 512, 720, 1024)
+
+
+class FleXrayMlxModel:
+    """Released residual U-Net run natively in MLX.
+
+    Activations are channels-last (NHWC) internally, as MLX convolutions expect.
+    Convolution weights are stored upstream in PyTorch OIHW order and are
+    transposed to OHWI when loaded. The public input and output stay NCHW.
+
+    Attributes:
+        weights: Every tensor in ``model.safetensors`` as float32, under its
+            original key.
+    """
+
+    def __init__(self, bundle: Path) -> None:
+        """Load one member bundle after checking it matches the released network.
+
+        Args:
+            bundle: Directory holding the released ``config.yml`` (its ``model``
+                section) and ``model.safetensors``.
+
+        Raises:
+            ValueError: The config describes any other architecture or activation.
+            OSError: ``config.yml`` or ``model.safetensors`` cannot be read.
+                Malformed files raise the YAML or safetensors library's own errors.
+        """
+        config = cast(
+            dict[str, dict[str, object]],
+            yaml.safe_load((bundle / "config.yml").read_text(encoding="utf-8")),
+        )["model"]
+        expected: dict[str, object] = {
+            "_class": "fxr.models.UNet",
+            "in_channels": 1,
+            "out_channels": 61,
+            "filters": list(_FILTERS),
+            "convs_per_block": 3,
+            "dropout": 0.0,
+            "norm": "instance",
+            "residual": True,
+            "norm_after_activation": True,
+            "skip_connections": True,
+            "upsample_align_corners": True,
+            "residual_projection": "auto",
+            "residual_shortcut_norm": True,
+        }
+        for key, value in expected.items():
+            if config.get(key) != value:
+                raise ValueError(f"Unsupported FleXray MLX architecture: {key}={config.get(key)!r}")
+        if str(config.get("activation", "LeakyReLU")).casefold() != "leakyrelu":
+            raise ValueError("Unsupported FleXray MLX activation")
+        if config.get("bottleneck_convs") not in (None, 3) or config.get("up_filters") is not None:
+            raise ValueError("Unsupported FleXray MLX bottleneck or decoder configuration")
+
+        self.weights: dict[str, array] = {}
+        with safetensors.safe_open(bundle / "model.safetensors", framework="np") as reader:
+            for key in reader.keys():  # noqa: SIM118 - safe_open is not iterable
+                value = np.asarray(reader.get_tensor(key), dtype=np.float32)
+                # 4D weights are convolution kernels: OIHW -> OHWI. Norm weights are 1D.
+                if key.endswith("weight") and value.ndim == 4:
+                    value = value.transpose(0, 2, 3, 1)
+                self.weights[key] = mx.array(value)
+        # MLX is lazy; evaluate now so loading is complete before the first forward pass.
+        mx.eval(*self.weights.values())
+        self._consumed: set[str] = set()
+        self._pool = nn.MaxPool2d(kernel_size=2, stride=2)
+
+    def _weight(self, key: str) -> array:
+        self._consumed.add(key)
+        return self.weights[key]
+
+    def _conv(self, x: array, prefix: str, *, padding: int) -> array:
+        weight = self._weight(f"{prefix}.weight")
+        bias = self._weight(f"{prefix}.bias")
+        return mx.conv2d(x, weight, padding=padding) + bias
+
+    def _norm(self, x: array, prefix: str) -> array:
+        gamma = self._weight(f"{prefix}.weight")
+        beta = self._weight(f"{prefix}.bias")
+        # Instance norm on NHWC: per sample and channel over H and W. eps=1e-5 is
+        # PyTorch's InstanceNorm2d default; the upstream parity test covers it.
+        mean = mx.mean(x, axis=(1, 2), keepdims=True)
+        variance = mx.mean(mx.square(x - mean), axis=(1, 2), keepdims=True)
+        return (x - mean) * mx.rsqrt(variance + 1e-5) * gamma + beta
+
+    def _block(self, x: array, prefix: str) -> array:
+        residual = x
+        out = x
+        for index in range(3):
+            # Checkpoint key layout per step: conv at layers.3i, activation at
+            # 3i+1 (no tensors), norm at 3i+2 (norm_after_activation).
+            layer = f"{prefix}.layers.{index * 3}"
+            out = self._conv(out, layer, padding=1)
+            # LeakyReLU with PyTorch's default negative slope of 0.01.
+            out = mx.maximum(out, out * 0.01)
+            out = self._norm(out, f"{prefix}.layers.{index * 3 + 2}")
+        # A 1x1 projection shortcut exists only where channel counts differ.
+        if f"{prefix}.shortcut.conv.weight" in self.weights:
+            residual = self._conv(residual, f"{prefix}.shortcut.conv", padding=0)
+            residual = self._norm(residual, f"{prefix}.shortcut.instancenorm")
+        return out + residual
+
+    def __call__(self, images: FloatArray) -> FloatArray:
+        """Run the U-Net on prepared images and return raw logits.
+
+        Args:
+            images: Float32 ``(B, 1, 256, 256)`` NCHW radiographs, already scaled
+                and normalized as the bundle's preprocessing specifies.
+
+        Returns:
+            A new float32 ``(B, 61, 256, 256)`` NCHW array of logits, one channel
+            per label in the bundle's label-schema order (channel 0 is background).
+            Apply a sigmoid for probabilities.
+
+        Raises:
+            ValueError: ``images`` has another shape, or the bundle holds tensors
+                this network does not use. A tensor the network needs but the
+                bundle lacks raises ``KeyError``.
+        """
+        if images.ndim != 4 or images.shape[1:] != (1, 256, 256):
+            raise ValueError(f"FleXray MLX expects Bx1x256x256, got {images.shape}")
+        x = mx.array(np.asarray(images, dtype=np.float32).transpose(0, 2, 3, 1))
+        skips: list[array] = []
+        for index in range(len(_FILTERS)):
+            x = self._block(x, f"down_blocks.{index}")
+            if index < len(_FILTERS) - 1:
+                skips.append(x)
+                x = self._pool(x)
+        for index, skip in enumerate(reversed(skips)):
+            # Preserve corner alignment and resized-before-skip channel order,
+            # while avoiding the separate bilinear samples and resize tensor.
+            x = self._block(upsample_concat(x, skip, mx=mx), f"up_blocks.{index}")
+        logits = self._conv(x, "output_conv", padding=0)
+        mx.eval(logits)
+        # Fail on extra or misnamed tensors instead of silently running a different net.
+        if self._consumed != self.weights.keys():
+            missing = sorted(self.weights.keys() - self._consumed)
+            raise ValueError(f"FleXray MLX did not consume every released tensor: {missing[:3]}")
+        return cast(FloatArray, np.asarray(logits)).transpose(0, 3, 1, 2).copy()

flexray_mlx/tta.py

@@ -0,0 +1,248 @@
+"""NumPy port of pinned fxr ``tta_v3`` (FleXray bf6d014, MIT).
+
+Each view is drawn once, normalized again, shared by all members, and unflipped
+on the logits. Accumulation is sequential in view/member order, in float32
+probability space. The plain view is already normalized and stays untouched.
+See root THIRD_PARTY_NOTICES.md for source notices.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import cast
+
+import numpy as np
+
+from flexray_mlx._random import TorchRandom
+from flexray_mlx._types import BoolArray, FloatArray, IntArray
+
+Forward = Callable[[FloatArray], FloatArray]
+
+
+@dataclass(frozen=True, slots=True)
+class TtaSettings:
+    """Validated pass count and isolated Torch CPU seed."""
+
+    samples: int = 1
+    seed: int | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            isinstance(self.samples, bool)
+            or not isinstance(cast(object, self.samples), int)
+            or self.samples < 0
+        ):
+            raise ValueError("tta_samples must be a non-negative integer")
+        if self.seed is not None and (
+            isinstance(self.seed, bool)
+            or not isinstance(cast(object, self.seed), int)
+            or not -(2**63) <= self.seed < 2**64
+        ):
+            raise ValueError("tta_seed must be an integer in [-2**63, 2**64 - 1], or None")
+
+    @property
+    def resolved_samples(self) -> int:
+        """Passes per member actually run; ``samples`` of 0 resolves to one plain pass."""
+        return max(self.samples, 1)
+
+
+def predict_with_tta(
+    forward_fn: Forward | Sequence[Forward],
+    images: FloatArray,
+    *,
+    tta_samples: int = 1,
+    seed: int | None = None,
+    normalizer: Forward | None = None,
+) -> tuple[FloatArray, FloatArray]:
+    """Return multilabel ``(logits, probabilities)``, following fxr's total-pass contract.
+
+    The first pass is the plain input; each further pass is an augmented view
+    shared by all members. Probabilities are the mean of every member's sigmoid
+    over every pass. For a single plain pass of one member the logits are that
+    member's raw output; otherwise they are the logit of the mean probability
+    clipped to [1e-6, 1 - 1e-6].
+
+    Args:
+        forward_fn: One callable, or a sequence of member callables, mapping
+            float32 ``(B, C, H, W)`` images to float32 ``(B, L, H, W)`` logits.
+        images: Prepared float32 ``(B, C, H, W)`` batch with 1 or 3 channels,
+            already normalized.
+        tta_samples: Total passes per member; 0 or 1 means one plain pass.
+        seed: Seed for the isolated Torch-CPU-compatible stream; None is unseeded.
+        normalizer: Applied to each augmented view (not the plain input) so views
+            are normalized as the plain input was.
+
+    Raises:
+        ValueError: Invalid ``tta_samples``/``seed``, no forward callable, or
+            ``images`` that is not float32 ``(B, C, H, W)`` with 1 or 3 channels.
+    """
+
+    # Deferred: flexray_mlx.medmlx imports this module at load time.
+    from flexray_mlx.medmlx import multilabel_probabilities
+
+    settings = TtaSettings(tta_samples, seed)
+    forwards = (forward_fn,) if callable(forward_fn) else tuple(forward_fn)
+    if not forwards:
+        raise ValueError("predict_with_tta requires at least one forward callable")
+    if images.ndim != 4 or images.shape[1] not in {1, 3} or images.dtype != np.float32:
+        raise ValueError("FleXray TTA expects float32 BxCxHxW images with 1 or 3 channels")
+    logits = forwards[0](images)
+    probability_sum = multilabel_probabilities(logits)
+    if settings.resolved_samples == 1 and len(forwards) == 1:
+        return logits, probability_sum
+    for forward in forwards[1:]:
+        probability_sum += multilabel_probabilities(forward(images))
+    random = TorchRandom(settings.seed)
+    for _ in range(settings.resolved_samples - 1):
+        augmented, flipped = augment_batch(images, random)
+        if normalizer is not None:
+            augmented = normalizer(augmented)
+        for forward in forwards:
+            view_logits = forward(augmented)
+            unflipped = np.where(flipped[:, None, None, None], view_logits[..., ::-1], view_logits)
+            probability_sum += multilabel_probabilities(unflipped)
+    probabilities = probability_sum / np.float32(settings.resolved_samples * len(forwards))
+    clamped = np.clip(probabilities, np.float32(1e-6), np.float32(1 - 1e-6))
+    return np.log(clamped) - np.log1p(-clamped), probabilities
+
+
+def augment_batch(images: FloatArray, random: TorchRandom) -> tuple[FloatArray, BoolArray]:
+    """Draw the fxr chain independently per sample, in batch order.
+
+    Returns the stacked ``(B, C, H, W)`` views and a ``(B,)`` boolean mask of
+    which samples were flipped along the width axis.
+    """
+
+    views, flips = zip(*(augment_sample(image, random) for image in images), strict=True)
+    return np.stack(views), np.asarray(flips, dtype=np.bool_)
+
+
+def augment_sample(image: FloatArray, random: TorchRandom) -> tuple[FloatArray, np.bool_]:
+    """Horizontal flip, invert, CLAHE/gamma, raw contrast, sharpness, then noise.
+
+    ``image`` is one prepared ``(C, H, W)`` float32 sample. Random draws are
+    consumed in fxr's order. The CLAHE, gamma, contrast and sharpness steps clip
+    to [0, 1]; invert and noise do not.
+    Returns the view and whether it was flipped (so logits can be unflipped).
+    """
+
+    flipped = random.chance(0.5)
+    if flipped:
+        image = image[..., ::-1]
+    if random.chance(0.5):
+        image = np.float32(1.0) - image
+    choice = random.uniform()
+    if choice < 0.1:
+        image = clahe(image, clip_limit=random.uniform(1.0, 2.0), grid_size=(8, 8))
+    elif choice < 0.35:
+        gamma, gain = random.uniform(0.9, 1.1), random.uniform(0.9, 1.1)
+        image = np.clip(np.float32(gain) * np.power(image, np.float32(gamma)), 0, 1)
+    if random.chance(0.25):
+        image = cast(FloatArray, np.clip(image * np.float32(random.uniform(0.7, 1.3)), 0, 1))
+    if random.chance(0.5):
+        image = adjust_sharpness(image, random.uniform(0.7, 1.3))
+    if random.chance(0.25):
+        image = cast(FloatArray, image + random.normal(image.shape) * np.float32(0.01))
+    return image, flipped
+
+
+def adjust_sharpness(image: FloatArray, factor: float) -> FloatArray:
+    """Sharpen ``(C, H, W)`` ``image`` as ``factor * image + (1 - factor) * blurred``.
+
+    The blur is torchvision's 3x3 ``[1,1,1; 1,5,1; 1,1,1] / 13`` kernel, and the
+    one-pixel border keeps the original values. The blend is clipped to [0, 1].
+    Images with a side of 2 pixels or fewer are returned unchanged.
+    """
+
+    if min(image.shape[-2:]) <= 2:
+        return image
+    # Deferred: flexray_mlx.medmlx imports this module at load time.
+    from flexray_mlx.medmlx import fma32
+
+    height, width = image.shape[-2:]
+    blurred = image.copy()
+    interior = np.zeros_like(image[:, 1:-1, 1:-1])
+    for y in range(3):
+        for x in range(3):
+            weight = np.float32(5.0 if (y, x) == (1, 1) else 1.0) / np.float32(13.0)
+            interior = fma32(image[:, y : y + height - 2, x : x + width - 2], weight, interior)
+    blurred[:, 1:-1, 1:-1] = interior
+    return cast(
+        FloatArray, np.clip(np.float32(factor) * image + np.float32(1.0 - factor) * blurred, 0, 1)
+    )
+
+
+def _interpolation_axis(
+    length: int, tile_size: int, tile_count: int
+) -> tuple[IntArray, IntArray, FloatArray]:
+    """Per pixel: nearest lower/upper tile index and the weight of the upper tile.
+
+    Tile centres sit at ``(k + 0.5) * tile_size``; indices clamp at the edges.
+    """
+
+    position = np.arange(length, dtype=np.float32) / np.float32(tile_size) - np.float32(0.5)
+    lower = np.floor(position).astype(np.int64)
+    return (
+        np.clip(lower, 0, tile_count - 1),
+        np.clip(lower + 1, 0, tile_count - 1),
+        (position - lower.astype(np.float32)),
+    )
+
+
+def clahe(image: FloatArray, *, clip_limit: float, grid_size: tuple[int, int]) -> FloatArray:
+    """Contrast-limited adaptive histogram equalization of a ``(C, H, W)`` image.
+
+    Follows fxr: values are clipped to [0, 1] and quantized to 256 bins per
+    channel, histograms are built per tile and clipped at
+    ``clip_limit * pixels / 256`` with the excess redistributed, and each pixel
+    interpolates bilinearly between the four nearest tile centres. ``grid_size``
+    is ``(rows, cols)`` of tiles, capped at the image size; tiles are rounded up
+    to even sizes and the image is padded to fit (reflect, or edge when the
+    padding reaches the image size in either direction). Returns float32 ``(C, H, W)`` in [0, 1].
+
+    Raises:
+        ValueError: ``image`` is not a non-empty 3D array, ``clip_limit`` is not
+            positive and finite, or ``grid_size`` is not two positive integers.
+    """
+
+    if image.ndim != 3 or min(image.shape) < 1:
+        raise ValueError(f"CLAHE expects a non-empty CxHxW image, got {image.shape}")
+    if not math.isfinite(clip_limit) or clip_limit <= 0:
+        raise ValueError("CLAHE clip_limit must be positive and finite")
+    if len(grid_size) != 2 or any(isinstance(n, bool) or n <= 0 for n in grid_size):
+        raise ValueError("CLAHE grid_size must contain two positive integers")
+    channels, height, width = image.shape
+    rows, cols = min(grid_size[0], height), min(grid_size[1], width)
+    th, tw = math.ceil(height / rows), math.ceil(width / cols)
+    th, tw = th + th % 2, tw + tw % 2
+    ph, pw = th * rows - height, tw * cols - width
+    work = np.clip(image, 0, 1).astype(np.float32)
+    if ph or pw:
+        mode = "reflect" if ph < height and pw < width else "edge"
+        work = np.pad(work, ((0, 0), (0, ph), (0, pw)), mode=mode)
+    tiles = work.reshape(channels, rows, th, cols, tw).transpose(1, 3, 0, 2, 4)
+    pixels = th * tw
+    bins = (tiles.reshape(-1, pixels) * np.float32(255)).astype(np.int64)
+    offsets = np.arange(len(bins), dtype=np.int64)[:, None] * 256
+    histograms = np.bincount((bins + offsets).ravel(), minlength=len(bins) * 256).reshape(-1, 256)
+    histograms = np.minimum(histograms, max(math.floor(clip_limit * pixels / 256), 1))
+    clipped = pixels - histograms.sum(axis=1)
+    residual = clipped % 256
+    histograms += ((clipped - residual) // 256)[:, None]
+    histograms += np.arange(256)[None] < residual[:, None]
+    lookup = np.floor(np.cumsum(histograms, axis=1).astype(np.float32) * np.float32(255 / pixels))
+    lookup = np.clip(lookup, 0, 255).reshape(rows, cols, channels, 256).transpose(2, 0, 1, 3)
+    pixel_bins = (work * np.float32(255)).astype(np.int64)
+    y0, y1, wy = _interpolation_axis(work.shape[1], th, rows)
+    x0, x1, wx = _interpolation_axis(work.shape[2], tw, cols)
+    channel = cast(IntArray, np.arange(channels))[:, None, None]
+    v00 = lookup[channel, y0[None, :, None], x0[None, None], pixel_bins]
+    v01 = lookup[channel, y0[None, :, None], x1[None, None], pixel_bins]
+    v10 = lookup[channel, y1[None, :, None], x0[None, None], pixel_bins]
+    v11 = lookup[channel, y1[None, :, None], x1[None, None], pixel_bins]
+    wy, wx = wy[None, :, None], wx[None, None]
+    top = v00 * (np.float32(1) - wx) + v01 * wx
+    bottom = v10 * (np.float32(1) - wx) + v11 * wx
+    return ((top * (np.float32(1) - wy) + bottom * wy) / np.float32(255))[:, :height, :width]

flexray_mlx-0.2.1.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.5
+Name: flexray-mlx
+Version: 0.2.1
+Summary: Native MLX implementation of FleXray
+Author: Joseph Sandoval, Alfredo Sandoval Jr.
+License-Expression: Apache-2.0 AND MIT AND BSD-3-Clause
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+Classifier: Operating System :: MacOS :: MacOS X
+Requires-Python: <3.15,>=3.13
+Requires-Dist: medmlx-core==0.2.3
+Requires-Dist: mlx<1,>=0.32.4
+Requires-Dist: numpy<3,>=2.0
+Requires-Dist: pillow<14,>=13
+Requires-Dist: pydicom<4,>=3
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: safetensors<1,>=0.6
+Provides-Extra: dev
+Requires-Dist: pyright==1.1.414; extra == 'dev'
+Requires-Dist: pytest<10,>=8.4; extra == 'dev'
+Requires-Dist: ruff<1,>=0.13; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# flexray-mlx
+
+Segment anatomical structures in radiographs with FleXray and native MLX.
+
+[Docs](docs/technical.md) · [MedMLX](https://github.com/MedMLX)
+
+![One chest radiograph → separate lung, heart and individual rib masks.](https://raw.githubusercontent.com/MedMLX/flexray-mlx/main/docs/showcase.png)
+
+*One chest radiograph → separate lung, heart and individual rib masks.*
+
+| Input | Output |
+| :--- | :--- |
+| Raster image or single-frame DICOM | Structure masks and probabilities |
+
+**Apple Silicon · Metal · Python 3.13 / 3.14** · [uv](https://docs.astral.sh/uv/)
+
+## Quick start
+
+```bash
+uv venv --python 3.13
+source .venv/bin/activate
+repo="https://github.com/MedMLX/flexray-mlx"
+uv pip install \
+  "flexray-mlx @ git+$repo" \
+  huggingface-hub
+```
+
+Download the released weights and run:
+
+```python
+from huggingface_hub import snapshot_download
+from flexray_mlx.medmlx import run
+
+weights = snapshot_download("VictorButoi/flexray", local_dir="flexray", ignore_patterns=["*.onnx"])
+
+result = run(image_path="chest.png", weights_path=weights, output_dir="out")
+print(result["outputs"]["mask"])
+```
+
+Use `label_name` to select a structure and `ensemble=True` to average all five members.
+
+## License
+
+[Apache-2.0](LICENSE). See [third-party notices](THIRD_PARTY_NOTICES.md). Model weights retain their publisher terms. FleXray weights are noncommercial (CC-BY-NC-4.0).
+
+For research and education. Outputs require human review.

flexray_mlx-0.2.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+flexray_mlx/__init__.py,sha256=zELHZB2HOgjvicl7pfqRAdO0x8OeeG0NHG8Wnk_H25c,563
+flexray_mlx/_kernels.py,sha256=R13EcWmb9pUolbJUICGJ6R0a3XjzKvdo7msoG6uwDxY,3604
+flexray_mlx/_random.py,sha256=zgeYBsuLy-eKRmrWHZmvcadr_EqaTHi0RiPPjeil5v8,3921
+flexray_mlx/_types.py,sha256=sdxMEDJJa8cP5xVqJ12_ESaO-8cGOT8fFxukxrxzCzA,3586
+flexray_mlx/medmlx.py,sha256=uEoDBbtRB2K_oMRgv2UJw8ZxBjc3Pf4881GApnW_Kmo,49894
+flexray_mlx/mlx_model.py,sha256=zjNuEdppSrctGLskKgaEmkjkhK_wcOM8koECVB8m85c,7678
+flexray_mlx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flexray_mlx/tta.py,sha256=yg8MDF9VvOJQ8p4rvslOWo2lAGlN9FV-9a849dRqFb8,11346
+flexray_mlx-0.2.1.dist-info/METADATA,sha256=dBt_JlT4b918Y7bpB1V0iqP9xaNZAoU3aGtWXiNnuHw,2201
+flexray_mlx-0.2.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+flexray_mlx-0.2.1.dist-info/entry_points.txt,sha256=fISmTVUJp2A8zG55t1nLC_bwQuztR_shgMVADfCLxwE,51
+flexray_mlx-0.2.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flexray_mlx-0.2.1.dist-info/licenses/THIRD_PARTY_NOTICES.md,sha256=HaCU3wNwRTSBx0jregZw0a1GAsi3b6-t_B59tEEABzU,7430
+flexray_mlx-0.2.1.dist-info/RECORD,,

flexray_mlx-0.2.1.dist-info/WHEEL

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

flexray_mlx-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[medmlx.models]
+flexray = flexray_mlx.medmlx:MODEL