foamlib 0.6.10__py3-none-any.whl → 0.6.12__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
@@ -6,35 +8,46 @@ if TYPE_CHECKING:
     import numpy as np
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Mapping, MutableMapping, Sequence
 else:
-    from typing import Mapping, Sequence
+    from typing import Mapping, MutableMapping, Sequence
 
 
 class FoamFileBase:
     class DimensionSet(NamedTuple):
-        mass: Union[int, float] = 0
-        length: Union[int, float] = 0
-        time: Union[int, float] = 0
-        temperature: Union[int, float] = 0
-        moles: Union[int, float] = 0
-        current: Union[int, float] = 0
-        luminous_intensity: Union[int, float] = 0
+        mass: float = 0
+        length: float = 0
+        time: float = 0
+        temperature: float = 0
+        moles: float = 0
+        current: float = 0
+        luminous_intensity: float = 0
 
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
 
+    _Tensor = Union[
+        float,
+        Sequence[float],
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+    ]
+
     @dataclass
     class Dimensioned:
-        value: Union[int, float, Sequence[Union[int, float]]] = 0
-        dimensions: Union["FoamFileBase.DimensionSet", Sequence[Union[int, 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):
                 self.dimensions = FoamFileBase.DimensionSet(*self.dimensions)
 
-    Data = Union[
+    _Field = Union[
+        _Tensor, Sequence[_Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
+    ]
+
+    _DataEntry = Union[
         str,
         int,
         float,
@@ -42,25 +55,22 @@ class FoamFileBase:
         Dimensioned,
         DimensionSet,
         Sequence["Data"],
+        _Tensor,
+        _Field,
+    ]
+
+    Data = Union[
+        _DataEntry,
         Mapping[str, "Data"],
     ]
     """
     A value that can be stored in an OpenFOAM file.
     """
 
+    _MutableData = Union[
+        _DataEntry,
+        MutableMapping[str, "_MutableData"],
+    ]
+
     _Dict = Dict[str, Union["Data", "_Dict"]]
     _File = Dict[Optional[str], Union["Data", "_Dict"]]
-
-    _SetData = Union[
-        str,
-        int,
-        float,
-        bool,
-        Dimensioned,
-        DimensionSet,
-        Sequence["_SetData"],
-        Mapping[str, "_SetData"],
-        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-    ]