Quick clean up with pycharm and pylint helping out

Author: max-amb

nix_tree/decomposer.py

@@ -274,7 +274,7 @@ def __managing_the_rest_of_the_file(self) -> None:
             except KeyError:  # If there isn't a comment attached
                 pass
             place_to_check = 1
-            for i in range(1, len(rest_of_file_split)): # To stop empty portions lile [""] being an issue and meaning something was skipped
+            for i in range(1, len(rest_of_file_split)): # To stop empty portions like [""] being an issue and meaning something was skipped
                 if rest_of_file_split[equals_locations[iterator.equals_number][1] + i] != "":
                     place_to_check = i
                     break
@@ -354,7 +354,7 @@ def __cleaning_the_configuration(self, file: str) -> str:
         file = re.sub(r"[^\S\n]{", " { ", file)
         file = re.sub(";", " ; ", file)  # For with clauses
         file = re.sub(r"}[^\S\n]*;", "}; ", file)
-        file = re.sub(r"\][^\S\n]*;", "]; ", file)
+        file = re.sub(r"][^\S\n]*;", "]; ", file)
         file = re.sub(r'\[[^\S\n]*"', '[ "', file)
         file = re.sub(r"\[[^\S\n]*'", "[ '", file)
         file = re.sub(r"\[[^\S\n]*''", "[ ''", file)

nix_tree/section_screens.py

@@ -80,9 +80,9 @@ def on_input_submitted(self, user_input: Input.Submitted):
             user_input: Input.Submitted - the choice of the user
         """
 
-        clean_input: str = re.sub(r"\"", "'", user_input.value)
+        clean_input: str = re.sub(r'"', "'", user_input.value)
         clean_input = re.sub(r"(\[)(\s*)", "[ ", clean_input)
-        clean_input = re.sub(r"(\s*)(\])", " ]", clean_input)
+        clean_input = re.sub(r"(\s*)(])", " ]", clean_input)
         self.dismiss(clean_input)
 
 
@@ -292,14 +292,17 @@ def handle_return_from_variable_addition(data: tuple[str, Types | None] | None)
             """
 
             if data:
-                if data[1] == Types.LIST and (not re.search(r"^\s*\[[^\]]*\]\s*$", data[0])):
+                if data[1] == Types.LIST and (not re.search(r"^\s*\[[^]]*]\s*$", data[0])):
                     self.notify("You lost (or gained) a bracket! Not updating", title="error adding option",  severity="error")
                     if type_as_defined:
                         self.app.push_screen(RecommendedTypeOrChooseType(type_as_defined),
                                              handle_return_from_variable_addition)
                     else:
                         self.app.push_screen(AddScreenVariableSelection(), handle_return_from_variable_addition)
-                elif data[1] == Types.STRING and (not re.search(r"^\s*'[^']*'\s*$", data[0])):
+                elif data[1] == Types.STRING and (
+                        (not re.search(r"^\s*'[^']*'\s*$", data[0])) and
+                        (not re.search(r"^\s*''[^'']*''\s*$", data[0]))
+                ):
                     self.notify("You lost (or gained) a speech mark! Not updating", title="error adding option",  severity="error")
                     if type_as_defined:
                         self.app.push_screen(RecommendedTypeOrChooseType(type_as_defined),
@@ -322,7 +325,7 @@ def handle_return_from_variable_addition(data: tuple[str, Types | None] | None)
             else:
                 self.app.pop_screen()
 
-        if re.search(r"[^a-zA-Z_]", path.value):
+        if re.search(r"[^a-zA-Z_.]", path.value):
             self.notify("You have entered invalid character(s) for the path of your option, not adding", title="error adding option",  severity="error")
             self.dismiss(None)
         else:
@@ -365,36 +368,29 @@ def recursive_addition(self, node: UIConnectorNode, path: list, data: str, path_
             bool - true if the function added the variable and false if otherwise
         """
         if len(path) > 1:
-            path_bit_already_exists = False
             for child in node.children:
                 if child.label.plain == path[0]:
-                    path_bit_already_exists = True
                     del path[0]
                     return self.recursive_addition(child, path, data, path_as_list, data_type)
-            if not path_bit_already_exists:
-                new_node = node.add(path[0])
-                if new_node.parent.is_root:
-                    self.__operations.append(f"Section {path[0]} added")
-                else:
-                    self.__operations.append(f"Section {'.'.join(work_out_full_path(new_node, []))} added")
-                del path[0]
-                return self.recursive_addition(new_node, path, data, path_as_list, data_type)
+            new_node = node.add(path[0])
+            if new_node.parent.is_root:
+                self.__operations.append(f"Section {path[0]} added")
+            else:
+                self.__operations.append(f"Section {'.'.join(work_out_full_path(new_node, []))} added")
+            del path[0]
+            return self.recursive_addition(new_node, path, data, path_as_list, data_type)
+
+        for child in node.children:
+            if child.label.plain.split("=")[0] == self.__path.split(".")[-1]:
+                self.notify("variable already exists", severity="error")
+                return False
+        if not path_as_list:
+            node.add_leaf(self.__path.split(".")[-1] + "=" + data,
+                          data={self.__path: data, "type": data_type})
         else:
-            var_already_exists = False
-            for child in node.children:
-                if child.label.plain.split("=")[0] == self.__path.split(".")[-1]:
-                    var_already_exists = True
-                    self.notify("variable already exists", severity="error")
-                    return False
-            if not var_already_exists:
-                if not path_as_list:
-                    node.add_leaf(self.__path.split(".")[-1] + "=" + data,
-                                  data={self.__path: data, "type": data_type})
-                else:
-                    node.add_leaf(self.__path.split(".")[-1] + "=" + data,
-                                  data={'.'.join(path_as_list) + "." + self.__path: data, "type": data_type})
-                return True
-        return None
+            node.add_leaf(self.__path.split(".")[-1] + "=" + data,
+                          data={'.'.join(path_as_list) + "." + self.__path: data, "type": data_type})
+        return True
 
     def action_quit_pressed(self) -> None:
         """Quits the screen when one of the quit buttons are pressed"""

nix_tree/tree.py

@@ -24,7 +24,7 @@ def find_type(variable: str) -> Types:
         return Types.INT
     if variable in ("true", "false"):
         return Types.BOOL
-    if re.search(r"^\s*\[.*\]\s*$", variable):
+    if re.search(r"^\s*\[.*]\s*$", variable):
         return Types.LIST
     if re.search(r"^\s*(\"|'|'').*(\"|'|'')\s*$", variable):
         return Types.STRING

nix_tree/ui.py

@@ -197,10 +197,9 @@ def __extract_data_from_action(self, action: str) -> tuple[str, str, str]:
             ErrorComposingFileFromTree - If the regex doesn't match meaning the action is corrupted
         """
 
-        path = ""
         variable = ""
         if "[" in action: # List types
-            if match := re.search(r"(Added|Delete|Change) (.*)\[(.*)\]", action):
+            if match := re.search(r"(Added|Delete|Change) (.*)\[(.*)]", action):
                 path = match.group(2)
                 variable = "[" + match.group(3) + "]"
             else:
@@ -216,10 +215,10 @@ def __extract_data_from_action(self, action: str) -> tuple[str, str, str]:
             else:
                 raise ErrorComposingFileFromTree(message="Was unable to parse actions to apply to tree")
             full_path = path + variable
-        else: # True falses and uniques
+        else: # True, falses and uniques
             full_path = action.split(" ")[1]
             path = full_path.split("=")[0]
-        return (path, variable, full_path)
+        return path, variable, full_path
 
     def action_undo(self, empty_command: bool = False) -> None:
         """Performs the undo commands by popping the change from the stack and reverse engineering it
@@ -334,7 +333,7 @@ def __apply_changes(self) -> None:
         while self.__queue.get_len() > 0:
             action = self.__queue.dequeue().name
             if action:
-                # This section is pulling all of the data from the action such as the path of the option and the data
+                # This section is pulling all the data from the action such as the path of the option and the data
                 _, _, full_path = self.__extract_data_from_action(action)
 
                 # Performing the operations on the tree

nix_tree/variable_screens.py

@@ -68,16 +68,19 @@ def on_input_submitted(self, new_data: Input.Submitted) -> None:
         """
 
         if self.__value != new_data.value:
-            if self.__type == Types.LIST and (not re.search(r"^\s*\[[^\]]*\]\s*$", new_data.value)):
+            if self.__type == Types.LIST and (not re.search(r"^\s*\[[^]]*]\s*$", new_data.value)):
                 self.notify("You lost (or gained) a bracket! Not updating", title="error changing option", severity="error")
                 self.app.pop_screen()
-            elif self.__type == Types.STRING and (not re.search(r"^\s*'[^']*'\s*$", new_data.value)):
+            elif self.__type == Types.STRING and (
+                    (not re.search(r"^\s*'[^']*'\s*$", new_data.value)) and
+                    (not re.search(r"^\s*''[^'']*''\s*$", new_data.value))
+            ):
                 self.notify("You lost (or gained) a speech mark! Not updating", title="error changing option", severity="error")
                 self.app.pop_screen()
             else:
                 clean_input: str = re.sub(r"\"", "'", new_data.value)
                 clean_input = re.sub(r"(\[)(\s*)", "[ ", clean_input)
-                clean_input = re.sub(r"(\s*)(\])", " ]", clean_input)
+                clean_input = re.sub(r"(\s*)(])", " ]", clean_input)
                 self.__node.node.label = self.__path.split(".")[-1] + "=" + clean_input
                 if self.__node.node.data:
                     self.__node.node.data[self.__path] = clean_input

tests/test_comment_collecting.py

@@ -1,3 +1,4 @@
+"""Tests the comment collecting functions for accuracy"""
 from pathlib import Path
 
 from nix_tree.decomposer import CommentHandling
@@ -14,7 +15,7 @@ def test_yasu_example_config():
     """
     Checks if all comments are collected correctly in yasu_example_config.nix configuration
     """
-    
+
     comment_handler = CommentHandling(Path("./tests/example_configurations/yasu_example_config.nix"))
     assert "{6: [('# Include the results of the hardware scan.\\n', False)], 13: [('# Define your hostname.\\n', False)], 23: [('#audio', True)], 38: [('# Steam\\n', False)]}".replace("\"", '"') == str(comment_handler.get_comments_for_attaching())
 

tests/test_exceptions.py

@@ -1,3 +1,4 @@
+"""Tests that the exceptions are called at the right times in the program"""
 from pathlib import Path
 import pytest
 

tests/test_individual_functions.py

@@ -114,5 +114,3 @@ def test_work_out_full_path_example():
                 at_bottom_of_tree = True
 
         assert path == work_out_full_path(current_node, [])
-
-