#1714: apply recommended changes with removing get methods and using the properties directly

src/primaite/simulator/core.py

@@ -10,7 +10,7 @@ class SimComponent(BaseModel):
     """Extension of pydantic BaseModel with additional methods that must be defined by all classes in the simulator."""
 
     uuid: str
-    "The component UUID."
+    """The component UUID."""
 
     def __init__(self, **kwargs):
         if not kwargs.get("uuid"):

src/primaite/simulator/file_system/file_system.py

@@ -31,7 +31,7 @@ class FileSystem(SimComponent):
     def create_file(
         self,
         file_name: str,
-        file_size: Optional[float] = None,
+        size: Optional[float] = None,
         file_type: Optional[FileSystemFileType] = None,
         folder: Optional[FileSystemFolder] = None,
         folder_uuid: Optional[str] = None,
@@ -39,14 +39,14 @@ class FileSystem(SimComponent):
         """
         Creates a FileSystemFile and adds it to the list of files.
 
-        If no file_size or file_type are provided, one will be chosen randomly.
+        If no size or file_type are provided, one will be chosen randomly.
         If no folder_uuid or folder is provided, a new folder will be created.
 
         :param: file_name: The file name
         :type: file_name: str
 
-        :param: file_size: The size the file takes on disk.
+        :param: size: The size the file takes on disk.
-        :type: file_size: Optional[float]
+        :type: size: Optional[float]
 
         :param: file_type: The type of the file
         :type: Optional[FileSystemFileType]
@@ -69,17 +69,17 @@ class FileSystem(SimComponent):
             folder = self.get_folder_by_id(folder_uuid)
 
         if folder is not None:
-            file = FileSystemFile(item_name=file_name, item_size=file_size, file_type=file_type)
+            file = FileSystemFile(name=file_name, size=size, file_type=file_type)
             folder.add_file(file=file)
         else:
             # check if a "root" folder exists
             folder = self.get_folder_by_name("root")
             if folder is None:
                 # create a root folder
-                folder = FileSystemFolder(item_name="root")
+                folder = FileSystemFolder(name="root")
 
             # add file to root folder
-            file = FileSystemFile(item_name=file_name, item_size=file_size, file_type=file_type)
+            file = FileSystemFile(name=file_name, size=size, file_type=file_type)
             folder.add_file(file)
             self.folders[folder.uuid] = folder
         return file
@@ -94,7 +94,7 @@ class FileSystem(SimComponent):
         :param: folder_name: The name of the folder
         :type: folder_name: str
         """
-        folder = FileSystemFolder(item_name=folder_name)
+        folder = FileSystemFolder(name=folder_name)
         self.folders[folder.uuid] = folder
         return folder
 
@@ -185,7 +185,7 @@ class FileSystem(SimComponent):
     def get_file_by_id(self, file_id: str) -> FileSystemFile:
         """Checks if the file exists in any file system folders."""
         for key in self.folders:
-            file = self.folders[key].get_file(file_id=file_id)
+            file = self.folders[key].get_file_by_id(file_id=file_id)
             if file is not None:
                 return file
 
@@ -197,7 +197,7 @@ class FileSystem(SimComponent):
         """
         matching_folder = None
         for key in self.folders:
-            if self.folders[key].get_folder_name() == folder_name:
+            if self.folders[key].name == folder_name:
                 matching_folder = self.folders[key]
                 break
         return matching_folder

src/primaite/simulator/file_system/file_system_file.py

@@ -15,17 +15,17 @@ class FileSystemFile(FileSystemItem):
         """
         Initialise FileSystemFile class.
 
-        :param item_name: The name of the file.
+        :param name: The name of the file.
-        :type item_name: str
+        :type name: str
 
         :param file_type: The FileSystemFileType of the file
         :type file_type: Optional[FileSystemFileType]
 
-        :param item_size: The size of the FileSystemItem
+        :param size: The size of the FileSystemItem
-        :type item_size: Optional[float]
+        :type size: Optional[float]
         """
         # set random file type if none provided
-        if kwargs.get("item_name") is None:
+        if kwargs.get("name") is None:
             raise Exception("File name not provided.")
 
         # set random file type if none provided
@@ -33,23 +33,11 @@ class FileSystemFile(FileSystemItem):
             kwargs["file_type"] = choice(list(FileSystemFileType))
 
         # set random file size if none provided
-        if kwargs.get("item_size") is None:
+        if kwargs.get("size") is None:
-            kwargs["item_size"] = float(randint(1, file_type_sizes_KB[kwargs["file_type"]]))
+            kwargs["size"] = float(randint(1, file_type_sizes_KB[kwargs["file_type"]]))
 
         super().__init__(**kwargs)
 
-    def get_file_name(self) -> str:
-        """Returns the name of the file."""
-        return self.item_name
-
-    def get_file_size(self) -> float:
-        """Returns the size of the file system item."""
-        return self.item_size
-
-    def get_file_type(self) -> FileSystemFileType:
-        """Returns the FileSystemFileType of the file."""
-        return self.file_type
-
     def describe_state(self) -> Dict:
         """
         Get the current state of the FileSystemFile as a dict.

src/primaite/simulator/file_system/file_system_folder.py

@@ -16,31 +16,18 @@ class FileSystemFolder(FileSystemItem):
     is_quarantined: bool = False
     """Flag that marks the folder as quarantined if true."""
 
-    def get_folder_name(self) -> str:
+    def get_file_by_id(self, file_id: str) -> FileSystemFile:
-        """Returns the item_name of the folder."""
-        return self.item_name
-
-    def get_folder_size(self) -> float:
-        """Returns the item_size of the folder."""
-        return self.item_size
-
-    def get_files(self) -> Dict:
-        """Returns the files dictionary."""
-        return self.files
-
-    def get_file(self, file_id: str) -> FileSystemFile:
         """Return a FileSystemFile with the matching id."""
-        return self.files[file_id]
+        return self.files.get(file_id)
 
     def add_file(self, file: FileSystemFile):
         """Adds a file to the folder list."""
         if file is None or not isinstance(file, FileSystemFile):
             raise Exception(f"Invalid file: {file}")
 
-        self.item_size += file.get_file_size()
-
         # add to list
         self.files[file.uuid] = file
+        self.size += file.size
 
     def remove_file(self, file: Optional[FileSystemFile]):
         """
@@ -57,8 +44,7 @@ class FileSystemFolder(FileSystemItem):
         if self.files.get(file.uuid):
             del self.files[file.uuid]
 
-            # remove folder size from folder
+            self.size -= file.size
-            self.item_size -= file.get_file_size()
         else:
             _LOGGER.debug(f"File with UUID {file.uuid} was not found.")
 

src/primaite/simulator/file_system/file_system_item_abc.py

@@ -6,11 +6,11 @@ from primaite.simulator.core import SimComponent
 class FileSystemItem(SimComponent):
     """Abstract base class for FileSystemItems used in the file system simulation."""
 
-    item_size: float = 0
+    name: str
-    """The size the item takes up on disk."""
+    """The name of the FileSystemItem."""
 
-    item_name: str
+    size: float = 0
-    """The name of the file system item."""
+    """The size the item takes up on disk."""
 
     def describe_state(self) -> Dict:
         """Returns the state of the FileSystemItem."""

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system.py

@@ -6,121 +6,121 @@ def test_create_folder_and_file():
     """Test creating a folder and a file."""
     file_system = FileSystem()
     folder = file_system.create_folder(folder_name="test_folder")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
-    file = file_system.create_file(file_name="test_file", file_size=10, folder_uuid=folder.uuid)
+    file = file_system.create_file(file_name="test_file", size=10, folder_uuid=folder.uuid)
-    assert len(file_system.get_folder_by_id(folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(folder.uuid).files) is 1
 
-    assert file_system.get_file_by_id(file.uuid).get_file_name() is "test_file"
+    assert file_system.get_file_by_id(file.uuid).name is "test_file"
-    assert file_system.get_file_by_id(file.uuid).get_file_size() == 10
+    assert file_system.get_file_by_id(file.uuid).size == 10
 
 
 def test_create_file():
     """Tests that creating a file without a folder creates a folder and sets that as the file's parent."""
     file_system = FileSystem()
 
-    file = file_system.create_file(file_name="test_file", file_size=10)
+    file = file_system.create_file(file_name="test_file", size=10)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
-    assert file_system.get_folder_by_name("root").get_file(file.uuid) is file
+    assert file_system.get_folder_by_name("root").get_file_by_id(file.uuid) is file
 
 
 def test_delete_file():
     """Tests that a file can be deleted."""
     file_system = FileSystem()
 
-    file = file_system.create_file(file_name="test_file", file_size=10)
+    file = file_system.create_file(file_name="test_file", size=10)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
-    folder_id = list(file_system.get_folders().keys())[0]
+    folder_id = list(file_system.folders.keys())[0]
     folder = file_system.get_folder_by_id(folder_id)
-    assert folder.get_file(file.uuid) is file
+    assert folder.get_file_by_id(file.uuid) is file
 
     file_system.delete_file(file=file)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
-    assert len(file_system.get_folder_by_id(folder.uuid).get_files()) is 0
+    assert len(file_system.get_folder_by_id(folder.uuid).files) is 0
 
 
 def test_delete_non_existent_file():
     """Tests deleting a non existent file."""
     file_system = FileSystem()
 
-    file = file_system.create_file(file_name="test_file", file_size=10)
+    file = file_system.create_file(file_name="test_file", size=10)
-    not_added_file = file_system.create_file(file_name="test_file", file_size=10)
+    not_added_file = file_system.create_file(file_name="test_file", size=10)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
-    folder_id = list(file_system.get_folders().keys())[0]
+    folder_id = list(file_system.folders.keys())[0]
     folder = file_system.get_folder_by_id(folder_id)
-    assert folder.get_file(file.uuid) is file
+    assert folder.get_file_by_id(file.uuid) is file
 
     file_system.delete_file(file=not_added_file)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
-    assert len(file_system.get_folder_by_id(folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(folder.uuid).files) is 1
 
 
 def test_delete_folder():
     file_system = FileSystem()
     folder = file_system.create_folder(folder_name="test_folder")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
     file_system.delete_folder(folder)
-    assert len(file_system.get_folders()) is 0
+    assert len(file_system.folders) is 0
 
 
 def test_deleting_a_non_existent_folder():
     file_system = FileSystem()
     folder = file_system.create_folder(folder_name="test_folder")
-    not_added_folder = FileSystemFolder(item_name="fake_folder")
+    not_added_folder = FileSystemFolder(name="fake_folder")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
     file_system.delete_folder(not_added_folder)
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
 
 def test_move_file():
     """Tests the file move function."""
     file_system = FileSystem()
     src_folder = file_system.create_folder(folder_name="test_folder_1")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
     target_folder = file_system.create_folder(folder_name="test_folder_2")
-    assert len(file_system.get_folders()) is 2
+    assert len(file_system.folders) is 2
 
-    file = file_system.create_file(file_name="test_file", file_size=10, folder_uuid=src_folder.uuid)
+    file = file_system.create_file(file_name="test_file", size=10, folder_uuid=src_folder.uuid)
-    assert len(file_system.get_folder_by_id(src_folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(src_folder.uuid).files) is 1
-    assert len(file_system.get_folder_by_id(target_folder.uuid).get_files()) is 0
+    assert len(file_system.get_folder_by_id(target_folder.uuid).files) is 0
 
     file_system.move_file(file=file, src_folder=src_folder, target_folder=target_folder)
 
-    assert len(file_system.get_folder_by_id(src_folder.uuid).get_files()) is 0
+    assert len(file_system.get_folder_by_id(src_folder.uuid).files) is 0
-    assert len(file_system.get_folder_by_id(target_folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(target_folder.uuid).files) is 1
 
 
 def test_copy_file():
     """Tests the file copy function."""
     file_system = FileSystem()
     src_folder = file_system.create_folder(folder_name="test_folder_1")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
     target_folder = file_system.create_folder(folder_name="test_folder_2")
-    assert len(file_system.get_folders()) is 2
+    assert len(file_system.folders) is 2
 
-    file = file_system.create_file(file_name="test_file", file_size=10, folder_uuid=src_folder.uuid)
+    file = file_system.create_file(file_name="test_file", size=10, folder_uuid=src_folder.uuid)
-    assert len(file_system.get_folder_by_id(src_folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(src_folder.uuid).files) is 1
-    assert len(file_system.get_folder_by_id(target_folder.uuid).get_files()) is 0
+    assert len(file_system.get_folder_by_id(target_folder.uuid).files) is 0
 
     file_system.copy_file(file=file, src_folder=src_folder, target_folder=target_folder)
 
-    assert len(file_system.get_folder_by_id(src_folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(src_folder.uuid).files) is 1
-    assert len(file_system.get_folder_by_id(target_folder.uuid).get_files()) is 1
+    assert len(file_system.get_folder_by_id(target_folder.uuid).files) is 1
 
 
 def test_serialisation():
     """Test to check that the object serialisation works correctly."""
     file_system = FileSystem()
     folder = file_system.create_folder(folder_name="test_folder")
-    assert len(file_system.get_folders()) is 1
+    assert len(file_system.folders) is 1
 
-    file_system.create_file(file_name="test_file", file_size=10, folder_uuid=folder.uuid)
+    file_system.create_file(file_name="test_file", size=10, folder_uuid=folder.uuid)
     assert file_system.get_folder_by_id(folder.uuid) is folder
 
     serialised_file_sys = file_system.model_dump_json()

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system_file.py

@@ -4,19 +4,19 @@ from primaite.simulator.file_system.file_system_file_type import FileSystemFileT
 
 def test_file_type():
     """Tests tha the FileSystemFile type is set correctly."""
-    file = FileSystemFile(item_name="test", file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test", file_type=FileSystemFileType.DOC)
-    assert file.get_file_type() is FileSystemFileType.DOC
+    assert file.file_type is FileSystemFileType.DOC
 
 
-def test_get_file_size():
+def test_get_size():
     """Tests that the file size is being returned properly."""
-    file = FileSystemFile(item_name="test", item_size=1.5)
+    file = FileSystemFile(name="test", size=1.5)
-    assert file.get_file_size() == 1.5
+    assert file.size == 1.5
 
 
 def test_serialisation():
     """Test to check that the object serialisation works correctly."""
-    file = FileSystemFile(item_name="test", item_size=1.5, file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test", size=1.5, file_type=FileSystemFileType.DOC)
     serialised_file = file.model_dump_json()
     deserialised_file = FileSystemFile.model_validate_json(serialised_file)
 

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system_folder.py

@@ -5,53 +5,53 @@ from primaite.simulator.file_system.file_system_folder import FileSystemFolder
 
 def test_adding_removing_file():
     """Test the adding and removing of a file from a folder."""
-    folder = FileSystemFolder(item_name="test")
+    folder = FileSystemFolder(name="test")
 
-    file = FileSystemFile(item_name="test_file", item_size=10, file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test_file", size=10, file_type=FileSystemFileType.DOC)
 
     folder.add_file(file)
-    assert folder.get_folder_size() == 10
+    assert folder.size == 10
-    assert len(folder.get_files()) is 1
+    assert len(folder.files) is 1
 
     folder.remove_file(file)
-    assert folder.get_folder_size() == 0
+    assert folder.size == 0
-    assert len(folder.get_files()) is 0
+    assert len(folder.files) is 0
 
 
 def test_remove_non_existent_file():
     """Test the removing of a file that does not exist."""
-    folder = FileSystemFolder(item_name="test")
+    folder = FileSystemFolder(name="test")
 
-    file = FileSystemFile(item_name="test_file", item_size=10, file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test_file", size=10, file_type=FileSystemFileType.DOC)
-    not_added_file = FileSystemFile(item_name="fake_file", item_size=10, file_type=FileSystemFileType.DOC)
+    not_added_file = FileSystemFile(name="fake_file", size=10, file_type=FileSystemFileType.DOC)
 
     folder.add_file(file)
-    assert folder.get_folder_size() == 10
+    assert folder.size == 10
-    assert len(folder.get_files()) is 1
+    assert len(folder.files) is 1
 
     folder.remove_file(not_added_file)
-    assert folder.get_folder_size() == 10
+    assert folder.size == 10
-    assert len(folder.get_files()) is 1
+    assert len(folder.files) is 1
 
 
 def test_get_file_by_id():
     """Test to make sure that the correct file is returned."""
-    folder = FileSystemFolder(item_name="test")
+    folder = FileSystemFolder(name="test")
 
-    file = FileSystemFile(item_name="test_file", item_size=10, file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test_file", size=10, file_type=FileSystemFileType.DOC)
-    file2 = FileSystemFile(item_name="test_file_2", item_size=10, file_type=FileSystemFileType.DOC)
+    file2 = FileSystemFile(name="test_file_2", size=10, file_type=FileSystemFileType.DOC)
 
     folder.add_file(file)
     folder.add_file(file2)
-    assert folder.get_folder_size() == 20
+    assert folder.size == 20
-    assert len(folder.get_files()) is 2
+    assert len(folder.files) is 2
 
-    assert folder.get_file(file_id=file.uuid) is file
+    assert folder.get_file_by_id(file_id=file.uuid) is file
 
 
 def test_folder_quarantine_state():
     """Tests the changing of folder quarantine status."""
-    folder = FileSystemFolder(item_name="test")
+    folder = FileSystemFolder(name="test")
 
     assert folder.quarantine_status() is False
 
@@ -64,8 +64,8 @@ def test_folder_quarantine_state():
 
 def test_serialisation():
     """Test to check that the object serialisation works correctly."""
-    folder = FileSystemFolder(item_name="test")
+    folder = FileSystemFolder(name="test")
-    file = FileSystemFile(item_name="test_file", item_size=10, file_type=FileSystemFileType.DOC)
+    file = FileSystemFile(name="test_file", size=10, file_type=FileSystemFileType.DOC)
     folder.add_file(file)
 
     serialised_folder = folder.model_dump_json()