Added @staticmethod and type hints across code base

[cpuguy96]

Introduce type hints and static methods to the code, improving its readability, maintainability, and potentially performance. Let's break down the changes by file:

output_processor.py:

• Type hints are added to the pregenerate_sm_output and pregenerate_txt_output functions, specifying the expected data types for the note_data parameter as dict[str, Any]. The previous type hint defaultdict(list) was too restrictive and didn't accurately reflect the data structure. dict[str, Any] is more flexible, while still providing some type information.
• The @staticmethod decorator is added to both functions. This indicates that the methods don't require access to the class's internal state (i.e., self). This change clarifies the intent and usage of these functions.

input_processor.py:

• Similar to output_processor.py, type hints are added throughout, enhancing clarity. For example, convert_note now specifies its input (line: str) and return type (-> str). parse_sm_input also clearly defines its input and output types.
• @staticmethod is applied to all methods in the class, emphasizing that these are utility functions operating independently of any specific InputProcessor instance. The internal logic remains consistent while being made easier to follow and reuse due to type hints. The improved specificity from the older, more general type hints aids in understanding the data flow within these methods.
• The return type of parse_sm_input is updated to tuple[dict[str, Any], bool] which means it returns a tuple including a dictionary containing the note data and a boolean variable.

file_utils.py:

• Type hints are added to all functions: read_file, write_file, strip_filename, collect_filenames, getFilePaths, and checkFilePaths. This makes the code much easier to understand and debug, especially when dealing with file paths and extensions. Notably, the extensions parameter in collect_filenames and getFilePaths are now typed as Collection[str], allowing for various iterable types to be passed in (e.g., lists, tuples, sets).
• The function signatures now explicitly communicate the expected input and output types, improving the developer experience and reducing the risk of type-related errors.

cli_options.py:

• Type hints clarify the input (filepath: str) and return type (-> DataHandler) of the read_SMtoData and read_TXTtoData functions. The methods write_DatatoSM and write_DatatoTXT also have the input type hints added.
• @staticmethod is applied to all functions, as these utility functions are self-contained and don't need instance-specific context.

data_processing/data_handler.py:

• The __init__ method now includes a type hint for the filepath parameter (filepath: str).
• Type hints are added to note_data and processed_data, using dict[str, Any] to represent the flexible structure of the data they hold.

components/measure.py:

• All methods in this class are marked as @staticmethod indicating that they do not operate on instance data. Type hints are added to all function parameters and return values, clarifying expectations. For instance, calculate_timing now explicitly states that it expects a list of strings or None values, and an integer, float, and float, and returns a list of strings. This strictness is vital when dealing with numerical computations and string formatting. The type hints for find_gcd, generate_measure, fit_notes_to_measure and place_notes also provides specific information about the input and output data types.

In summary, these changes represent a significant improvement to the code's clarity and maintainability. By adding type hints and using static methods, the developers have made the code easier to understand, reason about, and refactor. This also facilitates better static analysis and error detection.