foamlib 0.2.4__tar.gz → 0.2.6__tar.gz

{foamlib-0.2.4 → foamlib-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.4
+Version: 0.2.6
 Summary: A Python interface for interacting with OpenFOAM
 Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib
@@ -27,15 +27,14 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aioshutil<2,>=1
 Requires-Dist: pyparsing<4,>=3
-Requires-Dist: typing-extensions<5,>=4
+Requires-Dist: typing-extensions<5,>=4; python_version < "3.11"
 Provides-Extra: lint
-Requires-Dist: mypy<2,>=1; extra == "lint"
-Requires-Dist: pytest<9,>=7; extra == "lint"
-Requires-Dist: pytest-asyncio<0.24,>=0.21; extra == "lint"
-Requires-Dist: numpy<2,>=1; extra == "lint"
-Requires-Dist: black; extra == "lint"
-Requires-Dist: flake8; extra == "lint"
-Requires-Dist: Flake8-pyproject; extra == "lint"
+Requires-Dist: ruff; extra == "lint"
+Provides-Extra: typing
+Requires-Dist: mypy<2,>=1; extra == "typing"
+Requires-Dist: pytest<9,>=7; extra == "typing"
+Requires-Dist: pytest-asyncio<0.24,>=0.21; extra == "typing"
+Requires-Dist: numpy<2,>=1; extra == "typing"
 Provides-Extra: test
 Requires-Dist: pytest<9,>=7; extra == "test"
 Requires-Dist: pytest-asyncio<0.24,>=0.21; extra == "test"
@@ -52,7 +51,7 @@ Requires-Dist: numpy<2,>=1; extra == "docs"
 [![CI](https://github.com/gerlero/foamlib/actions/workflows/ci.yml/badge.svg)](https://github.com/gerlero/foamlib/actions/workflows/ci.yml)
 [![Codecov](https://codecov.io/gh/gerlero/foamlib/branch/main/graph/badge.svg)](https://codecov.io/gh/gerlero/foamlib)
 [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![PyPI](https://img.shields.io/pypi/v/foamlib)](https://pypi.org/project/foamlib/)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/foamlib)](https://pypi.org/project/foamlib/)
 [![Docker image](https://img.shields.io/badge/docker%20image-gerlero%2Ffoamlib-informational)](https://hub.docker.com/r/gerlero/foamlib/)

{foamlib-0.2.4 → foamlib-0.2.6}/README.md

@@ -4,7 +4,7 @@
 [![CI](https://github.com/gerlero/foamlib/actions/workflows/ci.yml/badge.svg)](https://github.com/gerlero/foamlib/actions/workflows/ci.yml)
 [![Codecov](https://codecov.io/gh/gerlero/foamlib/branch/main/graph/badge.svg)](https://codecov.io/gh/gerlero/foamlib)
 [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![PyPI](https://img.shields.io/pypi/v/foamlib)](https://pypi.org/project/foamlib/)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/foamlib)](https://pypi.org/project/foamlib/)
 [![Docker image](https://img.shields.io/badge/docker%20image-gerlero%2Ffoamlib-informational)](https://hub.docker.com/r/gerlero/foamlib/)

foamlib-0.2.6/foamlib/__init__.py

@@ -0,0 +1,15 @@
+"""A Python interface for interacting with OpenFOAM."""
+
+__version__ = "0.2.6"
+
+from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
+from ._dictionaries import FoamDictionaryBase, FoamFieldFile, FoamFile
+
+__all__ = [
+    "FoamCase",
+    "AsyncFoamCase",
+    "FoamCaseBase",
+    "FoamFile",
+    "FoamFieldFile",
+    "FoamDictionaryBase",
+]

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_cases.py

@@ -1,27 +1,34 @@
-import os
 import asyncio
 import multiprocessing
+import os
 import shutil
-
-from pathlib import Path
+import sys
 from contextlib import asynccontextmanager
+from pathlib import Path
 from typing import (
     Optional,
     Union,
-    Collection,
-    Mapping,
-    Set,
-    Sequence,
-    AsyncGenerator,
-    Callable,
-    Iterator,
     overload,
 )
 
+if sys.version_info >= (3, 9):
+    from collections.abc import (
+        AsyncGenerator,
+        Callable,
+        Collection,
+        Iterator,
+        Mapping,
+        Sequence,
+        Set,
+    )
+else:
+    from typing import AbstractSet as Set
+    from typing import AsyncGenerator, Callable, Collection, Iterator, Mapping, Sequence
+
 import aioshutil
 
-from ._subprocesses import run_process, run_process_async, CalledProcessError
-from ._dictionaries import FoamFile, FoamFieldFile
+from ._dictionaries import FoamFieldFile, FoamFile
+from ._util import CalledProcessError, is_sequence, run_process, run_process_async
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
@@ -46,16 +53,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
         @property
         def time(self) -> float:
-            """
-            The time that corresponds to this directory.
-            """
+            """The time that corresponds to this directory."""
             return float(self.path.name)
 
         @property
         def name(self) -> str:
-            """
-            The name of this time directory.
-            """
+            """The name of this time directory."""
             return self.path.name
 
         def __getitem__(self, key: str) -> FoamFieldFile:
@@ -132,7 +135,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         has_decompose_par_dict = (self.path / "system" / "decomposeParDict").is_file()
         has_block_mesh_dict = (self.path / "system" / "blockMeshDict").is_file()
 
-        paths: Set[Path] = set()
+        paths = set()
 
         for p in self.path.iterdir():
             if p.is_dir():
@@ -164,9 +167,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         return ignore
 
     def _clean_script(self) -> Optional[Path]:
-        """
-        Return the path to the (All)clean script, or None if no clean script is found.
-        """
+        """Return the path to the (All)clean script, or None if no clean script is found."""
         clean = self.path / "clean"
         all_clean = self.path / "Allclean"
 
@@ -178,9 +179,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return None
 
     def _run_script(self, *, parallel: Optional[bool]) -> Optional[Path]:
-        """
-        Return the path to the (All)run script, or None if no run script is found.
-        """
+        """Return the path to the (All)run script, or None if no run script is found."""
         run = self.path / "run"
         run_parallel = self.path / "run-parallel"
         all_run = self.path / "Allrun"
@@ -205,9 +204,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return None
 
     def _env(self) -> Mapping[str, str]:
-        """
-        Return the environment variables for this case.
-        """
+        """Return the environment variables for this case."""
         env = os.environ.copy()
         env["PWD"] = str(self.path)
         return env
@@ -215,7 +212,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
     def _parallel_cmd(
         self, cmd: Union[Sequence[Union[str, Path]], str, Path]
     ) -> Union[Sequence[Union[str, Path]], str]:
-        if isinstance(cmd, str) or not isinstance(cmd, Sequence):
+        if not is_sequence(cmd):
             return f"mpiexec -np {self._nprocessors} {cmd} -parallel"
         else:
             return [
@@ -229,22 +226,16 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def name(self) -> str:
-        """
-        The name of the case.
-        """
+        """The name of the case."""
         return self.path.name
 
     def file(self, path: Union[Path, str]) -> FoamFile:
-        """
-        Return a FoamFile object for the given path in the case.
-        """
+        """Return a FoamFile object for the given path in the case."""
         return FoamFile(self.path / path)
 
     @property
     def _nsubdomains(self) -> Optional[int]:
-        """
-        Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found.
-        """
+        """Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found."""
         try:
             nsubdomains = self.decompose_par_dict["numberOfSubdomains"]
             if not isinstance(nsubdomains, int):
@@ -257,16 +248,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def _nprocessors(self) -> int:
-        """
-        Return the number of processor directories in the case.
-        """
+        """Return the number of processor directories in the case."""
         return len(list(self.path.glob("processor*")))
 
     @property
     def application(self) -> str:
-        """
-        The application name as set in the controlDict.
-        """
+        """The application name as set in the controlDict."""
         application = self.control_dict["application"]
         if not isinstance(application, str):
             raise TypeError(f"application in {self.control_dict} is not a string")
@@ -274,51 +261,37 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def control_dict(self) -> FoamFile:
-        """
-        The controlDict file.
-        """
+        """The controlDict file."""
         return self.file("system/controlDict")
 
     @property
     def fv_schemes(self) -> FoamFile:
-        """
-        The fvSchemes file.
-        """
+        """The fvSchemes file."""
         return self.file("system/fvSchemes")
 
     @property
     def fv_solution(self) -> FoamFile:
-        """
-        The fvSolution file.
-        """
+        """The fvSolution file."""
         return self.file("system/fvSolution")
 
     @property
     def decompose_par_dict(self) -> FoamFile:
-        """
-        The decomposeParDict file.
-        """
+        """The decomposeParDict file."""
         return self.file("system/decomposeParDict")
 
     @property
     def block_mesh_dict(self) -> FoamFile:
-        """
-        The blockMeshDict file.
-        """
+        """The blockMeshDict file."""
         return self.file("system/blockMeshDict")
 
     @property
     def transport_properties(self) -> FoamFile:
-        """
-        The transportProperties file.
-        """
+        """The transportProperties file."""
         return self.file("constant/transportProperties")
 
     @property
     def turbulence_properties(self) -> FoamFile:
-        """
-        The turbulenceProperties file.
-        """
+        """The turbulenceProperties file."""
         return self.file("constant/turbulenceProperties")
 
     def __fspath__(self) -> str:
@@ -391,7 +364,7 @@ class FoamCase(FoamCaseBase):
                 )
             except CalledProcessError as e:
                 raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
+                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
                 ) from None
 
         else:
@@ -424,21 +397,15 @@ class FoamCase(FoamCaseBase):
                 )
 
     def block_mesh(self, *, check: bool = True) -> None:
-        """
-        Run blockMesh on this case.
-        """
+        """Run blockMesh on this case."""
         self.run(["blockMesh"], check=check)
 
     def decompose_par(self, *, check: bool = True) -> None:
-        """
-        Decompose this case for parallel running.
-        """
+        """Decompose this case for parallel running."""
         self.run(["decomposePar"], check=check)
 
     def reconstruct_par(self, *, check: bool = True) -> None:
-        """
-        Reconstruct this case after parallel running.
-        """
+        """Reconstruct this case after parallel running."""
         self.run(["reconstructPar"], check=check)
 
     def copy(self, dest: Union[Path, str]) -> "FoamCase":
@@ -566,7 +533,7 @@ class AsyncFoamCase(FoamCaseBase):
                     )
             except CalledProcessError as e:
                 raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
+                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
                 ) from None
 
         else:
@@ -616,21 +583,15 @@ class AsyncFoamCase(FoamCaseBase):
                 )
 
     async def block_mesh(self, *, check: bool = True) -> None:
-        """
-        Run blockMesh on this case.
-        """
+        """Run blockMesh on this case."""
         await self.run(["blockMesh"], check=check)
 
     async def decompose_par(self, *, check: bool = True) -> None:
-        """
-        Decompose this case for parallel running.
-        """
+        """Decompose this case for parallel running."""
         await self.run(["decomposePar"], check=check)
 
     async def reconstruct_par(self, *, check: bool = True) -> None:
-        """
-        Reconstruct this case after parallel running.
-        """
+        """Reconstruct this case after parallel running."""
         await self.run(["reconstructPar"], check=check)
 
     async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_dictionaries/__init__.py

@@ -1,5 +1,5 @@
-from ._files import FoamFile, FoamFieldFile
 from ._base import FoamDictionaryBase
+from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
     "FoamFile",

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_dictionaries/_base.py

@@ -1,6 +1,12 @@
+import sys
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Dict, NamedTuple, Optional, Sequence, Union
+from typing import Dict, NamedTuple, Optional, Union
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Sequence
+else:
+    from typing import Sequence
 
 
 class FoamDictionaryBase:
@@ -37,7 +43,5 @@ class FoamDictionaryBase:
 
     @abstractmethod
     def as_dict(self) -> _Dict:
-        """
-        Return a nested dict representation of the dictionary.
-        """
+        """Return a nested dict representation of the dictionary."""
         raise NotImplementedError

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_dictionaries/_files.py

@@ -1,21 +1,22 @@
+import sys
 from pathlib import Path
 from typing import (
     Any,
-    Iterator,
-    Mapping,
-    MutableMapping,
     Optional,
-    Sequence,
     Tuple,
     Union,
     cast,
 )
 
-from typing_extensions import Self
+if sys.version_info >= (3, 9):
+    from collections.abc import Iterator, Mapping, MutableMapping, Sequence
+else:
+    from typing import Iterator, Mapping, MutableMapping, Sequence
 
-from ._base import FoamDictionaryBase
-from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
-from ._serialization import serialize_entry
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
 
 try:
     import numpy as np
@@ -23,6 +24,10 @@ try:
 except ModuleNotFoundError:
     pass
 
+from ._base import FoamDictionaryBase
+from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
+from ._serialization import serialize_entry
+
 
 class _FoamFileBase:
     def __init__(self, path: Union[str, Path]) -> None:
@@ -93,9 +98,7 @@ class FoamFile(
         FoamDictionaryBase,
         MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
     ):
-        """
-        An OpenFOAM dictionary within a file as a mutable mapping.
-        """
+        """An OpenFOAM dictionary within a file as a mutable mapping."""
 
         def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
             self._file = _file
@@ -148,9 +151,7 @@ class FoamFile(
             return f"{type(self).__qualname__}({self._file}, {self._keywords})"
 
         def as_dict(self) -> FoamDictionaryBase._Dict:
-            """
-            Return a nested dict representation of the dictionary.
-            """
+            """Return a nested dict representation of the dictionary."""
             ret = self._file.as_dict()
 
             for k in self._keywords:
@@ -258,9 +259,7 @@ class FoamFile(
         return f"{type(self).__name__}({self.path})"
 
     def as_dict(self) -> FoamDictionaryBase._Dict:
-        """
-        Return a nested dict representation of the file.
-        """
+        """Return a nested dict representation of the file."""
         _, parsed = self._read()
         return as_dict(parsed)
 
@@ -283,9 +282,7 @@ class FoamFieldFile(FoamFile):
 
         @property
         def type(self) -> str:
-            """
-            Alias of `self["type"]`.
-            """
+            """Alias of `self["type"]`."""
             ret = self["type"]
             if not isinstance(ret, str):
                 raise TypeError("type is not a string")
@@ -304,9 +301,7 @@ class FoamFieldFile(FoamFile):
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
             "NDArray[np.generic]",
         ]:
-            """
-            Alias of `self["value"]`.
-            """
+            """Alias of `self["value"]`."""
             ret = self["value"]
             if not isinstance(ret, (int, float, Sequence)):
                 raise TypeError("value is not a field")
@@ -355,9 +350,7 @@ class FoamFieldFile(FoamFile):
 
     @property
     def dimensions(self) -> FoamFile.DimensionSet:
-        """
-        Alias of `self["dimensions"]`.
-        """
+        """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):
             raise TypeError("dimensions is not a DimensionSet")
@@ -378,9 +371,7 @@ class FoamFieldFile(FoamFile):
         Sequence[Union[int, float, Sequence[Union[int, float]]]],
         "NDArray[np.generic]",
     ]:
-        """
-        Alias of `self["internalField"]`.
-        """
+        """Alias of `self["internalField"]`."""
         ret = self["internalField"]
         if not isinstance(ret, (int, float, Sequence)):
             raise TypeError("internalField is not a field")
@@ -400,9 +391,7 @@ class FoamFieldFile(FoamFile):
 
     @property
     def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
-        """
-        Alias of `self["boundaryField"]`.
-        """
+        """Alias of `self["boundaryField"]`."""
         ret = self["boundaryField"]
         if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
             assert not isinstance(ret, FoamFile.Dictionary)

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_dictionaries/_parsing.py

@@ -1,4 +1,10 @@
-from typing import Mapping, MutableMapping, Optional, Sequence, Tuple
+import sys
+from typing import Optional, Tuple
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, MutableMapping, Sequence
+else:
+    from typing import Mapping, MutableMapping, Sequence
 
 from pyparsing import (
     Dict,
@@ -9,8 +15,8 @@ from pyparsing import (
     Literal,
     Located,
     Opt,
-    ParseResults,
     ParserElement,
+    ParseResults,
     QuotedString,
     Word,
     c_style_comment,
@@ -22,8 +28,11 @@ from pyparsing import (
 
 from ._base import FoamDictionaryBase
 
-_YES = Keyword("yes").set_parse_action(lambda: True)
-_NO = Keyword("no").set_parse_action(lambda: False)
+_SWITCH = (
+    Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
+).set_parse_action(lambda: True) | (
+    Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
+).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
 ).set_parse_action(lambda tks: FoamDictionaryBase.DimensionSet(*tks))
@@ -58,9 +67,7 @@ _FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _ITEM = Forward()
 _LIST = _list_of(_ITEM)
-_ITEM <<= (
-    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _YES | _NO | _TOKEN
-)
+_ITEM <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
 _TOKENS = (
     QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
 )[2, ...].set_parse_action(lambda tks: " ".join(tks))
@@ -124,9 +131,7 @@ def get_value(
     parsed: Parsed,
     keywords: Tuple[str, ...],
 ) -> Optional[FoamDictionaryBase.Value]:
-    """
-    Value of an entry.
-    """
+    """Value of an entry."""
     _, value, _ = parsed[keywords]
     return value
 
@@ -137,9 +142,7 @@ def get_entry_locn(
     *,
     missing_ok: bool = False,
 ) -> Tuple[int, int]:
-    """
-    Location of an entry or where it should be inserted.
-    """
+    """Location of an entry or where it should be inserted."""
     try:
         start, _, end = parsed[keywords]
     except KeyError:
@@ -158,12 +161,9 @@ def get_entry_locn(
 
 
 def as_dict(parsed: Parsed) -> FoamDictionaryBase._Dict:
-    """
-    Return a nested dict representation of the file.
-    """
+    """Return a nested dict representation of the file."""
     ret: FoamDictionaryBase._Dict = {}
     for keywords, (_, value, _) in parsed.items():
-
         r = ret
         for k in keywords[:-1]:
             assert isinstance(r, dict)

{foamlib-0.2.4 → foamlib-0.2.6}/foamlib/_dictionaries/_serialization.py

@@ -1,26 +1,17 @@
+import sys
 from contextlib import suppress
-from typing import Any, Mapping, Sequence
+from typing import Any
 
-from ._base import FoamDictionaryBase
-
-try:
-    import numpy as np
-except ModuleNotFoundError:
-    numpy = False
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping
 else:
-    numpy = True
+    from typing import Mapping
 
-
-def _is_sequence(value: Any) -> bool:
-    return (
-        isinstance(value, Sequence)
-        and not isinstance(value, str)
-        or numpy
-        and isinstance(value, np.ndarray)
-    )
+from .._util import is_sequence
+from ._base import FoamDictionaryBase
 
 
-def _serialize_bool(value: Any) -> str:
+def _serialize_switch(value: Any) -> str:
     if value is True:
         return "yes"
     elif value is False:
@@ -30,23 +21,23 @@ def _serialize_bool(value: Any) -> str:
 
 
 def _serialize_list(value: Any) -> str:
-    if _is_sequence(value):
+    if is_sequence(value):
         return f"({' '.join(_serialize_value(v) for v in value)})"
     else:
         raise TypeError(f"Not a valid sequence: {type(value)}")
 
 
 def _serialize_field(value: Any) -> str:
-    if _is_sequence(value):
+    if is_sequence(value):
         try:
             s = _serialize_list(value)
         except TypeError:
             raise TypeError(f"Not a valid field: {type(value)}") from None
         else:
-            if len(value) < 10:
+            if not is_sequence(value[0]) and len(value) < 10:
                 return f"uniform {s}"
             else:
-                if isinstance(value[0], (int, float)):
+                if not is_sequence(value[0]):
                     kind = "scalar"
                 elif len(value[0]) == 3:
                     kind = "vector"
@@ -64,7 +55,7 @@ def _serialize_field(value: Any) -> str:
 
 
 def _serialize_dimensions(value: Any) -> str:
-    if _is_sequence(value) and len(value) == 7:
+    if is_sequence(value) and len(value) == 7:
         return f"[{' '.join(str(v) for v in value)}]"
     else:
         raise TypeError(f"Not a valid dimension set: {type(value)}")
@@ -98,7 +89,7 @@ def _serialize_value(
         return _serialize_list(value)
 
     with suppress(TypeError):
-        return _serialize_bool(value)
+        return _serialize_switch(value)
 
     return str(value)