spectre-core 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

spectre_core/_file_io/__init__.py

@@ -1,13 +1,13 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 """Basic internal file handling capabilities."""
 
 from .file_handlers import (
-    BaseFileHandler, JsonHandler, TextHandler,
+    BaseFileHandler,
+    JsonHandler,
+    TextHandler,
 )
 
-__all__ = [ 
-    "BaseFileHandler", "JsonHandler", "TextHandler"
-]
+__all__ = ["BaseFileHandler", "JsonHandler", "TextHandler"]

spectre_core/_file_io/file_handlers.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,14 +7,15 @@ import json
 from abc import ABC, abstractmethod
 from typing import Any, Optional, TypeVar, Generic
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 class BaseFileHandler(ABC, Generic[T]):
     """
     Base class for handling file operations.
 
-    When subclassing, specify the return type of `_read` 
-    using `Generic[T]`. 
+    When subclassing, specify the return type of `_read`
+    using `Generic[T]`.
 
     Example:
     .. code-block:: python
@@ -26,11 +27,9 @@ class BaseFileHandler(ABC, Generic[T]):
                 # Implementation here
                 ...
     """
+
     def __init__(
-        self, 
-        parent_dir_path: str, 
-        base_file_name: str, 
-        extension: Optional[str] = None
+        self, parent_dir_path: str, base_file_name: str, extension: Optional[str] = None
     ) -> None:
         """Initialise a `BaseFileHandler` instance.
 
@@ -39,130 +38,101 @@ class BaseFileHandler(ABC, Generic[T]):
         :param extension: The file extension (without the dot), defaults to None
         """
         self._data_cache: Optional[T] = None
-        
+
         self._parent_dir_path = parent_dir_path
-        self._base_file_name  = base_file_name
-        
+        self._base_file_name = base_file_name
+
         if extension == "":
             extension = None
         self._extension = extension
 
-     
     @abstractmethod
-    def _read(
-        self
-    ) -> T:
+    def _read(self) -> T:
         """The grunt work to return the file contents.
 
         :return: The file contents.
         """
-     
-    
+
     @property
-    def parent_dir_path(
-        self
-    ) -> str:
+    def parent_dir_path(self) -> str:
         """Return the parent directory path for the file."""
         return self._parent_dir_path
-    
 
     @property
-    def base_file_name(
-        self
-    ) -> str:
+    def base_file_name(self) -> str:
         """Return the file name, stripped of the file extension."""
         return self._base_file_name
-    
 
     @property
-    def extension(
-        self
-    ) -> Optional[str]:
+    def extension(self) -> Optional[str]:
         """Return the file path suffix, excluding the dot."""
         return self._extension
-    
 
     @property
-    def file_name(
-        self
-    ) -> str:
+    def file_name(self) -> str:
         """Generate the file name based on the base name and extension.
 
         :return: The file name with the extension (including the dot), or the base name if no extension is set.
         """
-        return self._base_file_name if (self._extension is None) else f"{self._base_file_name}.{self._extension}"
-    
+        return (
+            self._base_file_name
+            if (self._extension is None)
+            else f"{self._base_file_name}.{self._extension}"
+        )
 
     @property
-    def file_path(
-        self
-    ) -> str:
+    def file_path(self) -> str:
         """The absolute or relative file path as defined by the parent directory path,
         base file name and extension."""
         return os.path.join(self._parent_dir_path, self.file_name)
-    
-    
+
     @property
-    def exists(
-        self
-    ) -> bool:
+    def exists(self) -> bool:
         """Check if the file exists in the filesystem."""
-        return os.path.exists(self.file_path) 
-
+        return os.path.exists(self.file_path)
 
-    def read(
-        self,
-        cache: bool = True
-    ) -> T:
+    def read(self, cache: bool = True) -> T:
         """Read the file contents.
-        
+
         :param cache: If False, bypasses the cache and reads the file directly on each `read` call, defaults to True
         :return: The file contents.
         """
         # if the user has specified to ignore the cache, simply read the file.
         if not cache:
             return self._read()
-        
+
         # otherwise make use of the cache
         if self._data_cache is None:
             self._data_cache = self._read()
         return self._data_cache
-    
-    
-    def make_parent_dir_path(
-        self
-    ) -> None:
-        """Make the parent directory path of the file. No error is raised if the target 
+
+    def make_parent_dir_path(self) -> None:
+        """Make the parent directory path of the file. No error is raised if the target
         directory already exists.
         """
-        os.makedirs(self.parent_dir_path, exist_ok=True) 
-    
+        os.makedirs(self.parent_dir_path, exist_ok=True)
 
-    def delete(
-        self,
-        ignore_if_missing: bool = False
-    ) -> None:
+    def delete(self, ignore_if_missing: bool = False) -> None:
         """Delete the file from the filesystem.
 
         :param ignore_if_missing: If True, skips deletion if the file does not exist, defaults to False
         :raises FileNotFoundError: If the file is missing and `ignore_if_missing` is False.
         """
         if not self.exists and not ignore_if_missing:
-            raise FileNotFoundError(f"{self.file_name} does not exist, and so cannot be deleted")
+            raise FileNotFoundError(
+                f"{self.file_name} does not exist, and so cannot be deleted"
+            )
         else:
             os.remove(self.file_path)
-    
 
-    def cat(
-        self
-    ) -> None:
+    def cat(self) -> None:
         """Display the file contents on the standard output."""
         print(self.read())
 
 
 class JsonHandler(BaseFileHandler[dict[str, Any]]):
     """File handler for JSON formatted files.
-    
+
     We assume that the files are of the form
     {
         "foo": <JSON compatable structure>
@@ -170,29 +140,17 @@ class JsonHandler(BaseFileHandler[dict[str, Any]]):
     }
 
     """
+
     def __init__(
-        self, 
-        parent_dir_path: str, 
-        base_file_name: str,
-        extension: str = "json"
+        self, parent_dir_path: str, base_file_name: str, extension: str = "json"
     ) -> None:
-        super().__init__(parent_dir_path, 
-                         base_file_name, 
-                         extension)
-    
-    
-    def _read(
-        self
-    ) -> dict[str, Any]:
-        with open(self.file_path, 'r') as f:
+        super().__init__(parent_dir_path, base_file_name, extension)
+
+    def _read(self) -> dict[str, Any]:
+        with open(self.file_path, "r") as f:
             return json.load(f)
-        
-        
-    def save(
-        self, 
-        d: dict[str, Any], 
-        force: bool = False
-    ) -> None:
+
+    def save(self, d: dict[str, Any], force: bool = False) -> None:
         """Save the input dictionary to file in the JSON file format.
 
         :param d: The dictionary to save.
@@ -205,29 +163,25 @@ class JsonHandler(BaseFileHandler[dict[str, Any]]):
             if force:
                 pass
             else:
-                raise FileExistsError((f"{self.file_name} already exists, write has been abandoned. "
-                                       f"You can override this functionality with `force`"))
+                raise FileExistsError(
+                    (
+                        f"{self.file_name} already exists, write has been abandoned. "
+                        f"You can override this functionality with `force`"
+                    )
+                )
 
-        with open(self.file_path, 'w') as file:
-                json.dump(d, file, indent=4)
+        with open(self.file_path, "w") as file:
+            json.dump(d, file, indent=4)
 
-    
 
 class TextHandler(BaseFileHandler[str]):
     """File handler for text formatted files."""
+
     def __init__(
-        self, 
-        parent_dir_path: str,
-        base_file_name: str, 
-        extension: str = "txt"
+        self, parent_dir_path: str, base_file_name: str, extension: str = "txt"
     ) -> None:
-        super().__init__(parent_dir_path,
-                         base_file_name,
-                         extension)
-    
-    
-    def _read(
-        self
-    ) -> str:
-        with open(self.file_path, 'r') as f:
-            return f.read()
+        super().__init__(parent_dir_path, base_file_name, extension)
+
+    def _read(self) -> str:
+        with open(self.file_path, "r") as f:
+            return f.read()

spectre_core/batches/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -10,12 +10,29 @@ from .plugins._batch_keys import BatchKey
 from .plugins._iq_stream import IQStreamBatch, IQMetadata
 from .plugins._callisto import CallistoBatch
 
-from ._base import BaseBatch, BatchFile, parse_batch_base_file_name
+from ._base import (
+    BaseBatch,
+    BatchFile,
+    parse_batch_file_name,
+    parse_batch_base_file_name,
+)
 from ._batches import Batches
 from ._factory import get_batch_cls, get_batch_cls_from_tag
 
 __all__ = [
-    "IQStreamBatch", "IQMetadata", "CallistoBatch", "BaseBatch", "BatchFile", 
-    "Batches", "get_batch_cls", "BatchKey", "get_batch_cls_from_tag", "parse_batch_base_file_name"
+    "IQStreamBatch",
+    "IQMetadata",
+    "CallistoBatch",
+    "BaseBatch",
+    "BatchFile",
+    "Batches",
+    "get_batch_cls",
+    "BatchKey",
+    "get_batch_cls_from_tag",
+    "parse_batch_file_name",
 ]
 
+# To be deprecated.
+__all__ += [
+    "parse_batch_base_file_name",
+]