foamlib 0.8.0__tar.gz → 0.8.2__tar.gz

{foamlib-0.8.0 → foamlib-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: foamlib
-Version: 0.8.0
+Version: 0.8.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
@@ -25,12 +25,12 @@ Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.7
 Requires-Dist: aioshutil<2,>=1
-Requires-Dist: pyparsing<4,>=3
+Requires-Dist: numpy<3,>=1
+Requires-Dist: numpy<3,>=1.25.0; python_version >= '3.10'
+Requires-Dist: pyparsing<4,>=3.1.2
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: mypy<2,>=1; extra == 'dev'
-Requires-Dist: numpy<3,>=1; extra == 'dev'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'dev'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest<9,>=7; extra == 'dev'
@@ -38,25 +38,16 @@ Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: sphinx-rtd-theme; extra == 'dev'
 Requires-Dist: sphinx<9,>=5; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: numpy<3,>=1; extra == 'docs'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'docs'
 Requires-Dist: sphinx-rtd-theme; extra == 'docs'
 Requires-Dist: sphinx<9,>=5; extra == 'docs'
 Provides-Extra: lint
 Requires-Dist: ruff; extra == 'lint'
-Provides-Extra: numpy
-Requires-Dist: numpy<3,>=1; extra == 'numpy'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'numpy'
 Provides-Extra: test
-Requires-Dist: numpy<3,>=1; extra == 'test'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'test'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest<9,>=7; extra == 'test'
 Provides-Extra: typing
 Requires-Dist: mypy<2,>=1; extra == 'typing'
-Requires-Dist: numpy<3,>=1; extra == 'typing'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'typing'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'typing'
 Requires-Dist: pytest-cov; extra == 'typing'
 Requires-Dist: pytest<9,>=7; extra == 'typing'

{foamlib-0.8.0 → foamlib-0.8.2}/foamlib/__init__.py

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

{foamlib-0.8.0 → foamlib-0.8.2}/foamlib/_cases/_async.py

@@ -106,7 +106,7 @@ class AsyncFoamCase(FoamCaseRunBase):
     async def _rmtree(
         path: os.PathLike[str] | str, *, ignore_errors: bool = False
     ) -> None:
-        await aioshutil.rmtree(path, ignore_errors=ignore_errors)
+        await aioshutil.rmtree(path, ignore_errors=ignore_errors)  # type: ignore [call-arg]
 
     @staticmethod
     async def _copytree(

{foamlib-0.8.0 → foamlib-0.8.2}/foamlib/_files/_files.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 import sys
 from copy import deepcopy
 from typing import Any, Optional, Tuple, Union, cast
@@ -15,6 +14,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Iterator, Mapping, MutableMapping, Sequence
 
+import numpy as np
+
 from ._io import FoamFileIO
 from ._serialization import Kind, dumps, normalize
 from ._types import (
@@ -27,7 +28,6 @@ from ._types import (
     File,
     MutableEntry,
 )
-from ._util import is_sequence
 
 
 class FoamFile(
@@ -196,7 +196,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(keywords[-1]), str):
             msg = f"Invalid keyword: {keywords[-1]}"
             raise ValueError(msg)
 
@@ -228,52 +228,43 @@ class FoamFile(
                     or keywords[2].endswith("Gradient")
                 )
             ):
-                if self.format == "binary":
-                    arch = self.get(("FoamFile", "arch"), default=None)
-                    assert arch is None or isinstance(arch, str)
-                    if (arch is not None and "scalar=32" in arch) or (
-                        arch is None
-                        and os.environ.get("WM_PRECISION_OPTION", default="DP") == "SP"
-                    ):
-                        kind = Kind.SINGLE_PRECISION_BINARY_FIELD
-                    else:
-                        kind = Kind.DOUBLE_PRECISION_BINARY_FIELD
-                else:
-                    kind = Kind.ASCII_FIELD
+                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.DOUBLE_PRECISION_BINARY_FIELD,
-                    Kind.SINGLE_PRECISION_BINARY_FIELD,
-                )
+                kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD)
             ) and self.class_ == "dictionary":
-                if isinstance(data, (int, float)):
-                    self.class_ = "volScalarField"
-
-                elif is_sequence(data) and data:
-                    if isinstance(data[0], (int, float)):
-                        if len(data) == 3:
-                            self.class_ = "volVectorField"
-                        elif len(data) == 6:
-                            self.class_ = "volSymmTensorField"
-                        elif len(data) == 9:
-                            self.class_ = "volTensorField"
-                    elif (
-                        is_sequence(data[0])
-                        and data[0]
-                        and isinstance(data[0][0], (int, float))
-                    ):
-                        if len(data[0]) == 3:
+                try:
+                    shape = np.shape(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 len(data[0]) == 6:
+                        elif shape[1] == 6:
                             self.class_ = "volSymmTensorField"
-                        elif len(data[0]) == 9:
+                        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
+
             parsed = self._get_parsed(missing_ok=True)
 
             start, end = parsed.entry_location(keywords, missing_ok=True)
@@ -304,7 +295,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1], kind=Kind.KEYWORD)
+                    + dumps(keywords[-1])
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -322,7 +313,7 @@ class FoamFile(
                     normalize(data, kind=kind),
                     before
                     + indentation
-                    + dumps(keywords[-1], kind=Kind.KEYWORD)
+                    + dumps(keywords[-1])
                     + b" "
                     + dumps(data, kind=kind)
                     + b";"

{foamlib-0.8.0 → foamlib-0.8.2}/foamlib/_files/_parsing.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
-import array
 import re
 import sys
-from enum import Enum, auto
 from typing import Tuple, Union, cast
 
 if sys.version_info >= (3, 9):
@@ -16,6 +14,7 @@ if sys.version_info >= (3, 10):
 else:
     EllipsisType = type(...)
 
+import numpy as np
 from pyparsing import (
     Combine,
     Dict,
@@ -37,62 +36,31 @@ from pyparsing import (
     printables,
 )
 
-from ._types import Data, Dimensioned, DimensionSet, File
-
-
-class Tensor(Enum):
-    SCALAR = auto()
-    VECTOR = auto()
-    SYMM_TENSOR = auto()
-    TENSOR = auto()
-
-    @property
-    def shape(self) -> tuple[int, ...]:
-        return {
-            Tensor.SCALAR: (),
-            Tensor.VECTOR: (3,),
-            Tensor.SYMM_TENSOR: (6,),
-            Tensor.TENSOR: (9,),
-        }[self]
-
-    @property
-    def size(self) -> int:
-        return {
-            Tensor.SCALAR: 1,
-            Tensor.VECTOR: 3,
-            Tensor.SYMM_TENSOR: 6,
-            Tensor.TENSOR: 9,
-        }[self]
-
-    def pattern(self, *, ignore: Regex | None = None) -> str:
-        float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
-
-        if self == Tensor.SCALAR:
-            return float_pattern
-
-        ignore_pattern = (
-            rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
-        )
+from ._types import Data, Dimensioned, DimensionSet, File, TensorKind
 
-        return rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{self.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
 
-    def parser(self) -> ParserElement:
-        if self == Tensor.SCALAR:
-            return common.ieee_float
+def _tensor(tensor_kind: TensorKind, *, ignore: Regex | None = None) -> Regex:
+    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
 
-        return (
-            Literal("(").suppress()
-            + Group(common.ieee_float[self.size], aslist=True)
-            + Literal(")").suppress()
-        )
+    if tensor_kind == TensorKind.SCALAR:
+        ret = Regex(float_pattern)
+        ret.add_parse_action(lambda tks: [float(tks[0])])
+        return ret
 
-    def __str__(self) -> str:
-        return {
-            Tensor.SCALAR: "scalar",
-            Tensor.VECTOR: "vector",
-            Tensor.SYMM_TENSOR: "symmTensor",
-            Tensor.TENSOR: "tensor",
-        }[self]
+    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+
+    ret = Regex(
+        rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{tensor_kind.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
+    )
+    ret.add_parse_action(
+        lambda tks: np.fromstring(
+            re.sub(ignore.re, " ", tks[0][1:-1])
+            if ignore is not None
+            else tks[0][1:-1],
+            sep=" ",
+        )
+    )
+    return ret
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -115,61 +83,35 @@ def _list_of(entry: ParserElement) -> ParserElement:
 
 
 def _parse_ascii_field(
-    s: str, tensor_kind: Tensor, *, ignore: Regex | None
-) -> list[float] | list[list[float]]:
-    values = [
-        float(v)
-        for v in (re.sub(ignore.re, " ", s) if ignore is not None else s)
-        .replace("(", " ")
-        .replace(")", " ")
-        .split()
-    ]
-
-    if tensor_kind == Tensor.SCALAR:
-        return values
+    s: str, tensor_kind: TensorKind, *, ignore: Regex | None
+) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64]]:
+    if ignore is not None:
+        s = re.sub(ignore.re, " ", s)
+    s = s.replace("(", " ").replace(")", " ")
 
-    return [
-        values[i : i + tensor_kind.size]
-        for i in range(0, len(values), tensor_kind.size)
-    ]
+    return np.fromstring(s, sep=" ").reshape(-1, *tensor_kind.shape)
 
 
 def _unpack_binary_field(
-    b: bytes, tensor_kind: Tensor, *, length: int
-) -> list[float] | list[list[float]]:
+    b: bytes, tensor_kind: TensorKind, *, length: int
+) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]:
     float_size = len(b) / tensor_kind.size / length
     assert float_size in (4, 8)
 
-    arr = array.array("f" if float_size == 4 else "d", b)
-    values = arr.tolist()
-
-    if tensor_kind == Tensor.SCALAR:
-        return values
-
-    return [
-        values[i : i + tensor_kind.size]
-        for i in range(0, len(values), tensor_kind.size)
-    ]
+    dtype = np.float32 if float_size == 4 else float
+    return np.frombuffer(b, dtype=dtype).reshape(-1, *tensor_kind.shape)
 
 
 def _tensor_list(
-    tensor_kind: Tensor | None = None, *, ignore: Regex | None = None
+    tensor_kind: TensorKind, *, ignore: Regex | None = None
 ) -> ParserElement:
-    if tensor_kind is None:
-        return (
-            _tensor_list(Tensor.SCALAR, ignore=ignore)
-            | _tensor_list(Tensor.VECTOR, ignore=ignore)
-            | _tensor_list(Tensor.SYMM_TENSOR, ignore=ignore)
-            | _tensor_list(Tensor.TENSOR, ignore=ignore)
-        )
-
-    tensor_pattern = tensor_kind.pattern(ignore=ignore)
+    tensor = _tensor(tensor_kind, ignore=ignore)
     ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
 
     list_ = Forward()
 
     list_ <<= Regex(
-        rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern})*{tensor_pattern}(?:{ignore_pattern})?\)"
+        rf"\((?:{ignore_pattern})?(?:{tensor.re.pattern}{ignore_pattern})*{tensor.re.pattern}(?:{ignore_pattern})?\)"
     ).add_parse_action(
         lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
     )
@@ -181,13 +123,13 @@ def _tensor_list(
 
         list_ <<= (
             Regex(
-                rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)"
+                rf"\((?:{ignore_pattern})?(?:{tensor.re.pattern}{ignore_pattern}){{{length - 1}}}{tensor.re.pattern}(?:{ignore_pattern})?\)"
             ).add_parse_action(
                 lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
             )
             | Regex(
                 rf"\((?s:.{{{length * tensor_kind.size * 8}}}|.{{{length * tensor_kind.size * 4}}})\)"
-            ).set_parse_action(
+            ).add_parse_action(
                 lambda tks: [
                     _unpack_binary_field(
                         tks[0][1:-1].encode("latin-1"), tensor_kind, length=length
@@ -195,8 +137,10 @@ def _tensor_list(
                 ]
             )
             | (
-                Literal("{").suppress() + tensor_kind.parser() + Literal("}").suppress()
-            ).set_parse_action(lambda tks: [[tks[0]] * length])
+                Literal("{").suppress() + tensor + Literal("}").suppress()
+            ).add_parse_action(
+                lambda tks: [np.full((length, *tensor_kind.shape), tks[0], dtype=float)]
+            )
         )
 
     count = common.integer.copy().add_parse_action(count_parse_action)
@@ -274,10 +218,10 @@ _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
 ).set_parse_action(lambda tks: DimensionSet(*tks))
 _TENSOR = (
-    Tensor.SCALAR.parser()
-    | Tensor.VECTOR.parser()
-    | Tensor.SYMM_TENSOR.parser()
-    | Tensor.TENSOR.parser()
+    _tensor(TensorKind.SCALAR)
+    | _tensor(TensorKind.VECTOR)
+    | _tensor(TensorKind.SYMM_TENSOR)
+    | _tensor(TensorKind.TENSOR)
 )
 _IDENTIFIER = Combine(
     Word(_IDENTCHARS, _IDENTBODYCHARS, exclude_chars="()")
@@ -287,29 +231,40 @@ _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
-    Keyword("nonuniform", _IDENTBODYCHARS).suppress() + _tensor_list(ignore=_COMMENT)
+    Keyword("nonuniform", _IDENTBODYCHARS).suppress()
+    + (
+        _tensor_list(TensorKind.SCALAR, ignore=_COMMENT)
+        | _tensor_list(TensorKind.VECTOR, ignore=_COMMENT)
+        | _tensor_list(TensorKind.SYMM_TENSOR, ignore=_COMMENT)
+        | _tensor_list(TensorKind.TENSOR, ignore=_COMMENT)
+    )
 )
-TOKEN = dbl_quoted_string | _IDENTIFIER
-DATA = Forward()
-_KEYWORD_ENTRY = _keyword_entry_of(TOKEN | _list_of(_IDENTIFIER), DATA)
-_DICT = _dict_of(TOKEN, DATA)
+_TOKEN = dbl_quoted_string | _IDENTIFIER
+_DATA = Forward()
+_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 = _list_of(_LIST_ENTRY)
 _NUMBER = common.signed_integer ^ common.ieee_float
-_DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | TOKEN
+_DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-DATA <<= (
+_DATA <<= (
     _DATA_ENTRY[1, ...]
     .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
+
+def parse_data(s: str) -> Data:
+    return cast(Data, _DATA.parse_string(s, parse_all=True)[0])
+
+
 _LOCATED_DICTIONARY = Group(
-    _keyword_entry_of(TOKEN, Opt(DATA, default=""), located=True)
+    _keyword_entry_of(_TOKEN, Opt(_DATA, default=""), located=True)
 )[...]
-_LOCATED_DATA = Group(Located(DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
+_LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
 
 _FILE = (
     Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)

{foamlib-0.8.0 → foamlib-0.8.2}/foamlib/_files/_serialization.py

@@ -1,35 +1,27 @@
 from __future__ import annotations
 
-import array
-import itertools
 import sys
 from enum import Enum, auto
-from typing import cast, overload
+from typing import overload
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Mapping
 else:
-    from typing import Mapping, Sequence
+    from typing import Mapping
 
-from ._parsing import DATA, TOKEN
-from ._types import Data, Dimensioned, DimensionSet, Entry
-from ._util import is_sequence
+import numpy as np
 
-try:
-    import numpy as np
-
-    numpy = True
-except ModuleNotFoundError:
-    numpy = False
+from ._parsing import parse_data
+from ._types import Data, Dimensioned, DimensionSet, Entry, is_sequence
 
 
 class Kind(Enum):
     DEFAULT = auto()
-    KEYWORD = auto()
     SINGLE_ENTRY = auto()
     ASCII_FIELD = auto()
-    DOUBLE_PRECISION_BINARY_FIELD = auto()
-    SINGLE_PRECISION_BINARY_FIELD = auto()
+    SCALAR_ASCII_FIELD = auto()
+    BINARY_FIELD = auto()
+    SCALAR_BINARY_FIELD = auto()
     DIMENSIONS = auto()
 
 
@@ -42,9 +34,34 @@ def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
 
 
 def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
-    if numpy and isinstance(data, np.ndarray):
+    if kind in (
+        Kind.ASCII_FIELD,
+        Kind.SCALAR_ASCII_FIELD,
+        Kind.BINARY_FIELD,
+        Kind.SCALAR_BINARY_FIELD,
+    ):
+        if is_sequence(data):
+            try:
+                arr = np.asarray(data)
+            except ValueError:
+                pass
+            else:
+                if not np.issubdtype(arr.dtype, np.floating):
+                    arr = arr.astype(float)
+
+                if arr.ndim == 1 or (arr.ndim == 2 and arr.shape[1] in (3, 6, 9)):
+                    return arr
+
+            return data
+
+        if isinstance(data, int):
+            return float(data)
+
+        return data
+
+    if isinstance(data, np.ndarray):
         ret = data.tolist()
-        assert isinstance(ret, list)
+        assert isinstance(ret, (int, float, list))
         return ret
 
     if isinstance(data, Mapping):
@@ -56,32 +73,21 @@ def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
         and len(data) <= 7
         and all(isinstance(d, (int, float)) for d in data)
     ):
-        data = cast(Sequence[float], data)
         return DimensionSet(*data)
 
     if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
         k, v = data
-        return (normalize(k, kind=Kind.KEYWORD), normalize(v))
+        return (normalize(k), normalize(v))
 
     if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
         return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
 
-    if isinstance(data, Dimensioned):
-        value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
-        assert isinstance(value, (int, float, list))
-        return Dimensioned(value, data.dimensions, data.name)
-
     if isinstance(data, str):
-        if kind == Kind.KEYWORD:
-            data = TOKEN.parse_string(data, parse_all=True)[0]
-            assert isinstance(data, str)
-            return data
-
-        return cast(Data, DATA.parse_string(data, parse_all=True)[0])
+        return parse_data(data)
 
     if isinstance(
         data,
-        (int, float, bool, tuple, DimensionSet),
+        (int, float, bool, tuple, DimensionSet, Dimensioned),
     ):
         return data
 
@@ -105,7 +111,7 @@ def dumps(
 
     if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
         k, v = data
-        ret = dumps(k, kind=Kind.KEYWORD) + b" " + dumps(v)
+        ret = dumps(k) + b" " + dumps(v)
         if not isinstance(v, Mapping):
             ret += b";"
         return ret
@@ -115,56 +121,39 @@ def dumps(
 
     if kind in (
         Kind.ASCII_FIELD,
-        Kind.DOUBLE_PRECISION_BINARY_FIELD,
-        Kind.SINGLE_PRECISION_BINARY_FIELD,
-    ) and (
-        isinstance(data, (int, float))
-        or (
-            is_sequence(data)
-            and data
-            and isinstance(data[0], (int, float))
-            and len(data) in (3, 6, 9)
-        )
-    ):
-        return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
+        Kind.SCALAR_ASCII_FIELD,
+        Kind.BINARY_FIELD,
+        Kind.SCALAR_BINARY_FIELD,
+    ) and (isinstance(data, (int, float, np.ndarray))):
+        shape = np.shape(data)
+        if not shape or (
+            kind not in (Kind.SCALAR_ASCII_FIELD, Kind.SCALAR_BINARY_FIELD)
+            and shape in ((3,), (6,), (9,))
+        ):
+            return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
 
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.DOUBLE_PRECISION_BINARY_FIELD,
-        Kind.SINGLE_PRECISION_BINARY_FIELD,
-    ) and is_sequence(data):
-        if data and isinstance(data[0], (int, float)):
+        assert isinstance(data, np.ndarray)
+        ndim = len(shape)
+        if ndim == 1:
             tensor_kind = b"scalar"
-        elif is_sequence(data[0]) and data[0] and isinstance(data[0][0], (int, float)):
-            if len(data[0]) == 3:
+
+        elif ndim == 2:
+            if shape[1] == 3:
                 tensor_kind = b"vector"
-            elif len(data[0]) == 6:
+            elif shape[1] == 6:
                 tensor_kind = b"symmTensor"
-            elif len(data[0]) == 9:
+            elif shape[1] == 9:
                 tensor_kind = b"tensor"
             else:
                 return dumps(data)
+
         else:
             return dumps(data)
 
-        if kind in (
-            Kind.DOUBLE_PRECISION_BINARY_FIELD,
-            Kind.SINGLE_PRECISION_BINARY_FIELD,
-        ):
-            typecode = "f" if kind == Kind.SINGLE_PRECISION_BINARY_FIELD else "d"
-            if tensor_kind == b"scalar":
-                data = cast(Sequence[float], data)
-                contents = b"(" + array.array(typecode, data).tobytes() + b")"
-            else:
-                data = cast(Sequence[Sequence[float]], data)
-                contents = (
-                    b"("
-                    + array.array(
-                        typecode, itertools.chain.from_iterable(data)
-                    ).tobytes()
-                    + b")"
-                )
+        if kind in (Kind.BINARY_FIELD, Kind.SCALAR_BINARY_FIELD):
+            contents = b"(" + data.tobytes() + b")"
         else:
+            assert kind in (Kind.ASCII_FIELD, Kind.SCALAR_ASCII_FIELD)
             contents = dumps(data, kind=Kind.SINGLE_ENTRY)
 
         return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents