esf-format 1.0.0__tar.gz

esf_format-1.0.0/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+
+updates:
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: monthly
+  groups:
+    all:
+      patterns: ["*"]
+
+- package-ecosystem: uv
+  directory: /
+  schedule:
+    interval: monthly
+  groups:
+    all:
+      patterns: ["*"]

esf_format-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  test:
+    uses: ./.github/workflows/test.yml
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v10.3.3
+
+      - name: Set the version from the release tag
+        run: uv version --frozen "${GITHUB_REF_NAME#v}"
+
+      - name: Build
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish

esf_format-1.0.0/.github/workflows/test.yml

@@ -0,0 +1,51 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_call:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.11", "3.12", "3.13", "3.14", "3.15"]
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v7
+
+      - name: Check out esf-format
+        uses: actions/checkout@v7
+        with:
+          repository: EVEShipFit/esf-format
+          ref: v1.0
+          path: esf-format
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v10.3.3
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Lint
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+          uv run mypy src
+
+      - name: Run the test cases
+        run: uv run --project esf-format/tools esf-test -- .venv/bin/coverage run tests/program.py
+
+      - name: Run the unit tests
+        run: uv run coverage run -m pytest
+
+      - name: Report coverage
+        run: |
+          uv run coverage combine
+          uv run coverage report
+          uv run coverage report --format=markdown >> "$GITHUB_STEP_SUMMARY"

esf_format-1.0.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+dist/
+esf-format/
+.coverage*

esf_format-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 EVEShipFit Team
+
+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.

esf_format-1.0.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.5
+Name: esf-format
+Version: 1.0.0
+Summary: Read and write esf/1, the plain-text format for EVE Online ship fits
+Project-URL: Homepage, https://github.com/EVEShipFit/esf-format-python
+Project-URL: Specification, https://github.com/EVEShipFit/esf-format
+Author: EVEShipFit Team
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Games/Entertainment
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# esf-format
+
+[![PyPI](https://img.shields.io/pypi/v/esf-format.svg)](https://pypi.org/project/esf-format/)
+[![Python](https://img.shields.io/pypi/pyversions/esf-format.svg)](https://pypi.org/project/esf-format/)
+[![CI](https://github.com/EVEShipFit/esf-format-python/actions/workflows/test.yml/badge.svg)](https://github.com/EVEShipFit/esf-format-python/actions/workflows/test.yml)
+
+[![Discord](https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white)](https://discord.gg/S5V5BkvNf7)
+
+Read and write [esf/1](https://github.com/EVEShipFit/esf-format), the
+plain-text format for EVE Online ship fits. Text, canonical and binary forms.
+No dependencies.
+
+```
+pip install esf-format
+```
+
+## Usage
+
+```python
+import esf_format
+from esf_format import Entry, EsfFit, Location, State
+
+fit = EsfFit(
+    hull=587,  # Rifter
+    name="Shield Buffer",
+    entries=[
+        Entry(2889, count=3, charge=21898),  # 3 guns, a full load of ammo each
+        Entry(None, location=Location.HIGH),  # an empty high slot
+        Entry(448, state=State.OFF),  # an offline module
+        Entry(2048),  # goes in its own rack
+        Entry(2456, count=5),  # 5 drones
+        Entry(21898, count=1000, location=Location.CARGO),
+    ],
+)
+
+text = esf_format.save([fit], catalog)  # canonical text
+data = esf_format.save_binary([fit], catalog)  # binary
+fits = esf_format.load(data, catalog)  # text or binary
+
+url = esf_format.to_base64url(data)  # the binary form in a URL
+data = esf_format.from_base64url(url)
+```
+
+`save()` and `save_binary()` take entries in any order, and check every rule
+of the spec. `load()` returns fits in canonical form. All three raise
+`esf_format.EsfError` when a rule is broken. It says where: `line` for text,
+or `fit` and `entry` (counting from 1) for fits.
+
+## Fits
+
+An `EsfFit` is one fit: `hull`, `name`, tactical `mode` and its `entries`.
+`hull` is `None` for a fit without a ship. A document can hold more than one
+fit.
+
+Each `Entry` is one line of the fit. `None` means the default:
+
+| field | what it is | `None` means |
+| --- | --- | --- |
+| `type` | The type ID. | An empty slot. |
+| `count` | How many. | One; for fighters, a full squadron. |
+| `fit_name` | The name of another fit in the list, which this ship or container carries. | Carries no fit. |
+| `charge` | The charge loaded. | |
+| `charge_count` | How many charges. | A full load. |
+| `mutaplasmid` | The mutaplasmid applied. | |
+| `overrides` | Attribute values by attribute ID. | |
+| `state` | `State.OFF`, `ON` or `HEAT`. | Active if the type can be, else on. |
+| `location` | `CARGO`, `BAY` or another hold; a rack only for an empty slot. | Where the type goes by default. |
+
+## The Catalog
+
+The library holds no game data. You give it a `Catalog`: an object that looks
+up types and attributes in your copy of the SDE.
+
+```python
+class MyCatalog:
+    def type(self, folded: str) -> esf_format.TypeRecord | None: ...
+    def type_by_id(self, type_id: int) -> esf_format.TypeRecord | None: ...
+    def attribute(self, folded: str) -> esf_format.AttributeRecord | None: ...
+    def attribute_by_id(self, attribute_id: int) -> esf_format.AttributeRecord | None: ...
+
+    # Optional. Without them, no hull has tactical modes and no type has mutaplasmids.
+    def modes(self, hull_id: int) -> Sequence[esf_format.TypeRecord]: ...
+    def mutaplasmids(self, type_id: int) -> Sequence[esf_format.MutaplasmidRecord]: ...
+```
+
+Names are looked up folded: index them with `esf_format.fold(name)`. Where
+names are shared, published wins, then the lowest ID (§4.2).
+[tests/catalog.py](https://github.com/EVEShipFit/esf-format-python/blob/main/tests/catalog.py) is a complete example.
+
+## Tests
+
+The test cases live in [esf-format](https://github.com/EVEShipFit/esf-format):
+
+```
+git clone --branch v1.0 https://github.com/EVEShipFit/esf-format
+uv sync
+uv run --project esf-format/tools esf-test -- .venv/bin/python tests/program.py
+uv run pytest
+```

esf_format-1.0.0/README.md

@@ -0,0 +1,99 @@
+# esf-format
+
+[![PyPI](https://img.shields.io/pypi/v/esf-format.svg)](https://pypi.org/project/esf-format/)
+[![Python](https://img.shields.io/pypi/pyversions/esf-format.svg)](https://pypi.org/project/esf-format/)
+[![CI](https://github.com/EVEShipFit/esf-format-python/actions/workflows/test.yml/badge.svg)](https://github.com/EVEShipFit/esf-format-python/actions/workflows/test.yml)
+
+[![Discord](https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white)](https://discord.gg/S5V5BkvNf7)
+
+Read and write [esf/1](https://github.com/EVEShipFit/esf-format), the
+plain-text format for EVE Online ship fits. Text, canonical and binary forms.
+No dependencies.
+
+```
+pip install esf-format
+```
+
+## Usage
+
+```python
+import esf_format
+from esf_format import Entry, EsfFit, Location, State
+
+fit = EsfFit(
+    hull=587,  # Rifter
+    name="Shield Buffer",
+    entries=[
+        Entry(2889, count=3, charge=21898),  # 3 guns, a full load of ammo each
+        Entry(None, location=Location.HIGH),  # an empty high slot
+        Entry(448, state=State.OFF),  # an offline module
+        Entry(2048),  # goes in its own rack
+        Entry(2456, count=5),  # 5 drones
+        Entry(21898, count=1000, location=Location.CARGO),
+    ],
+)
+
+text = esf_format.save([fit], catalog)  # canonical text
+data = esf_format.save_binary([fit], catalog)  # binary
+fits = esf_format.load(data, catalog)  # text or binary
+
+url = esf_format.to_base64url(data)  # the binary form in a URL
+data = esf_format.from_base64url(url)
+```
+
+`save()` and `save_binary()` take entries in any order, and check every rule
+of the spec. `load()` returns fits in canonical form. All three raise
+`esf_format.EsfError` when a rule is broken. It says where: `line` for text,
+or `fit` and `entry` (counting from 1) for fits.
+
+## Fits
+
+An `EsfFit` is one fit: `hull`, `name`, tactical `mode` and its `entries`.
+`hull` is `None` for a fit without a ship. A document can hold more than one
+fit.
+
+Each `Entry` is one line of the fit. `None` means the default:
+
+| field | what it is | `None` means |
+| --- | --- | --- |
+| `type` | The type ID. | An empty slot. |
+| `count` | How many. | One; for fighters, a full squadron. |
+| `fit_name` | The name of another fit in the list, which this ship or container carries. | Carries no fit. |
+| `charge` | The charge loaded. | |
+| `charge_count` | How many charges. | A full load. |
+| `mutaplasmid` | The mutaplasmid applied. | |
+| `overrides` | Attribute values by attribute ID. | |
+| `state` | `State.OFF`, `ON` or `HEAT`. | Active if the type can be, else on. |
+| `location` | `CARGO`, `BAY` or another hold; a rack only for an empty slot. | Where the type goes by default. |
+
+## The Catalog
+
+The library holds no game data. You give it a `Catalog`: an object that looks
+up types and attributes in your copy of the SDE.
+
+```python
+class MyCatalog:
+    def type(self, folded: str) -> esf_format.TypeRecord | None: ...
+    def type_by_id(self, type_id: int) -> esf_format.TypeRecord | None: ...
+    def attribute(self, folded: str) -> esf_format.AttributeRecord | None: ...
+    def attribute_by_id(self, attribute_id: int) -> esf_format.AttributeRecord | None: ...
+
+    # Optional. Without them, no hull has tactical modes and no type has mutaplasmids.
+    def modes(self, hull_id: int) -> Sequence[esf_format.TypeRecord]: ...
+    def mutaplasmids(self, type_id: int) -> Sequence[esf_format.MutaplasmidRecord]: ...
+```
+
+Names are looked up folded: index them with `esf_format.fold(name)`. Where
+names are shared, published wins, then the lowest ID (§4.2).
+[tests/catalog.py](https://github.com/EVEShipFit/esf-format-python/blob/main/tests/catalog.py) is a complete example.
+
+## Tests
+
+The test cases live in [esf-format](https://github.com/EVEShipFit/esf-format):
+
+```
+git clone --branch v1.0 https://github.com/EVEShipFit/esf-format
+uv sync
+uv run --project esf-format/tools esf-test -- .venv/bin/python tests/program.py
+uv run pytest
+```

esf_format-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "esf-format"
+version = "1.0.0"
+description = "Read and write esf/1, the plain-text format for EVE Online ship fits"
+readme = "README.md"
+authors = [{ name = "EVEShipFit Team" }]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Games/Entertainment",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/EVEShipFit/esf-format-python"
+Specification = "https://github.com/EVEShipFit/esf-format"
+
+[dependency-groups]
+dev = [
+    "coverage>=7.17.0",
+    "mypy>=2.4.1",
+    "pytest>=9.2.0",
+    "ruff",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 100
+
+[tool.coverage.run]
+source = ["esf_format"]
+parallel = true
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.pytest.ini_options]
+pythonpath = ["tests"]
+
+[tool.mypy]
+strict = true

esf_format-1.0.0/src/esf_format/__init__.py

@@ -0,0 +1,104 @@
+"""Read and write esf/1 (https://github.com/EVEShipFit/esf-format)."""
+
+import base64
+import re
+
+from . import binary, canonical, resolve, source, text
+from .canonical import CanonFit
+from .catalog import (
+    AttributeRecord,
+    Catalog,
+    Kind,
+    ModeCatalog,
+    MutaplasmidCatalog,
+    MutaplasmidRecord,
+    TypeRecord,
+)
+from .errors import EsfError
+from .model import Entry, EsfFit, Location, State
+from .names import fold
+
+__all__ = [
+    "AttributeRecord",
+    "Catalog",
+    "Entry",
+    "EsfError",
+    "EsfFit",
+    "Kind",
+    "Location",
+    "ModeCatalog",
+    "MutaplasmidCatalog",
+    "MutaplasmidRecord",
+    "State",
+    "TypeRecord",
+    "fold",
+    "from_base64url",
+    "is_text",
+    "load",
+    "save",
+    "save_binary",
+    "to_base64url",
+]
+
+_BASE64URL = re.compile(r"[A-Za-z0-9_-]*")
+
+
+def is_text(data: bytes | str) -> bool:
+    """Whether a document is text, by its first character (§10)."""
+    return data[:1] in (b"%", b" ", "%", " ")
+
+
+def _canonical(
+    blocks: list[text.FitBlock], catalog: Catalog, given: list[EsfFit] | None = None
+) -> list[CanonFit]:
+    fits = resolve.resolve(blocks, catalog)
+    if given is not None:
+        source.verify(fits, given)
+    return [canonical.canonical_fit(f, catalog) for f in fits]
+
+
+def _checked(fits: list[EsfFit], catalog: Catalog) -> list[CanonFit]:
+    data, where = source.source(fits, catalog)
+    try:
+        return _canonical(text.parse(data), catalog, fits)
+    except EsfError as e:
+        if e.line is None:
+            raise
+        fit, entry = where[e.line - 1]
+        raise EsfError(e.message, fit=fit, entry=entry) from None
+
+
+def load(data: bytes | str, catalog: Catalog) -> list[EsfFit]:
+    """Read a text or binary document, in canonical form."""
+    if isinstance(data, str):
+        data = data.encode("utf-8", "surrogatepass")
+    if not data:
+        raise EsfError("the document is empty")
+    if is_text(data):
+        fits = _canonical(text.parse(data), catalog)
+    else:
+        fits = _checked(binary.decode(data), catalog)
+    return [canonical.to_model(f) for f in fits]
+
+
+def save(fits: list[EsfFit], catalog: Catalog) -> str:
+    """Write fits as canonical text (§8)."""
+    return canonical.render(_checked(fits, catalog))
+
+
+def save_binary(fits: list[EsfFit], catalog: Catalog) -> bytes:
+    """Write fits in the binary form (§10)."""
+    return binary.encode([canonical.to_model(f) for f in _checked(fits, catalog)])
+
+
+def to_base64url(data: bytes) -> str:
+    """The binary form as base64url without padding, for URLs (§10.4)."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
+
+
+def from_base64url(encoded: str) -> bytes:
+    """The binary form from base64url without padding (§10.4)."""
+    encoded = encoded.strip()
+    if not _BASE64URL.fullmatch(encoded) or len(encoded) % 4 == 1:
+        raise EsfError("not valid base64url")
+    return base64.urlsafe_b64decode(encoded + "=" * (-len(encoded) % 4))

esf_format-1.0.0/src/esf_format/binary.py

@@ -0,0 +1,185 @@
+"""The binary form (SPEC §10)."""
+
+import struct
+from typing import TypeVar
+
+from . import wire
+from .model import Entry, EsfFit, Location, State
+
+T = TypeVar("T")
+from .errors import EsfError
+from .text import UINT32_MAX
+
+STATES = {State.OFF: 1, State.ON: 2, State.HEAT: 3}
+LOCATIONS = {
+    Location.HIGH: 1,
+    Location.MID: 2,
+    Location.LOW: 3,
+    Location.RIG: 4,
+    Location.SUB: 5,
+    Location.SVC: 6,
+    Location.CARGO: 7,
+    Location.BAY: 8,
+    Location.AMMO: 9,
+    Location.BOOSTER: 10,
+    Location.COMMAND: 11,
+    Location.CORPSE: 12,
+    Location.DEPOT: 13,
+    Location.EXPEDITION: 14,
+    Location.FLEET: 15,
+    Location.FRIGATE: 16,
+    Location.FUEL: 17,
+    Location.GAS: 18,
+    Location.ICE: 19,
+    Location.INFRASTRUCTURE: 20,
+    Location.MAINTENANCE: 21,
+    Location.MINERAL: 22,
+    Location.MINING: 23,
+    Location.MOON: 24,
+    Location.PLANETARY: 25,
+    Location.QUAFE: 26,
+    Location.SUBSYSTEM: 27,
+}
+
+
+def _encode_entry(entry: Entry) -> bytes:
+    out = []
+    if entry.type is not None:
+        out.append(wire.uint(1, entry.type))
+    if entry.count is not None:
+        out.append(wire.uint(2, entry.count))
+    if entry.fit_name:
+        out.append(wire.record(3, entry.fit_name.encode()))
+    if entry.charge is not None:
+        out.append(wire.uint(4, entry.charge))
+    if entry.charge_count is not None:
+        out.append(wire.uint(5, entry.charge_count))
+    if entry.mutaplasmid is not None:
+        out.append(wire.uint(6, entry.mutaplasmid))
+    if entry.overrides:
+        out.append(wire.packed_uints(7, list(entry.overrides)))
+        out.append(wire.packed_doubles(8, list(entry.overrides.values())))
+    if entry.state is not None:
+        out.append(wire.uint(9, STATES[entry.state]))
+    if entry.location is not None:
+        out.append(wire.uint(10, LOCATIONS[entry.location]))
+    return b"".join(out)
+
+
+def _encode_fit(fit: EsfFit) -> bytes:
+    out = [wire.uint(1, 1)]
+    if fit.hull is not None:
+        out.append(wire.uint(2, fit.hull))
+    if fit.name:
+        out.append(wire.record(3, fit.name.encode()))
+    if fit.mode is not None:
+        out.append(wire.uint(4, fit.mode))
+    out += [wire.record(5, _encode_entry(entry)) for entry in fit.entries]
+    return b"".join(out)
+
+
+def encode(fits: list[EsfFit]) -> bytes:
+    return b"".join(wire.record(1, _encode_fit(fit)) for fit in fits)
+
+
+def _uint32(value: int, what: str) -> int:
+    if value > UINT32_MAX:
+        raise EsfError(f"binary: {what} is out of range")
+    return value
+
+
+def _string(payload: bytes, what: str) -> str | None:
+    try:
+        return payload.decode("utf-8") or None
+    except UnicodeDecodeError:
+        raise EsfError(f"binary: {what} is not valid UTF-8") from None
+
+
+def _enum(numbers: dict[T, int], value: int, what: str) -> T | None:
+    if value == 0:
+        return None
+    for member, number in numbers.items():
+        if number == value:
+            return member
+    raise EsfError(f"binary: unknown {what} value {value}")
+
+
+def _not_in_schema(what: str) -> EsfError:
+    return EsfError(f"binary: {what} has a field that is not in the schema")
+
+
+def _decode_entry(data: bytes) -> Entry:
+    e = Entry(None)
+    attributes: list[int] = []
+    values: list[float] = []
+    for tag, wire_type, value in wire.fields(data):
+        match tag, wire_type:
+            case 1, wire.VARINT:
+                e.type = _uint32(value, "Entry.type")
+            case 2, wire.VARINT:
+                e.count = _uint32(value, "Entry.count")
+            case 3, wire.LEN:
+                e.fit_name = _string(value, "Entry.fit_name")
+            case 4, wire.VARINT:
+                e.charge = _uint32(value, "Entry.charge")
+            case 5, wire.VARINT:
+                e.charge_count = _uint32(value, "Entry.charge_count")
+            case 6, wire.VARINT:
+                e.mutaplasmid = _uint32(value, "Entry.mutaplasmid")
+            case 7, wire.VARINT:
+                attributes.append(_uint32(value, "Entry.override_attributes"))
+            case 7, wire.LEN:
+                attributes += [
+                    _uint32(v, "Entry.override_attributes") for v in wire.unpack_uints(value)
+                ]
+            case 8, wire.I64:
+                values.append(struct.unpack("<d", value)[0])
+            case 8, wire.LEN:
+                values += wire.unpack_doubles(value)
+            case 9, wire.VARINT:
+                e.state = _enum(STATES, value, "State")
+            case 10, wire.VARINT:
+                e.location = _enum(LOCATIONS, value, "Location")
+            case _:
+                raise _not_in_schema("Entry")
+    if len(attributes) != len(values):
+        raise EsfError("binary: override fields have different lengths")
+    e.overrides = dict(zip(attributes, values))
+    if len(e.overrides) != len(attributes):
+        raise EsfError("binary: an attribute is overridden twice")
+    return e
+
+
+def _decode_fit(data: bytes) -> EsfFit:
+    fit = EsfFit()
+    version = 0
+    for tag, wire_type, value in wire.fields(data):
+        match tag, wire_type:
+            case 1, wire.VARINT:
+                version = _uint32(value, "Fit.version")
+            case 2, wire.VARINT:
+                fit.hull = _uint32(value, "Fit.hull")
+            case 3, wire.LEN:
+                fit.name = _string(value, "Fit.name")
+            case 4, wire.VARINT:
+                fit.mode = _uint32(value, "Fit.tactical_mode")
+            case 5, wire.LEN:
+                fit.entries.append(_decode_entry(value))
+            case _:
+                raise _not_in_schema("Fit")
+    if version != 1:
+        raise EsfError(f"binary: unsupported Fit.version {version}")
+    return fit
+
+
+def decode(data: bytes) -> list[EsfFit]:
+    fits = []
+    for tag, wire_type, value in wire.fields(data):
+        if tag != 1:
+            continue
+        if wire_type != wire.LEN:
+            raise EsfError("binary: Document.fits has the wrong wire type")
+        fits.append(_decode_fit(value))
+    if not fits:
+        raise EsfError("binary: a document holds at least one fit")
+    return fits