mlx-model-doctor
Validate an MLX / Hugging Face model repository before you load it.
A model repo can be broken in ways you only discover halfway through load(): a config.json that's missing or internally inconsistent, a missing tokenizer file, a model.safetensors.index.json that points at shards that aren't there, quantization metadata that uses a mode or group size MLX rejects, a chat template that's absent or whose stop token has a typo, a corrupt safetensors header, a quantized layer whose packed weight and scales shapes disagree, or a model that simply won't fit in the memory you have. mlx-model-doctor checks those up front and prints a report, so a bad repo fails fast with a clear reason instead of a confusing crash.
The checks read repository metadata and the safetensors header — config.json, the tokenizer files, the safetensors index, quantization fields, and the tensor map (dtypes, shapes, byte-offsets) parsed from the header alone. They need no GPU or MLX and never download the weights; on the Hub the header arrives over a small HTTP range request, so the checks stay cheap to run anywhere. For the default text profile, an optional --smoke check loads the model through mlx-lm (Apple Silicon), or through mlx-vlm with --plugin vlm, under a memory cap, to confirm it loads and generates.
--smoke loads and runs the model, so run it only on repositories you trust. Before it loads anything, the tool reads the model folder and refuses the load, with a plain message, if the repository names its own loader code or, on VLM --smoke, ships a chat template for one of six processor families. What counts depends on the loader:
- Text
--smoke(through mlx-lm) refuses amodel_fileinconfig.json, at any depth. It also refuses whenconfig.jsoncannot be read or the model path is not a directory. mlx-lm is always called with remote code off for the tokenizer, so anauto_mapdoes not block this path and does not run code. But if the tokenizer needs that code to load, the load fails with a message that names the file, instead of transformers' advice to turn remote code on. - VLM
--smoke(--plugin vlm, through mlx-vlm) refuses all of that, plusconfiguration_filesinconfig.json, anauto_mapinconfig.json,tokenizer_config.json,processor_config.json,preprocessor_config.jsonorvideo_preprocessor_config.json, and any of those files that exists but cannot be read. Some mlx-vlm processors turn remote code back on, which is why this path is stricter. VLM--smokerefuses any repository whose config files carry anauto_mapentry, and some well-known vision repositories do. There is no option to override this. The static checks still run on them. - VLM
--smokealso refuses a repository that ships a chat template of its own whenconfig.jsonmodel_type(compared in lower case, orspeculators_model_typewhenmodel_typeis empty) ismolmo,molmo2,ernie4_5_moe_vl,phi3_v(also writtenphi3-vorphi3v),kimi_vlorlocateanything. These mlx-vlm processors render templates without a sandbox, which can let a template run code. This route was read in the mlx-vlm and transformers source; it has not been shown to run code. The list comes from mlx-vlm 0.6.12 to 0.7.12 and a later release could change it. - The tool looks for that template in
tokenizer_config.json,chat_template.json,processor_config.json,preprocessor_config.json,special_tokens_map.json(a top-levelchat_templatekey),chat_template.jinjaand anadditional_chat_templates/folder that holds a.jinjafile. The check covers all of these files for every one of the six families. A template file that exists but cannot be read (for example a truncated download) also refuses the load, because the tool cannot tell whether the repository ships a template. - The message names the family and where the template was found, says the load was refused so the template was not rendered, and says the static checks still ran. A repository of these families with no template of its own still loads. Where mlx-vlm has a built-in template (molmo, molmo2) it is used; for the other four families such a repository can fail when the chat template is applied. Other families with templates load as before.
A refused smoke check is a failed check (exit 1 under the default policy). The static checks still run, and they read only metadata and the safetensors header, so they are the safe way to look at a repository you do not trust. parity mlx applies the mlx-lm rule to the base and fused models (see Check a fused adapter kept its behavior). This refusal is new in 0.10.1; see Status.
mlx-model-doctor check local ./my-model
mlx-model-doctor check hf mlx-community/Llama-3.2-3B-Instruct-4bit
See EXAMPLES.md for real, dated transcripts plus newer command examples.
Install
pip install mlx-model-doctor
# With the optional mlx-lm smoke check (Apple Silicon):
pip install "mlx-model-doctor[mlx-lm]"
Or with uv:
uv add mlx-model-doctor
uv add "mlx-model-doctor[mlx-lm]"
Verify the install:
mlx-model-doctor version
mlx-model-doctor --help
The [mlx-lm] extra asks for mlx-lm>=0.32.0,<0.33 and mlx>=0.32.4,<0.33, and the [mlx-vlm] extra asks for mlx-vlm>=0.6.12,<0.8 and mlx>=0.32.4,<0.33. Installing an extra upgrades mlx to 0.32.4 or later and, for [mlx-lm], mlx-lm to 0.32.0 or later. If another package in the same environment pins an older mlx or mlx-lm, the two cannot both be satisfied. mlx-train-perf 0.9.1 is one such package: it pins mlx==0.32.0 in its base install, and its own [mlx-lm] extra keeps mlx-lm below 0.32, so it cannot share an environment with either extra.
Requires Python ≥ 3.11. The static checks are pure Python and need only huggingface-hub; the optional --smoke runtime check needs Apple Silicon and mlx-lm (default text profile) or mlx-vlm (--plugin vlm).
What it checks
The built-in text plugin runs these against a model repository, broadly in this order:
text is the default plugin. For vision-language repositories, pass --plugin vlm
to run the explicit non-runtime VLM profile. The VLM plugin keeps the same metadata
and safetensors-header posture: no weights are downloaded and no model runtime is
loaded, unless you add --smoke.
- Required files —
config.jsonis present and readable. - Config consistency —
config.jsonparses, and itsmodel_typeis set. - Tokenizer — the tokenizer files a text model needs are present, and the special-token configuration is coherent.
- Chat template — a chat/instruct model declares a chat template (in
tokenizer_config.json,chat_template.json, or achat_template.jinja), and the end-of-turn token its template emits is a registered special token. A typo'd stop token loads fine and then never stops generating. - Safetensors index — when the weights are sharded,
model.safetensors.index.jsonis valid and every shard it references exists. - Tensor header — read the safetensors header itself (the tensor map: dtypes, shapes, byte-offsets; no weight download) to catch a corrupt header (overlapping or out-of-bounds tensor offsets), a weight map that points at tensors no shard contains, a declared tied embedding that contradicts the stored weights, and an MLX-quantized layer whose packed-weight and scales shapes don't agree. These run by default; pass
--skip-weightsto skip them for a faster config-only pass. - Quantization metadata — quantization fields are present and use a valid MLX mode with a valid group size and bit width (
affine,mxfp4,mxfp8,nvfp4). This reads the metadata, not the tensors. - Generation tokens — the
eos/pad/bostoken IDs are present and agree acrossconfig.json,generation_config.json, andtokenizer_config.json. - Memory budget — an estimate of the memory the model needs at your context length, compared against a budget you pass with
--max-memory.
Each check returns a result with a status (pass / warn / fail / skip), a message, and — when something is wrong — a remediation hint. The report aggregates them, and the process exit code reflects the worst result under your fail policy.
Python API
from mlx_model_doctor import check_local_model, check_hf_model
report = check_local_model("./my-model")
print(report.summary) # {"pass": 9, "warn": 1, "fail": 0, "skip": 2}
for result in report.results:
print(result.status, result.check_id, result.message)
# Hugging Face repos (hits the Hub):
report = check_hf_model("mlx-community/Llama-3.2-3B-Instruct-4bit")
DoctorReport renders to text, JSON, or Markdown (render_text / render_json / render_markdown), and the result objects are frozen dataclasses, so the output is stable to diff in CI.
Commands
| Command | What it does |
|---|---|
version |
Print the version plus the active Python, virtualenv, and dependency status. |
man |
Print usage examples and the exit-code table. |
plugins |
List registered check plugins (text, vlm). |
check local <path> |
Validate a model directory on disk. |
check hf <repo_id> |
Validate a model repository on the Hugging Face Hub (network). |
sample hf |
Survey likely-MLX repos for an author and validate a deterministic sample. |
parity mlx |
Check whether fusing a LoRA adapter into a base model kept the behavior the adapter learned. |
check accepts --format {text,json,markdown,github}, --output <file>, --max-memory <e.g. 32gb>, --context-length <n>, --fail-on {error,warn,never}, --skip-weights (skip the tensor-header checks for a faster config-only pass), and --smoke for the runtime load check (see above for what it refuses). With check hf, --smoke first downloads the repository snapshot, without downloading .py files, checks it, and loads from that local copy; the smoke result records the snapshot revision, and a failed snapshot download is a tool error (exit 2). Use --plugin vlm for vision-language repositories; omit it for the default text profile. The github format prints GitHub Actions annotations (see Use it in CI).
Exit codes: 0 checks passed (under the fail policy), 1 checks found failures, 2 tool error — a bad target, a missing dependency, or zero checks run.
The Hugging Face path
check hf and sample hf talk to the Hub through huggingface-hub. They read repository metadata (the file list, sizes, the small text files, and the safetensors header over a range request) rather than downloading the weights, but they do need network access, and an auth or rate-limit problem surfaces as a clear tool error rather than a stack trace. sample hf is a survey: it lists an author's repos, keeps the ones that look like MLX models, validates a deterministic sample of them, and reports each as its own batch item — a per-model failure is recorded and the run continues.
Checking a model in your Hugging Face cache
After hf download <repo>, the model sits in your cache under
~/.cache/huggingface/hub/models--ORG--NAME/snapshots/<commit>/. You can point
check local and parity mlx --base straight at that folder:
mlx-model-doctor check local ~/.cache/huggingface/hub/models--mlx-community--Qwen3.5-0.8B-4bit/snapshots/<commit>
The files in a snapshot are symlinks into the cache's own stored copies, and
this works for snapshots downloaded with huggingface_hub 1.x or 2.x. Older
versions link each file straight to a copy in the repository's own blobs/
folder. Versions 1.32 and later keep large files once per cache in a shared
store, and the repository's link leads on into it. The tool reads both layouts.
Pass the snapshot folder itself (.../snapshots/<commit>), not a subfolder of
it. The tool follows a symlink only when it leads to one of those stored copies.
A symlink that points anywhere else outside the folder is still refused. See
EXAMPLES.md for a real run.
Validate before uploading to Hugging Face
For a model you build or convert locally, run the static checks before upload and treat warnings as release blockers unless you have reviewed them:
mlx-model-doctor check local ./dist/my-mlx-model --fail-on warn
hf upload my-org/my-mlx-model ./dist/my-mlx-model --repo-type model
mlx-model-doctor check hf my-org/my-mlx-model --fail-on warn
If your publisher is Python-based, keep the same order:
from huggingface_hub import upload_folder
# Run `mlx-model-doctor check local ./dist/my-mlx-model --fail-on warn` first.
upload_folder(
repo_id="my-org/my-mlx-model",
folder_path="./dist/my-mlx-model",
repo_type="model",
)
Use --fail-on warn before upload when you want a clean producer release gate. Use the default --fail-on error when warnings are acceptable but hard failures should still block. After upload, check hf verifies that the Hub repository exposes the same files and metadata the local directory did.
Check a fused adapter kept its behavior
Fusing a LoRA adapter into a base model is supposed to bake the adapter's
learned behavior into the weights. It doesn't always. With mlx-lm's default
fuse the merged weights get re-quantized back to the base's format, and that
round-trip can erase a good part of what the adapter learned — so the fused
model quietly behaves more like the plain base than like the model you
fine-tuned. parity mlx catches that before you ship the fused model.
mlx-model-doctor parity mlx \
--base ./Qwen2.5-0.5B-Instruct-4bit \
--adapter ./my-lora \
--fused ./my-fused-model \
--prompts ./examples.json
It runs the same teacher-forced input through three models — the base alone,
the base with the adapter loaded, and the fused model — and compares their
top-token predictions. If the fused model tracks base+adapter the verdict is
pass; if it fell back to the base and lost the adapter, fail_tracks_base; if
it matches neither, fail_gross; and if the difference is within measurement
noise, inconclusive. A default 4-bit fuse that only kept half the adapter lands
at inconclusive — parity not confirmed — rather than a misleading pass.
The exit code is 0 for a confirmed pass, 1 for a determined regression, and
2 when the run can't decide (inconclusive or a setup problem).
--prompts takes a JSON list of {"prompt", "completion"} examples and builds
the comparison fixture from them, tokenized with the base model's own tokenizer
and scored over the completion tokens — so you measure parity on text that
matters for your model. Use examples the adapter should have changed. The check
needs the optional [mlx-lm] extra, a base repository that ships a
tokenizer.json, and loads each model in its own memory-capped subprocess (one
at a time), so it's safe on a laptop. If your fuse comes out inconclusive or
worse, re-fuse with --dequantize (a float fuse), which preserves the adapter.
Point --base, --adapter, and --fused at model directories: a locally
converted or fused model, a directory fetched with hf download <repo> --local-dir ./dir, or a snapshot in the Hugging Face cache (see
Checking a model in your Hugging Face cache).
parity mlx and check_adapter_parity load the base and fused models through mlx-lm, so they apply the same refusal as text --smoke to those two directories. The --prompts step loads the tokenizer through transformers with remote code turned off, and applies the same refusal before it does. If either one names a model_file in config.json at any depth, or config.json cannot be read, or the path is not a directory, nothing is loaded. Parity loads the tokenizer with remote code turned off, so an auto_map does not block it. But if the tokenizer needs that code to load, the load fails with a message that names the file, instead of transformers' advice to turn remote code on. The report names the repository (base or fused), the key and the file, and the run exits 2. A tokenizer mismatch or an uncovered target found in the same run still exits 1. The adapter directory is not checked this way, because mlx-lm reads only its config and weights. The parity mlx command never downloads. When the Python API check_adapter_parity downloads a repository from the Hub, it fetches only the files mlx-lm reads (JSON configs, safetensors weights, tokenizer files and chat templates) plus the adapter's config and weights.
parity mlx also accepts --format {text,json,markdown}; the json output
follows the published parity.v1 schema.
Use it in CI
Gate a pull request on a model repository with the GitHub Marketplace Action. It runs the static checks (no weights downloaded, no GPU), writes the report to the job summary, and fails the job under your fail policy:
- uses: IonDen/mlx-model-doctor@v0
with:
source: hf
target: mlx-community/Llama-3.2-3B-Instruct-4bit
plugin: text
fail-on: warn
For a vision-language model, opt into the VLM profile:
- uses: IonDen/mlx-model-doctor@v0
with:
source: hf
target: mlx-community/InternVL3-2B-4bit
plugin: vlm
Add version: "==0.10.1" to pin the tool to a release; without it the action installs the latest published version.
For a model directory you keep in git, validate it on every commit with the pre-commit hook:
repos:
- repo: https://github.com/IonDen/mlx-model-doctor
rev: v0.10.1
hooks:
- id: mlx-model-doctor
args: ["path/to/model"]
Output contract
--format json prints a stable, versioned payload. The top-level fields are:
| Field | Type | Description |
|---|---|---|
schema_version |
string | Schema major.minor version (e.g. "1.0"), independent of the package version. |
target |
string | The model path or repo ID that was checked. |
source |
"local" or "hf" |
Where the model came from. |
plugin |
string | The check plugin that ran (e.g. "text"). |
summary |
object | Check counts: pass, warn, fail, skip (integers). |
environment |
object | Reserved and currently always empty ({}); kept empty so JSON output stays stable to diff across environments. |
zero_check_reason |
string or null | When a run produced no checks (a zero-check run, which exits 2), a message naming the responsible plugin; null on a normal run. |
results |
array | One entry per check; see below. |
Each result in results[] has:
| Field | Type | Description |
|---|---|---|
check_id |
string | Namespaced identifier, e.g. "text/files.required". |
title |
string | Short human-readable check name. |
status |
string | "pass", "warn", "fail", or "skip". |
severity |
string | "info", "low", "medium", or "high". |
message |
string | What was found. |
remediation |
string or null | What to do if the check fired. |
details |
object | Open object with check-specific key/value pairs. |
duration_s |
number or null | Reserved; currently always null. Per-check timing is not emitted so JSON output stays stable to diff run-to-run. |
The machine-readable schema ships with the package at mlx_model_doctor/schema/report.v1.schema.json and is validated against real output in CI.
Exit codes: 0 checks passed under the fail policy, 1 failures found, 2 a tool error (a bad target, a missing dependency, or zero checks run). --format github reports the same results as GitHub Actions annotations; inside a workflow it also writes the Markdown report to the job summary and the pass / warn / fail / skip / exit-code / schema-version values to the step outputs.
Stability policy
Public API
The names you can depend on — only change on a major release:
check_local_model, check_hf_model, CheckOptions, DoctorReport, CheckResult, render_json, render_text, render_markdown, render_github, exit_code_for, FailOn, and the error types ModelDoctorError, TargetError, DependencyError, MemorySafetyError. exit_code_for raises ValueError on an unrecognized fail-on value.
Internal layer
The check, plugin, and target Protocols; CheckContext; the plugin registry; and the hub= parameter on check_hf_model (a test injection seam whose type may change) are internal and not stable across releases.
Schema versioning
schema_version is MAJOR.MINOR, versioned independently of the package. A minor bump adds new optional fields or new values to open fields (such as the memory check's estimate_source values). A major bump means a documented field was removed, renamed, or retyped, or a closed enum (status, severity, source) changed.
The top-level object, summary, and each entry in results[] are closed (additionalProperties: false), so a new field there is a coordinated schema edit plus a minor version bump. Validate against the schema that matches the payload's schema_version, not a pinned older copy — otherwise a newer payload's added field will fail your validator.
Promoted details keys
details is otherwise free-form, but three keys from the memory check are stable across the 1.x schema line: lower_bound_bytes, estimate_source, and memory_lower_bound_kind. lower_bound_bytes is a structural lower bound — it counts attention, MLP, and embedding parameters at ≤16-bit weights (or quantized-equivalent) plus KV cache, but excludes norms, biases, and an untied lm_head. It sits below real runtime use and is not a fit guarantee.
Batch output
The sample hf --format json survey has its own published schema, at mlx_model_doctor/schema/sample-batch.v1.schema.json and validated against real output in CI. It carries a schema_version of sample-batch/MAJOR.MINOR (same bump rules as above), and each checked item embeds a full single-check report that conforms to report.v1.schema.json.
Version sensitivity
The checks encode behavior from specific upstream versions (MLX, transformers, safetensors). When a value falls outside the known set — a quantization mode added in a newer MLX, an unfamiliar safetensors dtype — the check warns rather than failing. Only structurally invalid metadata (wrong type, missing required fields) produces a failure. Each version-bound table carries a comment naming the upstream version it was verified against.
Status
Beta (0.10.2). Version 0.10.2 moves the [mlx-lm] and [mlx-vlm] extras to MLX 0.32, mlx-lm 0.32 and mlx-vlm 0.6.12 to 0.7 (MLX 0.32.4 or later, mlx-lm 0.32.0 or later) and writes your home folder as ~ in the upstream error that a failed text --smoke load on a repository naming auto_map code keeps in the report details (other failed loads still show the loader's own message); it changes no API, CLI, check or output format. Version 0.10.1 makes --smoke and parity mlx refuse to load a repository that names its own loader code, or, on VLM --smoke, that ships a chat template for one of six processor families; if you used --smoke, or parity mlx on a base or fused model you do not control, with 0.10.0 or earlier, upgrade, and until then run them only on repositories you trust. Version 0.10.0 lets check local and parity mlx read a model straight from your Hugging Face cache, including snapshots downloaded with huggingface_hub 1.x or 2.x, and accepts 1-bit affine quantization as of MLX 0.32.4. Version 0.9.2 made a stale safetensors index a warning rather than a failure. Version 0.9.1 was a false-positive cleanup: a safetensors index kept in a subdirectory, a model with tie_word_embeddings absent and no separate output head (Gemma), a Pixtral/Mistral-3 [IMG] image token, and a chat template in chat_template.json no longer fail valid repositories. The static check local path and the report/CLI surface are solid and well tested. Version 0.9.0 added the adapter-parity verifier (parity mlx / check_adapter_parity), which checks whether fusing a LoRA adapter into a base model kept the adapter's behavior — see Check a fused adapter kept its behavior; it needs the optional [mlx-lm] extra and a base repository that ships a tokenizer.json. Version-bound check tables (MLX quantization modes, safetensors dtypes) now warn rather than fail on a recognized-but-unlisted value, so a repository built against a newer upstream release is flagged as unverified instead of rejected outright — see Version sensitivity. The optional runtime smoke check now covers vision-language repositories too: --smoke --plugin vlm loads a model through mlx-vlm and generates from a dummy image under the same advisory memory caps as the text path. Both smoke paths refuse repositories that name their own loader code, as described above. sample hf gained a configurable scan depth (--max-candidates), a listing-signal filter (--signal-filter), and a local listing cache (--no-cache / --cache-ttl) for surveying more of an author's catalog without repeating Hub calls. The safetensors header (read without downloading weights) backs four tensor-level checks — offset corruption, weight-map parameter sanity, tied-embedding consistency, and MLX quantized-layer shape consistency — which run by default (--skip-weights opts out). A single check reports whether a repository looks like an MLX model and why; the VLM profile adds image-processor and image-token wiring checks for vision-language repositories. The quantized-shape and quantization-mode checks read each layer's own bits/group_size/mode, so a mixed-precision model (4-bit experts with 8-bit dense and router layers) is validated per layer rather than reported as broken. The memory estimate handles mixed precision the same way: when a model mixes bit widths it takes the weight figure from the stored file sizes instead of the model-level setting. The Hugging Face path (check hf, sample hf) is implemented and tested offline against fakes; its live behavior is exercised by opt-in network tests. It also ships a GitHub Action and a pre-commit hook. The public API and JSON output now have a documented, versioned stability contract — see Output contract and Stability policy. Pin a version if you depend on the schema or the API.
License
Apache-2.0. See LICENSE and NOTICE. Validating a model repository does not touch the model's own weights or license; those belong to their respective authors.
Acknowledgements
- Apple ML Explore for MLX and
mlx-lm. - Hugging Face for the Hub client and
safetensors.
Sister projects
Other MLX libraries for Apple Silicon:
- mlx-taef — tiny autoencoders for fast diffusion-latent previews and low-memory decode (FLUX / SD).
- mlx-teacache — TeaCache residual caching to skip redundant FLUX denoising steps.
- mlx-quant-fidelity — measure how much quality a quantization costs (KL divergence, top-token flips, perplexity delta).
By Denis Ineshin · ineshin.space
Metadata
Release files for mlx-model-doctor 0.10.2
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| mlx_model_doctor-0.10.2.tar.gz | 349.4 kB | With provenance | Details for mlx_model_doctor-0.10.2.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| mlx_model_doctor-0.10.2-py3-none-any.whl | Python 3 | none | any | Details for mlx_model_doctor-0.10.2-py3-none-any.whl |
Total release size: 513.2 kB
Release files / mlx_model_doctor-0.10.2.tar.gz
| Download URL | mlx_model_doctor-0.10.2.tar.gz |
|---|---|
| Size | 349.4 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
6a3aa01f096c4305275195b7a6b777f3a564c401b6a115abd5c7289d3c7eb527
|
|
BLAKE2b-256 checksum How to use checksums |
ae6ec76af72f9847b31dcc301150f9e8cdc25e39d00f5b05b9dd16cda54f98b7
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logRelease files / mlx_model_doctor-0.10.2-py3-none-any.whl
| Download URL | mlx_model_doctor-0.10.2-py3-none-any.whl |
|---|---|
| Size | 163.8 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
e08366babcf7aa71e7322542a06ea8d94af30adac1a9d0142a26c4b366edb304
|
|
BLAKE2b-256 checksum How to use checksums |
59b71b5cfc7ab29417721fc08194b5c8cac6b7293164a5e8f28a8bcc335c93e7
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logSecurity for mlx-model-doctor 0.10.2
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for mlx_model_doctor-0.10.2.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.