linting

Author: VicTrqt

Diff for: src/atomate2/abinit/run.py

@@ -99,7 +99,7 @@ def run_mrgddb(
         open(LOG_FILE_NAME, "w") as stdout,
         open(STDERR_FILE_NAME, "w") as stderr,
     ):
-        process = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr)  # noqa: S603
+        process = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr)
 
         if wall_time is not None:
             while True:
@@ -146,7 +146,7 @@ def run_anaddb(
         open(STDERR_FILE_NAME, "w") as stderr,
     ):
         # process = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr)
-        process = subprocess.Popen(command, stdout=stdout, stderr=stderr)  # noqa: S603
+        process = subprocess.Popen(command, stdout=stdout, stderr=stderr)
 
         if wall_time is not None:
             while True:

Diff for: src/atomate2/abinit/schemas/outfiles.py

@@ -1,10 +1,13 @@
-import os
+"""Class to store the raw data of Abinit files."""
+
 import base64
-from monty.json import MSONable
-from typing import TYPE_CHECKING
+import os
 from pathlib import Path
+
+from monty.json import MSONable
 from typing_extensions import Self
 
+
 class AbinitStoredFile(MSONable):
     """Wrap a file to store its raw data."""
 
@@ -13,57 +16,69 @@ def __init__(self, data: str | bytes, source_filepath: str | Path) -> None:
         self.source_filepath = source_filepath
 
     def as_dict(self) -> dict:
-        data = base64.b64encode(self.data).decode('ascii') if self.data_type == "bytes" else self.data
-        
+        """Return a dict of the stored file."""
+        data = (
+            base64.b64encode(self.data).decode("ascii")
+            if isinstance(self.data, bytes)
+            else self.data
+        )
+
         return {
             "@module": self.__class__.__module__,
             "@class": self.__class__.__name__,
             "data": data,
             "data_type": self.data_type,
             "source_filepath": self.source_filepath,
-            }
+        }
 
     @classmethod
     def from_dict(cls, d: dict) -> Self:
+        """Create an AbinitStoredFile from a dict."""
         data_type = d["data_type"]
         data = base64.b64decode(d["data"]) if data_type == "bytes" else d["data"]
         return cls(data=data, source_filepath=d["source_filepath"])
 
     @classmethod
     def from_file(cls, filepath: str | Path, data_type: str | type) -> Self:
+        """Create an AbinitStoredFile from the original file."""
         source_filepath = os.path.abspath(filepath)
-        if data_type=="bytes" or data_type==bytes:
-            read_type = 'rb'
-        elif data_type=="str" or data_type==str:
-            read_type = 'r'
+        if data_type in {"bytes", bytes}:
+            read_type = "rb"
+        elif data_type in {"str", str}:
+            read_type = "r"
         else:
             raise TypeError("data_type should be either bytes or str.")
         with open(source_filepath, read_type) as f:
             data = f.read()
-        
+
         return cls(data=data, source_filepath=source_filepath)
 
     @property
     def data_type(self) -> str:
+        """Return the type of the data."""
         return type(self.data).__name__
 
     @property
     def filename(self) -> str:
+        """Return the name of the source file."""
         return os.path.basename(self.source_filepath)
 
     @property
     def extension(self) -> str:
-        return self.source_filepath.split("_")[-1]
+        """Return the extension of the source file."""
+        return str(self.source_filepath).split("_")[-1]
 
-    def write(self, filepath: str | Path=None) -> None:
+    def write(self, filepath: str | Path = None) -> None:
+        """Write the data into a file."""
         filepath = filepath or self.filename
-        out_type = self.data_type[0]
-        if self.data_type == 'bytes':
-            write_type = 'wb'
+        if self.data_type == "bytes":
+            write_type = "wb"
         elif self.data_type == "str":
-            write_type = 'w'
+            write_type = "w"
         else:
-            raise TypeError("The data type is neither bytes nor string,\
-                            does it make sense to write it into a file?")
+            raise TypeError(
+                "The data type is neither bytes nor string,\
+                            does it make sense to write it into a file?"
+            )
         with open(filepath, write_type) as f:
             f.write(self.data)