foamlib 0.9.0__tar.gz → 0.9.2__tar.gz

{foamlib-0.9.0 → foamlib-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.0
+Version: 0.9.2
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib

{foamlib-0.9.0 → foamlib-0.9.2}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.9.0"
+__version__ = "0.9.2"
 
 from ._cases import (
     AsyncFoamCase,

{foamlib-0.9.0 → foamlib-0.9.2}/foamlib/_files/_files.py

@@ -17,9 +17,11 @@ else:
 import numpy as np
 
 from ._io import FoamFileIO
-from ._serialization import Kind, dumps, normalize
+from ._parsing import loads
+from ._serialization import dumps, normalize_data, normalize_keyword
 from ._types import (
     Data,
+    DataLike,
     Dict_,
     Dimensioned,
     DimensionSet,
@@ -31,6 +33,32 @@ from ._types import (
 )
 
 
+def _tensor_kind_for_field(
+    field: FieldLike,
+) -> str:
+    shape = np.shape(field)  # type: ignore [arg-type]
+    if not shape:
+        return "scalar"
+    if shape == (3,):
+        return "vector"
+    if shape == (6,):
+        return "symmTensor"
+    if shape == (9,):
+        return "tensor"
+    if len(shape) == 1:
+        return "scalar"
+    if len(shape) == 2:
+        if shape[1] == 3:
+            return "vector"
+        if shape[1] == 6:
+            return "symmTensor"
+        if shape[1] == 9:
+            return "tensor"
+
+    msg = f"Invalid field shape: {shape}"
+    raise ValueError(msg)
+
+
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
@@ -261,7 +289,7 @@ class FoamFile(
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        if keywords and not isinstance(normalize(keywords[-1], kind=Kind.KEYWORD), str):
+        if keywords and not isinstance(normalize_keyword(keywords[-1]), str):
             msg = f"Invalid keyword: {keywords[-1]}"
             raise ValueError(msg)
 
@@ -283,52 +311,26 @@ class FoamFile(
                     self.path.stem if self.path.suffix == ".gz" else self.path.name
                 )
 
-            kind = Kind.DEFAULT
-            if keywords == ("internalField",) or (
-                len(keywords) == 3
-                and keywords[0] == "boundaryField"
-                and (
-                    keywords[2] in ("value", "gradient")
-                    or keywords[2].endswith("Value")
-                    or keywords[2].endswith("Gradient")
-                )
-            ):
-                kind = (
-                    Kind.BINARY_FIELD if self.format == "binary" else Kind.ASCII_FIELD
-                )
-            elif keywords == ("dimensions",):
-                kind = Kind.DIMENSIONS
-
             if (
-                kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD)
+                keywords == ("internalField",)
+                or (
+                    len(keywords) == 3
+                    and keywords[0] == "boundaryField"
+                    and (
+                        keywords[2] == "value"
+                        or keywords[2] == "gradient"
+                        or keywords[2].endswith(("Value", "Gradient"))
+                    )
+                )
             ) and self.class_ == "dictionary":
                 try:
-                    shape = np.shape(data)  # type: ignore [arg-type]
+                    tensor_kind = _tensor_kind_for_field(data)  # type: ignore [arg-type]
                 except ValueError:
                     pass
                 else:
-                    if not shape:
-                        self.class_ = "volScalarField"
-                    elif shape == (3,):
-                        self.class_ = "volVectorField"
-                    elif shape == (6,):
-                        self.class_ = "volSymmTensorField"
-                    elif shape == (9,):
-                        self.class_ = "volTensorField"
-                    elif len(shape) == 1:
-                        self.class_ = "volScalarField"
-                    elif len(shape) == 2:
-                        if shape[1] == 3:
-                            self.class_ = "volVectorField"
-                        elif shape[1] == 6:
-                            self.class_ = "volSymmTensorField"
-                        elif shape[1] == 9:
-                            self.class_ = "volTensorField"
-
-            if kind == Kind.ASCII_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_ASCII_FIELD
-            elif kind == Kind.BINARY_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_BINARY_FIELD
+                    self.class_ = (
+                        "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+                    )
 
             parsed = self._get_parsed(missing_ok=True)
 
@@ -360,7 +362,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -373,23 +375,37 @@ class FoamFile(
                     self[(*keywords, k)] = v
 
             elif keywords:
-                val = dumps(data, kind=kind)
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
+                val = dumps(
+                    data,
+                    keywords=keywords,
+                    header=header,
+                )
                 parsed.put(
                     keywords,
-                    normalize(data, kind=kind),
+                    normalize_data(data, keywords=keywords),
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + ((b" " + val) if val else b"")
                     + (b";" if not keywords[-1].startswith("#") else b"")
                     + after,
                 )
 
             else:
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
                 parsed.put(
                     (),
-                    normalize(data, kind=kind),
-                    before + dumps(data, kind=kind) + after,
+                    normalize_data(data, keywords=keywords),
+                    before
+                    + dumps(
+                        data,
+                        keywords=(),
+                        header=header,
+                    )
+                    + after,
                 )
 
     def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
@@ -442,6 +458,85 @@ class FoamFile(
             d.pop("FoamFile", None)
         return deepcopy(d)
 
+    @staticmethod
+    def loads(
+        s: bytes | str,
+        *,
+        include_header: bool = False,
+    ) -> File | Data:
+        """
+        Standalone deserializing function.
+
+        Deserialize the OpenFOAM FoamFile format to Python objects.
+
+        :param s: The string to deserialize. This can be a dictionary, list, or any
+            other object that can be serialized to the OpenFOAM format.
+        :param include_header: Whether to include the "FoamFile" header in the output.
+            If `True`, the header will be included if it is present in the input object.
+        """
+        ret = loads(s)
+
+        if not include_header and isinstance(ret, Mapping) and "FoamFile" in ret:
+            del ret["FoamFile"]
+            if len(ret) == 1 and None in ret:
+                val = ret[None]
+                assert not isinstance(val, Mapping)
+                return val
+
+        return ret
+
+    @staticmethod
+    def dumps(file: File | DataLike, *, ensure_header: bool = True) -> bytes:
+        """
+        Standalone serializing function.
+
+        Serialize Python objects to the OpenFOAM FoamFile format.
+
+        :param file: The Python object to serialize. This can be a dictionary, list,
+            or any other object that can be serialized to the OpenFOAM format.
+        :param ensure_header: Whether to include the "FoamFile" header in the output.
+            If `True`, a header will be included if it is not already present in the
+            input object.
+        """
+        if isinstance(file, Mapping):
+            header = file.get("FoamFile", None)
+            assert isinstance(header, FoamFile.SubDict) or header is None
+            entries: list[bytes] = []
+            for k, v in file.items():
+                if k is not None:
+                    entries.append(
+                        dumps((k, v), keywords=(), header=header, tuple_is_entry=True)
+                    )
+                else:
+                    entries.append(dumps(v, keywords=(), header=header))
+            ret = b" ".join(entries)
+        else:
+            header = None
+            ret = dumps(file)
+
+        if header is None and ensure_header:
+            class_ = "dictionary"
+            if isinstance(file, Mapping) and "internalField" in file:
+                try:
+                    tensor_kind = _tensor_kind_for_field(file["internalField"])  # type: ignore [arg-type]
+                except (ValueError, TypeError):
+                    pass
+                else:
+                    class_ = "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+
+            header = {"version": 2.0, "format": "ascii", "class": class_}
+
+            ret = (
+                dumps(
+                    {"FoamFile": header},
+                    keywords=(),
+                )
+                + b" "
+                + ret
+            )
+
+        return ret
+
 
 class FoamFieldFile(FoamFile):
     """

{foamlib-0.9.0 → foamlib-0.9.2}/foamlib/_files/_parsing.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Tuple, Union, cast
+from typing import TYPE_CHECKING, Tuple, Union, cast
 
 if sys.version_info >= (3, 9):
     from collections.abc import Iterator, Mapping, MutableMapping, Sequence
@@ -40,46 +40,43 @@ from pyparsing import (
 
 from ._types import Data, Dimensioned, DimensionSet, File
 
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
 
-def _numeric_list(
-    *, nested: int | None = None, ignore: Regex | None = None, force_float: bool = False
+
+def _ascii_numeric_list(
+    dtype: DTypeLike,
+    *,
+    nested: int | None = None,
+    ignore: Regex | None = None,
+    empty_ok: bool = False,
 ) -> ParserElement:
-    if not force_float:
-        int_pattern = r"(?:-?\d+)"
-    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    dtype = np.dtype(dtype)
+
+    if np.issubdtype(dtype, np.floating):
+        element = common.ieee_float
+        element_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    elif np.issubdtype(dtype, np.integer):
+        element = common.integer
+        element_pattern = r"(?:-?\d+)"
+    else:
+        msg = f"Unsupported dtype: {dtype}"
+        raise TypeError(msg)
+
     spacing_pattern = (
-        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"\s+"
+        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"(?:\s+)"
     )
 
-    if nested is None:
-        if not force_float:
-            int_element_pattern = int_pattern
-            int_element = common.integer
-        float_element_pattern = float_pattern
-        float_element = common.ieee_float
-    else:
-        if not force_float:
-            int_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{int_pattern}{spacing_pattern}){{{nested - 1}}}{int_pattern}{spacing_pattern}?\))"
-            int_element = (
-                Opt(Literal(str(nested))).suppress()
-                + Literal("(").suppress()
-                + Group(common.integer[nested])
-                + Literal(")").suppress()
-            )
-        float_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{float_pattern}{spacing_pattern}){{{nested - 1}}}{float_pattern}{spacing_pattern}?\))"
-        float_element = (
-            Opt(Literal(str(nested))).suppress()
-            + Literal("(").suppress()
-            + Group(common.ieee_float[nested])
-            + Literal(")").suppress()
+    if nested is not None:
+        element = (
+            Literal("(").suppress() + Group(element[nested]) + Literal(")").suppress()
         )
+        element_pattern = rf"(?:{spacing_pattern}?\({element_pattern}?(?:{element_pattern}{spacing_pattern}){{{nested - 1}}}{element_pattern}{spacing_pattern}?\))"
 
-    if not force_float:
-        int_list = Forward()
-    float_list = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal int_list, float_list
+        nonlocal list_
 
         if not tks:
             count = None
@@ -88,46 +85,41 @@ def _numeric_list(
             assert isinstance(count, int)
 
         if count is None:
-            if not force_float:
-                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern})*{int_element_pattern}{spacing_pattern}?\)"
-                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}{spacing_pattern}?\)"
+            if not empty_ok:
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}{spacing_pattern}?\)"
             else:
-                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}?{spacing_pattern}?\)"
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}?{spacing_pattern}?\)"
 
         elif count == 0:
-            if not force_float:
-                int_list <<= NoMatch()
-                float_list <<= NoMatch()
+            if not empty_ok:
+                list_ <<= NoMatch()
             else:
-                float_list <<= (Literal("(") + Literal(")")).add_parse_action(
-                    lambda: np.empty((0, nested) if nested else 0, dtype=float)
+                list_ <<= (Literal("(") + Literal(")")).add_parse_action(
+                    lambda: np.empty((0, nested) if nested else 0, dtype=dtype)
                 )
             return
 
         else:
-            if not force_float:
-                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern}){{{count - 1}}}{int_element_pattern}{spacing_pattern}?\)"
-            float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern}){{{count - 1}}}{float_element_pattern}{spacing_pattern}?\)"
+            list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern}){{{count - 1}}}{element_pattern}{spacing_pattern}?\)"
 
-        if not force_float:
-            int_list <<= Regex(int_list_pattern).add_parse_action(
-                lambda tks: to_array(tks, dtype=int)
-            )
-        float_list <<= Regex(float_list_pattern).add_parse_action(
-            lambda tks: to_array(tks, dtype=float)
+        list_ <<= Regex(list_pattern).add_parse_action(
+            lambda tks: to_array(tks, dtype=dtype)
         )
 
     def to_array(
-        tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+        tks: ParseResults, *, dtype: DTypeLike
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         (s,) = tks
-        s = s.replace("(", "").replace(")", "")
-
+        assert s.startswith("(")
+        assert s.endswith(")")
+        s = s[1:-1]
         if ignore is not None:
             s = re.sub(ignore.re, " ", s)
+        if nested is not None:
+            s = s.replace("(", " ").replace(")", " ")
 
         ret: np.ndarray[
-            tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]
+            tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]
         ] = np.fromstring(s, sep=" ", dtype=dtype)  # type: ignore[assignment]
 
         if nested is not None:
@@ -137,7 +129,7 @@ def _numeric_list(
 
     def to_full_array(
         tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         count, lst = tks
         assert isinstance(count, int)
 
@@ -146,24 +138,8 @@ def _numeric_list(
 
         return np.full((count, nested), lst, dtype=dtype)  # type: ignore[return-value]
 
-    count = Opt(common.integer).add_parse_action(process_count)
-
-    ret = count.suppress() + (
-        (int_list | float_list) if not force_float else float_list
-    )
-
-    if not force_float:
-        ret |= (
-            common.integer
-            + Literal("{").suppress()
-            + int_element
-            + Literal("}").suppress()
-        ).add_parse_action(lambda tks: to_full_array(tks, dtype=int))
-    ret |= (
-        common.integer
-        + Literal("{").suppress()
-        + float_element
-        + Literal("}").suppress()
+    ret = ((Opt(common.integer).add_parse_action(process_count)).suppress() + list_) | (
+        common.integer + Literal("{").suppress() + element + Literal("}").suppress()
     ).add_parse_action(lambda tks: to_full_array(tks, dtype=float))
 
     if ignore is not None:
@@ -172,23 +148,29 @@ def _numeric_list(
     return ret
 
 
-def _binary_field(*, nested: int | None = None) -> ParserElement:
+def _binary_numeric_list(
+    dtype: DTypeLike, *, nested: int | None = None, empty_ok: bool = False
+) -> ParserElement:
+    dtype = np.dtype(dtype)
+
     elsize = nested if nested is not None else 1
 
-    binary_field = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal binary_field
+        nonlocal list_
         (size,) = tks
         assert isinstance(size, int)
 
-        binary_field <<= Regex(
-            rf"\((?s:({'.' * 8 * elsize}|{'.' * 4 * elsize}){{{size}}})\)"
-        )
+        if size == 0 and not empty_ok:
+            list_ <<= NoMatch()
+            return
+
+        list_ <<= Regex(rf"\((?s:{'.' * dtype.itemsize * elsize}){{{size}}}\)")
 
     def to_array(
         tks: ParseResults,
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         size, s = tks
         assert isinstance(size, int)
         assert isinstance(s, str)
@@ -196,10 +178,6 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
         assert s[-1] == ")"
         s = s[1:-1]
 
-        float_size = len(s) / elsize / size
-        assert float_size in (4, 8)
-
-        dtype = np.float32 if float_size == 4 else float
         ret = np.frombuffer(s.encode("latin-1"), dtype=dtype)
 
         if nested is not None:
@@ -207,9 +185,9 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
 
         return ret  # type: ignore[return-value]
 
-    count = common.integer.copy().add_parse_action(process_count)
-
-    return (count + binary_field).add_parse_action(to_array)
+    return (
+        common.integer.copy().add_parse_action(process_count) + list_
+    ).add_parse_action(to_array)
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -337,15 +315,22 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
             Opt(
                 Literal("List") + Literal("<") + Literal("scalar") + Literal(">")
             ).suppress()
-            + (_numeric_list(force_float=True, ignore=_COMMENT) | _binary_field())
+            + (
+                _ascii_numeric_list(dtype=float, ignore=_COMMENT, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float64, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float32, empty_ok=True)
+            )
         )
         | (
             Opt(
                 Literal("List") + Literal("<") + Literal("vector") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(nested=3, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=3)
+                _ascii_numeric_list(
+                    dtype=float, nested=3, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=3, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=3, empty_ok=True)
             )
         )
         | (
@@ -353,12 +338,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("symmTensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(
-                    nested=6,
-                    force_float=True,
-                    ignore=_COMMENT,
+                _ascii_numeric_list(
+                    dtype=float, nested=6, ignore=_COMMENT, empty_ok=True
                 )
-                | _binary_field(nested=6)
+                | _binary_numeric_list(np.float64, nested=6, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=6, empty_ok=True)
             )
         )
         | (
@@ -366,8 +350,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("tensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(nested=9, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=9)
+                _ascii_numeric_list(
+                    dtype=float, nested=9, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=9, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=9, empty_ok=True)
             )
         )
     )
@@ -380,12 +367,7 @@ _KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
-_LIST = (
-    _numeric_list(ignore=_COMMENT)
-    | _numeric_list(nested=3, ignore=_COMMENT)
-    | _numeric_list(nested=4, ignore=_COMMENT)
-    | _list_of(_LIST_ENTRY)
-)
+_LIST = _list_of(_LIST_ENTRY)
 _NUMBER = (
     common.number
     | CaselessKeyword("nan").set_parse_action(lambda: np.nan)
@@ -398,21 +380,41 @@ _NUMBER = (
 )
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-_DATA <<= (
-    _DATA_ENTRY[1, ...]
-    .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
+_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
+    lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]]
+)
+
+_STANDALONE_DATA = (
+    _ascii_numeric_list(dtype=int, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.int64)
+    | _binary_numeric_list(dtype=np.int32)
+    | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.float64, nested=3)
+    | _binary_numeric_list(dtype=np.float32, nested=3)
+    | _DATA
+).add_parse_action(lambda tks: [None, tks[0]])
+
+
+_FILE = (
+    Dict(_KEYWORD_ENTRY[...] + Opt(Group(_STANDALONE_DATA)) + _KEYWORD_ENTRY[...])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
 
-def parse_data(s: str) -> Data:
-    if not s.strip():
-        return ""
-    return cast("Data", _DATA.parse_string(s, parse_all=True)[0])
+def loads(s: bytes | str) -> File | Data:
+    if isinstance(s, bytes):
+        s = s.decode("latin-1")
+
+    file = _FILE.parse_string(s, parse_all=True).as_dict()
 
+    if len(file) == 1 and None in file:
+        return file[None]  # type: ignore[no-any-return]
 
-_LOCATED_DICTIONARY = Group(
+    return file
+
+
+_LOCATED_KEYWORD_ENTRIES = Group(
     _keyword_entry_of(
         _TOKEN,
         Opt(_DATA, default=""),
@@ -421,10 +423,14 @@ _LOCATED_DICTIONARY = Group(
         located=True,
     )
 )[...]
-_LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
+_LOCATED_STANDALONE_DATA = Group(Located(_STANDALONE_DATA))
 
-_FILE = (
-    Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)
+_LOCATED_FILE = (
+    Dict(
+        _LOCATED_KEYWORD_ENTRIES
+        + Opt(_LOCATED_STANDALONE_DATA)
+        + _LOCATED_KEYWORD_ENTRIES
+    )
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
@@ -436,7 +442,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
             tuple[str, ...],
             tuple[int, Data | EllipsisType, int],
         ] = {}
-        for parse_result in _FILE.parse_string(
+        for parse_result in _LOCATED_FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
         ):
             self._parsed.update(self._flatten_result(parse_result))
@@ -459,8 +465,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
         end = parse_result.locn_end
         assert isinstance(end, int)
         keyword, *data = item
-        assert isinstance(keyword, str)
-        if not keyword:
+        if keyword is None:
             assert not _keywords
             assert len(data) == 1
             assert not isinstance(data[0], ParseResults)