foamlib 0.6.11__py3-none-any.whl → 0.6.13__py3-none-any.whl

foamlib/_cases/_sync.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import shutil
 import sys
-from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import Collection, Sequence
@@ -13,7 +14,6 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-from .._files import FoamFieldFile
 from ._base import FoamCaseBase
 from ._run import FoamCaseRunBase
 from ._subprocess import run_sync
@@ -21,6 +21,9 @@ from ._util import ValuedGenerator
 
 if TYPE_CHECKING:
     import os
+    from types import TracebackType
+
+    from .._files import FoamFieldFile
 
 
 class FoamCase(FoamCaseRunBase):
@@ -36,7 +39,7 @@ class FoamCase(FoamCaseRunBase):
 
     class TimeDirectory(FoamCaseRunBase.TimeDirectory):
         @property
-        def _case(self) -> "FoamCase":
+        def _case(self) -> FoamCase:
             return FoamCase(self.path.parent)
 
         def cell_centers(self) -> FoamFieldFile:
@@ -50,7 +53,7 @@ class FoamCase(FoamCaseRunBase):
 
     @staticmethod
     def _run(
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        cmd: Sequence[str | os.PathLike[str]] | str,
         *,
         cpus: int,
         **kwargs: Any,
@@ -58,34 +61,29 @@ class FoamCase(FoamCaseRunBase):
         run_sync(cmd, **kwargs)
 
     @staticmethod
-    def _rmtree(
-        path: Union["os.PathLike[str]", str], *, ignore_errors: bool = False
-    ) -> None:
+    def _rmtree(path: os.PathLike[str] | str, *, ignore_errors: bool = False) -> None:
         shutil.rmtree(path, ignore_errors=ignore_errors)
 
     @staticmethod
     def _copytree(
-        src: Union["os.PathLike[str]", str],
-        dest: Union["os.PathLike[str]", str],
+        src: os.PathLike[str] | str,
+        dest: os.PathLike[str] | str,
         *,
         symlinks: bool = False,
-        ignore: Optional[
-            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
-        ] = None,
+        ignore: Callable[[os.PathLike[str] | str, Collection[str]], Collection[str]]
+        | None = None,
     ) -> None:
         shutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
 
     @overload
-    def __getitem__(
-        self, index: Union[int, float, str]
-    ) -> "FoamCase.TimeDirectory": ...
+    def __getitem__(self, index: int | float | str) -> FoamCase.TimeDirectory: ...
 
     @overload
-    def __getitem__(self, index: slice) -> Sequence["FoamCase.TimeDirectory"]: ...
+    def __getitem__(self, index: slice) -> Sequence[FoamCase.TimeDirectory]: ...
 
     def __getitem__(
-        self, index: Union[int, slice, float, str]
-    ) -> Union["FoamCase.TimeDirectory", Sequence["FoamCase.TimeDirectory"]]:
+        self, index: int | slice | float | str
+    ) -> FoamCase.TimeDirectory | Sequence[FoamCase.TimeDirectory]:
         ret = super().__getitem__(index)
         if isinstance(ret, FoamCaseBase.TimeDirectory):
             return FoamCase.TimeDirectory(ret)
@@ -96,9 +94,9 @@ class FoamCase(FoamCaseRunBase):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self._rmtree(self.path)
 
@@ -117,10 +115,10 @@ class FoamCase(FoamCaseRunBase):
 
     def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        cmd: Sequence[str | os.PathLike[str]] | str | None = None,
         *,
-        parallel: Optional[bool] = None,
-        cpus: Optional[int] = None,
+        parallel: bool | None = None,
+        cpus: int | None = None,
         check: bool = True,
         log: bool = True,
     ) -> None:
@@ -158,7 +156,7 @@ class FoamCase(FoamCaseRunBase):
         for _ in self._restore_0_dir_calls():
             pass
 
-    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
+    def copy(self, dst: os.PathLike[str] | str | None = None) -> Self:
         """
         Make a copy of this case.
 
@@ -173,7 +171,7 @@ class FoamCase(FoamCaseRunBase):
 
         return calls.value
 
-    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
+    def clone(self, dst: os.PathLike[str] | str | None = None) -> Self:
         """
         Clone this case (make a clean copy).
 

foamlib/_cases/_util.py

@@ -1,16 +1,19 @@
+from __future__ import annotations
+
 import functools
 import sys
-from types import TracebackType
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncContextManager,
     Callable,
     Generic,
-    Optional,
-    Type,
     TypeVar,
 )
 
+if TYPE_CHECKING:
+    from types import TracebackType
+
 if sys.version_info >= (3, 9):
     from collections.abc import Generator
 else:
@@ -23,7 +26,7 @@ R = TypeVar("R")
 
 
 class ValuedGenerator(Generic[Y, S, R]):
-    def __init__(self, generator: Generator[Y, S, R]):
+    def __init__(self, generator: Generator[Y, S, R]) -> None:
         self._generator = generator
 
     def __iter__(self) -> Generator[Y, S, R]:
@@ -32,7 +35,7 @@ class ValuedGenerator(Generic[Y, S, R]):
 
 
 class _AwaitableAsyncContextManager(Generic[R]):
-    def __init__(self, cm: "AsyncContextManager[R]"):
+    def __init__(self, cm: AsyncContextManager[R]) -> None:
         self._cm = cm
 
     def __await__(self) -> Generator[Any, Any, R]:
@@ -43,15 +46,15 @@ class _AwaitableAsyncContextManager(Generic[R]):
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         return await self._cm.__aexit__(exc_type, exc_val, exc_tb)
 
 
 def awaitableasynccontextmanager(
-    cm: Callable[..., "AsyncContextManager[R]"],
+    cm: Callable[..., AsyncContextManager[R]],
 ) -> Callable[..., _AwaitableAsyncContextManager[R]]:
     @functools.wraps(cm)
     def f(*args: Any, **kwargs: Any) -> _AwaitableAsyncContextManager[R]:

foamlib/_files/_base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import sys
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Tuple, Union
@@ -33,9 +35,9 @@ class FoamFileBase:
 
     @dataclass
     class Dimensioned:
-        value: "FoamFileBase._Tensor" = 0
-        dimensions: Union["FoamFileBase.DimensionSet", Sequence[float]] = ()
-        name: Optional[str] = None
+        value: FoamFileBase._Tensor = 0
+        dimensions: FoamFileBase.DimensionSet | Sequence[float] = ()
+        name: str | None = None
 
         def __post_init__(self) -> None:
             if not isinstance(self.dimensions, FoamFileBase.DimensionSet):

foamlib/_files/_files.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import os
 import sys
 from copy import deepcopy
 from typing import Any, Optional, Tuple, Union, cast
@@ -14,7 +17,7 @@ else:
 
 from ._base import FoamFileBase
 from ._io import FoamFileIO
-from ._serialization import Kind, dumps
+from ._serialization import Kind, dumps, normalize
 from ._util import is_sequence
 
 
@@ -39,13 +42,13 @@ class FoamFile(
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
 
-        def __init__(self, _file: "FoamFile", _keywords: Tuple[str, ...]) -> None:
+        def __init__(self, _file: FoamFile, _keywords: tuple[str, ...]) -> None:
             self._file = _file
             self._keywords = _keywords
 
         def __getitem__(
             self, keyword: str
-        ) -> Union[FoamFileBase._DataEntry, "FoamFile.SubDict"]:
+        ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
             return self._file[(*self._keywords, keyword)]
 
         def __setitem__(
@@ -97,7 +100,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "version"]`."""
         ret = self["FoamFile", "version"]
         if not isinstance(ret, (int, float)):
-            raise TypeError("version is not a number")
+            msg = "version is not a number"
+            raise TypeError(msg)
         return ret
 
     @version.setter
@@ -109,9 +113,11 @@ class FoamFile(
         """Alias of `self["FoamFile", "format"]`."""
         ret = self["FoamFile", "format"]
         if not isinstance(ret, str):
-            raise TypeError("format is not a string")
+            msg = "format is not a string"
+            raise TypeError(msg)
         if ret not in ("ascii", "binary"):
-            raise ValueError("format is not 'ascii' or 'binary'")
+            msg = "format is not 'ascii' or 'binary'"
+            raise ValueError(msg)
         return cast(Literal["ascii", "binary"], ret)
 
     @format.setter
@@ -123,7 +129,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "class"]`."""
         ret = self["FoamFile", "class"]
         if not isinstance(ret, str):
-            raise TypeError("class is not a string")
+            msg = "class is not a string"
+            raise TypeError(msg)
         return ret
 
     @class_.setter
@@ -135,7 +142,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "location"]`."""
         ret = self["FoamFile", "location"]
         if not isinstance(ret, str):
-            raise TypeError("location is not a string")
+            msg = "location is not a string"
+            raise TypeError(msg)
         return ret
 
     @location.setter
@@ -147,7 +155,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "object"]`."""
         ret = self["FoamFile", "object"]
         if not isinstance(ret, str):
-            raise TypeError("object is not a string")
+            msg = "object is not a string"
+            raise TypeError(msg)
         return ret
 
     @object_.setter
@@ -155,8 +164,8 @@ class FoamFile(
         self["FoamFile", "object"] = value
 
     def __getitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union[FoamFileBase._DataEntry, "FoamFile.SubDict"]:
+        self, keywords: str | tuple[str, ...] | None
+    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -173,14 +182,14 @@ class FoamFile(
         return deepcopy(value)
 
     def __setitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]], data: FoamFileBase.Data
+        self, keywords: str | tuple[str, ...] | None, data: FoamFileBase.Data
     ) -> None:
-        with self:
-            if not keywords:
-                keywords = ()
-            elif not isinstance(keywords, tuple):
-                keywords = (keywords,)
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
+            keywords = (keywords,)
 
+        with self:
             try:
                 write_header = (
                     not self and "FoamFile" not in self and keywords != ("FoamFile",)
@@ -208,92 +217,115 @@ class FoamFile(
                     or keywords[2].endswith("Gradient")
                 )
             ):
-                kind = Kind.BINARY_FIELD if self.format == "binary" else Kind.FIELD
+                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
             elif keywords == ("dimensions",):
                 kind = Kind.DIMENSIONS
 
             if (
-                kind == Kind.FIELD or kind == Kind.BINARY_FIELD
+                kind
+                in (
+                    Kind.ASCII_FIELD,
+                    Kind.DOUBLE_PRECISION_BINARY_FIELD,
+                    Kind.SINGLE_PRECISION_BINARY_FIELD,
+                )
             ) and self.class_ == "dictionary":
-                if not is_sequence(data):
-                    class_ = "volScalarField"
-                elif (len(data) == 3 and not is_sequence(data[0])) or len(data[0]) == 3:
-                    class_ = "volVectorField"
-                elif (len(data) == 6 and not is_sequence(data[0])) or len(data[0]) == 6:
-                    class_ = "volSymmTensorField"
-                elif (len(data) == 9 and not is_sequence(data[0])) or len(data[0]) == 9:
-                    class_ = "volTensorField"
+                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:
+                            self.class_ = "volVectorField"
+                        elif len(data[0]) == 6:
+                            self.class_ = "volSymmTensorField"
+                        elif len(data[0]) == 9:
+                            self.class_ = "volTensorField"
+
+            parsed = self._get_parsed(missing_ok=True)
+
+            start, end = parsed.entry_location(keywords, missing_ok=True)
+
+            if start and not parsed.contents[:start].endswith(b"\n\n"):
+                if parsed.contents[:start].endswith(b"\n"):
+                    before = b"\n" if len(keywords) <= 1 else b""
                 else:
-                    class_ = "volScalarField"
-
-                self.class_ = class_
-                self[keywords] = data
-
+                    before = b"\n\n" if len(keywords) <= 1 else b"\n"
             else:
-                parsed = self._get_parsed(missing_ok=True)
-
-                start, end = parsed.entry_location(keywords, missing_ok=True)
-
                 before = b""
-                if parsed.contents[:start] and not parsed.contents[:start].endswith(
-                    b"\n"
-                ):
-                    before = b"\n"
-                if (
-                    parsed.contents[:start]
-                    and len(keywords) <= 1
-                    and not parsed.contents[:start].endswith(b"\n\n")
-                ):
-                    before = b"\n\n"
 
+            if not parsed.contents[end:].strip() or parsed.contents[end:].startswith(
+                b"}"
+            ):
+                after = b"\n" + b"    " * (len(keywords) - 2)
+            else:
                 after = b""
-                if parsed.contents[end:].startswith(b"}"):
-                    after = b"    " * (len(keywords) - 2)
-                if not parsed.contents[end:] or not parsed.contents[end:].startswith(
-                    b"\n"
-                ):
-                    after = b"\n" + after
-
-                indentation = b"    " * (len(keywords) - 1)
-
-                if isinstance(data, Mapping):
-                    if isinstance(data, (FoamFile, FoamFile.SubDict)):
-                        data = data.as_dict()
-
-                    parsed.put(
-                        keywords,
-                        ...,
-                        before
-                        + indentation
-                        + dumps(keywords[-1])
-                        + b"\n"
-                        + indentation
-                        + b"{\n"
-                        + indentation
-                        + b"}"
-                        + after,
-                    )
-
-                    for k, v in data.items():
-                        self[(*keywords, k)] = v
-
-                elif keywords:
-                    parsed.put(
-                        keywords,
-                        data,
-                        before
-                        + indentation
-                        + dumps(keywords[-1])
-                        + b" "
-                        + dumps(data, kind=kind)
-                        + b";"
-                        + after,
-                    )
 
-                else:
-                    parsed.put(keywords, data, before + dumps(data, kind=kind) + after)
+            indentation = b"    " * (len(keywords) - 1)
+
+            if isinstance(data, Mapping):
+                if isinstance(data, (FoamFile, FoamFile.SubDict)):
+                    data = data.as_dict()
+
+                parsed.put(
+                    keywords,
+                    ...,
+                    before
+                    + indentation
+                    + dumps(keywords[-1])
+                    + b"\n"
+                    + indentation
+                    + b"{\n"
+                    + indentation
+                    + b"}"
+                    + after,
+                )
+
+                for k, v in data.items():
+                    self[(*keywords, k)] = v
+
+            elif keywords:
+                parsed.put(
+                    keywords,
+                    normalize(data, kind=kind),
+                    before
+                    + indentation
+                    + dumps(keywords[-1])
+                    + b" "
+                    + dumps(data, kind=kind)
+                    + b";"
+                    + after,
+                )
+
+            else:
+                parsed.put(
+                    (),
+                    normalize(data, kind=kind),
+                    before + dumps(data, kind=kind) + after,
+                )
 
-    def __delitem__(self, keywords: Optional[Union[str, Tuple[str, ...]]]) -> None:
+    def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -302,12 +334,12 @@ class FoamFile(
         with self:
             del self._get_parsed()[keywords]
 
-    def _iter(self, keywords: Tuple[str, ...] = ()) -> Iterator[Optional[str]]:
+    def _iter(self, keywords: tuple[str, ...] = ()) -> Iterator[str | None]:
         yield from (
             k[-1] if k else None for k in self._get_parsed() if k[:-1] == keywords
         )
 
-    def __iter__(self) -> Iterator[Optional[str]]:
+    def __iter__(self) -> Iterator[str | None]:
         yield from (k for k in self._iter() if k != "FoamFile")
 
     def __contains__(self, keywords: object) -> bool:
@@ -348,11 +380,12 @@ class FoamFieldFile(FoamFile):
     """An OpenFOAM dictionary file representing a field as a mutable mapping."""
 
     class BoundariesSubDict(FoamFile.SubDict):
-        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundarySubDict":
+        def __getitem__(self, keyword: str) -> FoamFieldFile.BoundarySubDict:
             value = super().__getitem__(keyword)
             if not isinstance(value, FoamFieldFile.BoundarySubDict):
                 assert not isinstance(value, FoamFile.SubDict)
-                raise TypeError(f"boundary {keyword} is not a dictionary")
+                msg = f"boundary {keyword} is not a dictionary"
+                raise TypeError(msg)
             return value
 
     class BoundarySubDict(FoamFile.SubDict):
@@ -363,7 +396,8 @@ class FoamFieldFile(FoamFile):
             """Alias of `self["type"]`."""
             ret = self["type"]
             if not isinstance(ret, str):
-                raise TypeError("type is not a string")
+                msg = "type is not a string"
+                raise TypeError(msg)
             return ret
 
         @type.setter
@@ -392,8 +426,8 @@ class FoamFieldFile(FoamFile):
             del self["value"]
 
     def __getitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union[FoamFileBase._DataEntry, FoamFile.SubDict]:
+        self, keywords: str | tuple[str, ...] | None
+    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -408,15 +442,16 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @property
-    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[float]]:
+    def dimensions(self) -> FoamFile.DimensionSet | Sequence[float]:
         """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):
-            raise TypeError("dimensions is not a DimensionSet")
+            msg = "dimensions is not a DimensionSet"
+            raise TypeError(msg)
         return ret
 
     @dimensions.setter
-    def dimensions(self, value: Union[FoamFile.DimensionSet, Sequence[float]]) -> None:
+    def dimensions(self, value: FoamFile.DimensionSet | Sequence[float]) -> None:
         self["dimensions"] = value
 
     @property
@@ -434,12 +469,13 @@ class FoamFieldFile(FoamFile):
         self["internalField"] = value
 
     @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesSubDict":
+    def boundary_field(self) -> FoamFieldFile.BoundariesSubDict:
         """Alias of `self["boundaryField"]`."""
         ret = self["boundaryField"]
         if not isinstance(ret, FoamFieldFile.BoundariesSubDict):
             assert not isinstance(ret, FoamFile.SubDict)
-            raise TypeError("boundaryField is not a dictionary")
+            msg = "boundaryField is not a dictionary"
+            raise TypeError(msg)
         return ret
 
     @boundary_field.setter

foamlib/_files/_io.py

@@ -1,12 +1,10 @@
+from __future__ import annotations
+
 import gzip
 import sys
 from pathlib import Path
-from types import TracebackType
 from typing import (
     TYPE_CHECKING,
-    Optional,
-    Type,
-    Union,
 )
 
 if sys.version_info >= (3, 11):
@@ -18,14 +16,15 @@ from ._parsing import Parsed
 
 if TYPE_CHECKING:
     import os
+    from types import TracebackType
 
 
 class FoamFileIO:
-    def __init__(self, path: Union["os.PathLike[str]", str]) -> None:
+    def __init__(self, path: os.PathLike[str] | str) -> None:
         self.path = Path(path).absolute()
 
-        self.__parsed: Optional[Parsed] = None
-        self.__missing: Optional[bool] = None
+        self.__parsed: Parsed | None = None
+        self.__missing: bool | None = None
         self.__defer_io = 0
 
     def __enter__(self) -> Self:
@@ -36,9 +35,9 @@ class FoamFileIO:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.__defer_io -= 1
         if self.__defer_io == 0: