diff --git a/.gitignore b/.gitignore
index 5a82abd..8a793ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,16 @@
-astra.db
+# databases
+*.db
+
+# pycache
 __pycache__
+
+# mypy
+.mypy_cache
+
+# pytest
+.pytest_cache
+
+# pyinstaller
+*.spec
+dist/
+build/
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 98d1eaf..ba3183e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,5 +2,5 @@ PyYAML~=6.0.1
 SQLAlchemy~=2.0.23
 h5py~=3.10.0
 pandas~=2.1.3
-pytest
-matplotlib~=3.8.2
\ No newline at end of file
+pytest~=7.4.3
+matplotlib~=3.8.2
diff --git a/src/astra/__pycache__/__init__.cpython-310.pyc b/src/astra/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 9a01c54..0000000
Binary files a/src/astra/__pycache__/__init__.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/__pycache__/__init__.cpython-311.pyc b/src/astra/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index eaeda75..0000000
Binary files a/src/astra/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/src/astra/__pycache__/__init__.cpython-312.pyc b/src/astra/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index a9fcf52..0000000
Binary files a/src/astra/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/__init__.cpython-310.pyc b/src/astra/data/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index b381f0c..0000000
Binary files a/src/astra/data/__pycache__/__init__.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/__init__.cpython-311.pyc b/src/astra/data/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 370ce88..0000000
Binary files a/src/astra/data/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/__init__.cpython-312.pyc b/src/astra/data/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index dc5d11f..0000000
Binary files a/src/astra/data/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/alarms.cpython-312.pyc b/src/astra/data/__pycache__/alarms.cpython-312.pyc
deleted file mode 100644
index 186982e..0000000
Binary files a/src/astra/data/__pycache__/alarms.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/config_manager.cpython-310.pyc b/src/astra/data/__pycache__/config_manager.cpython-310.pyc
deleted file mode 100644
index d5056b1..0000000
Binary files a/src/astra/data/__pycache__/config_manager.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/config_manager.cpython-312.pyc b/src/astra/data/__pycache__/config_manager.cpython-312.pyc
deleted file mode 100644
index 0bc6a79..0000000
Binary files a/src/astra/data/__pycache__/config_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/data_manager.cpython-311.pyc b/src/astra/data/__pycache__/data_manager.cpython-311.pyc
deleted file mode 100644
index 785711b..0000000
Binary files a/src/astra/data/__pycache__/data_manager.cpython-311.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/data_manager.cpython-312.pyc b/src/astra/data/__pycache__/data_manager.cpython-312.pyc
deleted file mode 100644
index 0dcd396..0000000
Binary files a/src/astra/data/__pycache__/data_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/dict_parsing.cpython-312.pyc b/src/astra/data/__pycache__/dict_parsing.cpython-312.pyc
deleted file mode 100644
index c1693a7..0000000
Binary files a/src/astra/data/__pycache__/dict_parsing.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/parameters.cpython-312.pyc b/src/astra/data/__pycache__/parameters.cpython-312.pyc
deleted file mode 100644
index db4adcd..0000000
Binary files a/src/astra/data/__pycache__/parameters.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/telemetry_data.cpython-312.pyc b/src/astra/data/__pycache__/telemetry_data.cpython-312.pyc
deleted file mode 100644
index e8dbc95..0000000
Binary files a/src/astra/data/__pycache__/telemetry_data.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/__pycache__/telemetry_manager.cpython-312.pyc b/src/astra/data/__pycache__/telemetry_manager.cpython-312.pyc
deleted file mode 100644
index 4f796a1..0000000
Binary files a/src/astra/data/__pycache__/telemetry_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/data/alarm_container.py b/src/astra/data/alarm_container.py
index a2f08f4..4c3e5b2 100644
--- a/src/astra/data/alarm_container.py
+++ b/src/astra/data/alarm_container.py
@@ -1,3 +1,5 @@
+"""This module provides classes for storing and working with alarms."""
+
 from datetime import timedelta
 from queue import Queue
 from threading import Lock, Timer
@@ -5,18 +7,20 @@
 
 from astra.data.alarms import AlarmPriority, Alarm, AlarmCriticality
 
-NEW_QUEUE_KEY = 'n'
-
 
 class AlarmObserver:
     """
     Observes the state of the global alarms container and notifies interested
     parties whenever an update occurs
 
-    :param watchers: A list of functions to call on any update to the alarm container
-    :param mutex: Synchronization tool as many threads may notify watchers of updates
+    :param: watchers: A list of functions to call on any update to the alarm container
+    :type: list[Callable]
+
+    :param: mutex: Synchronization tool as many threads may notify watchers of updates
+    :type: Lock
     """
-    watchers = []
+
+    watchers: list[Callable] = []
     _mutex = Lock()
 
     @classmethod
@@ -43,17 +47,28 @@ class AlarmsContainer:
     A container for a global alarms dict that utilizes locking for multithreading
 
     :param alarms: The actual dictionary of alarms held
+    :type: dict[str, list[Alarm]]
+
     :param mutex: A lock used for mutating cls.alarms
+    :type: Lock
+
     :param observer: An Observer to monitor the state of the container
+    :type: AlarmObserver
     """
+
     observer = AlarmObserver()
-    alarms = {AlarmPriority.WARNING.name: [], AlarmPriority.LOW.name: [],
-              AlarmPriority.MEDIUM.name: [], AlarmPriority.HIGH.name: [],
-              AlarmPriority.CRITICAL.name: [], NEW_QUEUE_KEY: Queue()}
+    alarms: dict[str, list[Alarm]] = {
+        AlarmPriority.WARNING.name: [],
+        AlarmPriority.LOW.name: [],
+        AlarmPriority.MEDIUM.name: [],
+        AlarmPriority.HIGH.name: [],
+        AlarmPriority.CRITICAL.name: [],
+    }
+    new_alarms: Queue[Alarm] = Queue()
     mutex = Lock()
 
     @classmethod
-    def get_alarms(cls) -> dict[str, list[Alarm] | Queue]:
+    def get_alarms(cls) -> dict[str, list[Alarm]]:
         """
         Returns a shallow copy of <cls.alarms>
 
@@ -63,16 +78,16 @@ def get_alarms(cls) -> dict[str, list[Alarm] | Queue]:
             return cls.alarms.copy()
 
     @classmethod
-    def add_alarms(cls, alarms: list[Alarm],
-                   apm: Mapping[timedelta, Mapping[AlarmCriticality, AlarmPriority]]) -> None:
+    def add_alarms(
+        cls, alarms: list[Alarm], apm: Mapping[timedelta, Mapping[AlarmCriticality, AlarmPriority]]
+    ) -> None:
         """
         Updates the alarms global variable after acquiring the lock for it
 
-        :param dm: Holds information of data criticality and priority
         :param apm: Maps information on alarms to correct priority level
         :param alarms: The set of alarms to add to <cls.alarms>
         """
-        new_alarms = []
+        new_alarms: list[tuple[Alarm, AlarmCriticality]] = []
         times = [0, 5, 15, 30]
         timer_vals = []
         alarms.sort(reverse=True)
@@ -82,8 +97,8 @@ def add_alarms(cls, alarms: list[Alarm],
             with cls.mutex:
                 for alarm in alarms:
                     criticality = alarm.criticality
-                    alarm_timer_vals = []
-                    cls.alarms[NEW_QUEUE_KEY].put(alarm)
+                    alarm_timer_vals: list[timedelta] = []
+                    cls.new_alarms.put(alarm)
 
                     # Find the closest timeframe from 0, 5, 15, and 30 minutes from when the
                     # alarm was created to when it was actually confirmed
@@ -100,9 +115,9 @@ def add_alarms(cls, alarms: list[Alarm],
                         if alarm.event.creation_time < endpoint_time and not alarm_timer_vals:
                             priority_name = apm[timedelta(minutes=times[i - 1])][criticality]
                             priority = AlarmPriority(priority_name)
-                            cls.alarms[priority].append(alarm)
+                            cls.alarms[priority.name].append(alarm)
                             alarm.priority = priority
-                            new_alarms.append([alarm, priority])
+                            new_alarms.append((alarm, priority))
 
                             remaining_time = endpoint_time - alarm.event.creation_time
                             alarm_timer_vals.append(remaining_time)
@@ -112,7 +127,7 @@ def add_alarms(cls, alarms: list[Alarm],
                         priority = apm[timedelta(minutes=30)][criticality]
                         alarm.priority = priority
                         cls.alarms[priority.name].append(alarm)
-                        new_alarms.append([alarm, priority])
+                        new_alarms.append((alarm, priority))
                     timer_vals.append(alarm_timer_vals)
 
             # Now that the state of the alarms container has been update, notify watchers
@@ -120,7 +135,9 @@ def add_alarms(cls, alarms: list[Alarm],
 
             # Now, we need to create a timer thread for each alarm
             for i in range(len(new_alarms)):
-                alarm = new_alarms[i]
+                alarm_data: Alarm = new_alarms[i][0]
+                alarm_crit: AlarmCriticality = new_alarms[i][1]
+
                 associated_times = timer_vals[i]
 
                 for associated_time in associated_times:
@@ -128,30 +145,37 @@ def add_alarms(cls, alarms: list[Alarm],
                     # the index well later use into it
                     time_interval = len(times) - len(associated_times) + i
 
-                    new_timer = Timer(associated_time.seconds, cls._update_priority,
-                                      args=[alarm, timedelta(minutes=times[time_interval]), apm])
+                    new_timer = Timer(
+                        associated_time.seconds,
+                        cls._update_priority,
+                        args=[alarm_data, alarm_crit, timedelta(minutes=times[time_interval]), apm],
+                    )
                     new_timer.start()
 
     @classmethod
-    def _update_priority(cls, alarm_data: list[Alarm, AlarmPriority], time: timedelta,
-                         apm: Mapping[timedelta, Mapping[AlarmCriticality, AlarmPriority]]) -> None:
+    def _update_priority(
+        cls,
+        alarm: Alarm,
+        alarm_crit: AlarmCriticality,
+        time: timedelta,
+        apm: Mapping[timedelta, Mapping[AlarmCriticality, AlarmPriority]],
+    ) -> None:
         """
         Uses the alarm priority matrix with <time> to place <alarm> in the correct priority bin
         NOTE: we pass a list, and not a tuple, as we need to mutate said list
 
-        :param alarm_data: contains the current priority of the alarm and the alarm itself
+        :param alarm: The alarm to update priority of
+        :param alarm_crit: The base criticality of the alarm
         :param time: Time elapsed since the alarm came into effect
         :param apm: Maps information on alarms to correct priority level
         """
 
         with cls.mutex:
-            new_priority = apm[time][alarm_data[0].criticality]
-            cls.alarms[alarm_data[1]].remove(alarm_data[0])
-            cls.alarms[new_priority].append(alarm_data[0])
-            alarm_data[0].priority = new_priority
-            alarm_data[1] = new_priority
-        # Because of the nature of priorities, we need to notify both modification observers
-        # and addition observers
+            new_priority = apm[time][alarm.criticality]
+
+            cls.alarms[alarm_crit.name].remove(alarm)
+            cls.alarms[alarm_crit.name].append(alarm)
+            alarm.priority = new_priority
         cls.observer.notify_watchers()
 
     @classmethod
@@ -179,7 +203,7 @@ def remove_alarm(cls, alarm: Alarm) -> None:
         """
         with cls.mutex:
             for priority in cls.alarms:
-                if priority != NEW_QUEUE_KEY and alarm in cls.alarms[priority]:
+                if alarm in cls.alarms[priority]:
                     # Note: We don't consider the queue of new alarms, since by the time
                     # the alarm can be removed, it's already be taken out of the queue
                     cls.alarms[priority].remove(alarm)
diff --git a/src/astra/data/alarms.py b/src/astra/data/alarms.py
index 0bc9982..7e7feff 100644
--- a/src/astra/data/alarms.py
+++ b/src/astra/data/alarms.py
@@ -1,3 +1,9 @@
+"""
+This module defines classes and types relating to events and alarms.
+
+The classes defined here generally work the same way as they do in Panoptes.
+"""
+
 import functools
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
@@ -12,18 +18,24 @@
 
 @dataclass(frozen=True)
 class EventBase(ABC):
-    type: ClassVar[str] = ''
+    type: ClassVar[str] = ''  # Used for display purposes
     persistence: float | None
     description: str
 
     @property
     @abstractmethod
     def tags(self) -> Iterable[Tag]:
+        """A unified way to access all tags associated with an event base, regardless of type."""
         raise NotImplementedError
 
 
 @dataclass(frozen=True)
 class SimpleEventBase(EventBase):
+    """
+    An event base revolving around a single tag.
+
+    Equivalent to SingleTagEventBase in Panoptes.
+    """
     tag: Tag
 
     @override
@@ -34,6 +46,13 @@ def tags(self) -> Iterable[Tag]:
 
 @dataclass(frozen=True)
 class CompoundEventBase(EventBase):
+    """
+    An event base that consists of several inner event bases.
+
+    Equivalent to MultiTagEventBase in Panoptes.
+
+    Tags are currently automatically determined based on the tags of the inner event bases.
+    """
     event_bases: list[EventBase]
 
     @override
@@ -75,12 +94,12 @@ class SOEEventBase(CompoundEventBase):
 
 
 @dataclass(frozen=True)
-class AllEventBase(CompoundEventBase):
+class AllEventBase(CompoundEventBase):  # LogicalAndEventBase in Panoptes
     type: ClassVar[str] = 'Logical AND'
 
 
 @dataclass(frozen=True)
-class AnyEventBase(CompoundEventBase):
+class AnyEventBase(CompoundEventBase):  # LogicalOrEventBase in Panoptes
     type: ClassVar[str] = 'Logical OR'
 
 
@@ -98,10 +117,11 @@ class Event:
 
     @property
     def type(self) -> str:
+        """A string representation of the general type (static, setpoint, etc) of this event."""
         return type(self.base).type
 
 
-@functools.total_ordering
+@functools.total_ordering  # Criticalities/priorities can be compared in the natural way
 class AlarmCriticality(Enum):
     WARNING = 'WARNING'
     LOW = 'LOW'
@@ -141,6 +161,7 @@ class AlarmBase:
 @dataclass(frozen=False)
 class Alarm:
     event: Event
+    # As of now, no separate ID for alarms -- the id of the underlying event is used instead.
     criticality: AlarmCriticality
     priority: AlarmPriority
     acknowledged: bool
diff --git a/src/astra/data/config_manager.py b/src/astra/data/config_manager.py
index a17c8e8..915428c 100644
--- a/src/astra/data/config_manager.py
+++ b/src/astra/data/config_manager.py
@@ -1,3 +1,5 @@
+"""This module provides functionality for reading config files."""
+
 from yaml import safe_load
 
 # import parameters
@@ -11,12 +13,9 @@
 
 def _read_config_yaml(filename: str) -> None:
     """
-    Read in a yaml configuration file and parse it into a pandas dataframe.
-    The data in the "alarm" column is temporarily removed to
-    improve the readability of the dataframe.
+    Read in a yaml configuration file and save it to the database.
 
-    Args:
-        filename (str): full path to the config file
+    :param filename: full path to the config file
     """
     with open(filename, "r") as yaml_file:
         config_contents = safe_load(yaml_file)
@@ -34,24 +33,19 @@ def _read_config_yaml(filename: str) -> None:
             )
 
         # create or update the alarms in database
-        dictionary_of_alarms = config_contents["alarms"]
-        create_update_alarm(dictionary_of_alarms, device_id=device)
+        alarm_dicts = config_contents["alarms"]
+        create_update_alarm(alarm_dicts, device_id=device)
 
 
-def yaml_tag_parser(tag_dict: dict) -> dict:
+def yaml_tag_parser(tag_dict: dict) -> Parameter:
     """
-        A helper function for yaml reader that parse the tag
-        data into a dictionary.
+    Helper function for yaml reader: parse the tag data into a Parameter object.
 
-    Args:
-        tag_data (dict): a dictionary that contains the tag data
-                         (setpoint, dtype, display_units)
+    :param tag_dict: a dictionary that contains the tag data (setpoint, dtype, display_units)
 
-    Raises:
-        ValueError: when the dtype is not int, float, or bool
+    :raise ValueError: when the dtype is not int, float, or bool
 
-    Returns:
-        dict: a dictionary that contains the parsed tag data
+    :return: a Parameter object from the parsed tag data
     """
     tag_id = list(tag_dict.keys())[0]
     tag_data = tag_dict[tag_id]
@@ -60,6 +54,8 @@ def yaml_tag_parser(tag_dict: dict) -> dict:
     else:
         setpoint = None
 
+    dtype: type[int] | type[float] | type[bool]
+
     if tag_data["dtype"] == "int":
         dtype = int
     elif tag_data["dtype"] == "float":
@@ -88,7 +84,7 @@ def yaml_tag_parser(tag_dict: dict) -> dict:
     )
 
 
-# A dictionary that map file extensions to reader functions
+# A dictionary that maps file extensions to reader functions
 _file_readers = {
     "yaml": _read_config_yaml
     # Add more file types and reader functions as needed
@@ -97,12 +93,11 @@ def yaml_tag_parser(tag_dict: dict) -> dict:
 
 def read_config(filename: str) -> None:
     """
-    Read in a configuration file with the given path and return
-    it as a pandas dataframe.
-    Raise ValueError when the type of the configuration is incorrect.
+    Read in a configuration file with the given path and save it to the database.
+
+    :param filename: full path to the config file
 
-    Args:
-        filename (str): full path to the config file
+    :raise ValueError: when the type of the configuration is incorrect.
     """
     file_extension = filename.split(".")[-1]
     reader_func = _file_readers.get(file_extension)
diff --git a/src/astra/data/data_manager.py b/src/astra/data/data_manager.py
index ec19e82..8fdb144 100644
--- a/src/astra/data/data_manager.py
+++ b/src/astra/data/data_manager.py
@@ -137,10 +137,9 @@ def alarms(self) -> AlarmsContainer:
 
     def add_alarms(self, alarms: list[Alarm]) -> None:
         """
-        Updates the alarms global variable after acquiring the lock for it
+        Add alarms to the alarm container of this DataManager.
 
-        :param dm: Holds information of data criticality and priority
-        :param alarms: The set of alarms to add to <cls.alarms>
+        :param alarms: The list of alarms to add.
         """
         self._alarm_container.add_alarms(alarms, self.alarm_priority_matrix)
 
@@ -156,8 +155,8 @@ def alarm_priority_matrix(self) -> Mapping[timedelta, Mapping[AlarmCriticality,
         w, l, m, h, c = AlarmCriticality
         # fmt: off
         return dict(reversed([
-            (timedelta(minutes=0), {w: w, l: l, m: l, h: m, c: c}),  # noqa E251
-            (timedelta(minutes=5), {w: w, l: l, m: m, h: h, c: c}),  # noqa E251
+            (timedelta(minutes= 0), {w: w, l: l, m: l, h: m, c: c}),  # noqa E251
+            (timedelta(minutes= 5), {w: w, l: l, m: m, h: h, c: c}),  # noqa E251
             (timedelta(minutes=15), {w: w, l: l, m: m, h: h, c: c}),
             (timedelta(minutes=30), {w: w, l: m, m: h, h: c, c: c}),
         ]))
diff --git a/src/astra/data/database/db_initializer.py b/src/astra/data/database/db_initializer.py
index 4c801f8..67ee962 100644
--- a/src/astra/data/database/db_initializer.py
+++ b/src/astra/data/database/db_initializer.py
@@ -1,6 +1,4 @@
-"""
-This module initializes the database and provides the schema for the tables.
-"""
+"""This module initializes the database and provides the schema for the tables."""
 from datetime import datetime
 from sqlalchemy import (
     create_engine,
@@ -31,10 +29,10 @@ def set_sqlite_pragma(dbapi_connection, connection_record):
 
 
 def initialize_sqlite_db():
-    """initializes the sqlite database and creates the tables
+    """
+    Initialize the sqlite database and create the tables.
 
-    Returns:
-        an Engine, which the Session will use for connection
+    :return: An Engine, which the Session will use for connection.
     """
     engine = create_engine("sqlite:///astra.db")
     Base.metadata.create_all(engine)
@@ -42,24 +40,21 @@ def initialize_sqlite_db():
 
 
 class Device(Base):
-    """A table that holds the device data.
-
-        device_id (int): unique id for device (primary key)
-        device_name (Optional[str | None]): device name
-        device_description (Optional[str | None]): device description
-        tags (Set["Tag"]): tags of the device (one-to-many relationship)
-        alarms (Set["Alarm"]): alarms of the device (one-to-many relationship)
+    """
+    A table that holds the device data.
 
-    Args:
-        Base: a declarative base class that helps mapping to the relational
-              schema
+        device_id: unique id for device (primary key)
+        device_name: device name
+        device_description: device description
+        tags: tags of the device (one-to-many relationship)
+        alarms: alarms of the device (one-to-many relationship)
     """
 
     __tablename__ = "Device"
 
     device_id: Mapped[int] = mapped_column(primary_key=True)
-    device_name: Mapped[str | None] = mapped_column(unique=True)
-    device_description: Mapped[str | None] = mapped_column()
+    device_name: Mapped[str] = mapped_column(unique=True)
+    device_description: Mapped[str] = mapped_column()
 
     # one-to-many relationship
     tags = relationship(
@@ -80,18 +75,15 @@ class Device(Base):
 
 
 class Tag(Base):
-    """A table that holds the tag data.
-
-         tag_id (int): unique id for tag
-         tag_name (str): tag name
-         tag_parameter ()
-         device_id (int): unique id for device (foreign key)
-         device (Device): device of the tag (many-to-one relationship)
-         data (List["Data"]): data of the tag (one-to-many relationship
-
-    Args:
-        Base: a declarative base class that helps mapping to the relational
-              schema
+    """
+    A table that holds the tag data.
+
+         tag_id: unique id for tag
+         tag_name: tag name
+         tag_parameter: dictionary holding other configuration data pertaining to the tag
+         device_id: unique id for device (foreign key)
+         device: device of the tag (many-to-one relationship)
+         data: data of the tag (one-to-many relationship)
     """
 
     __tablename__ = "Tag"
@@ -126,18 +118,14 @@ class Tag(Base):
 
 
 class Alarm(Base):
-    """A table that holds the alarm data.
-
-        alarm_id (int): unique id for alarm (primary key)
-        alarm_criticality (str): criticality of the alarm
-                                 (Warning, Low, Medium, High, Critical)
-        alarm_data (dict): data of the alarm
-        device_id (int): unique id for device (foreign key)
-        device (Device): device of the alarm (many-to-one relationship)
-
-    Args:
-        Base: a declarative base class that helps mapping to the relational
-              schema
+    """
+    A table that holds the alarm data.
+
+        alarm_id: unique id for alarm (primary key)
+        alarm_criticality: criticality of the alarm (Warning, Low, Medium, High, Critical)
+        alarm_data: data of the alarm
+        device_id: unique id for device (foreign key)
+        device: device of the alarm (many-to-one relationship)
     """
 
     __tablename__ = "Alarm"
@@ -154,18 +142,15 @@ class Alarm(Base):
 
 
 class Data(Base):
-    """A table that holds the data for the tags with timestamps.
-
-        data_id (int): unique id for data (primary key)
-        timestamp (datetime): timestamp of the data
-        value (float | None): raw value of the data (before conversion)
-        last_modified (datetime): last modified date of the data
-        tag_id (int): unique id for tag (foreign key)
-        tag (Tag): tag of the data (many-to-one relationship)
-
-    Args:
-        Base: a declarative base class that helps mapping to the relational
-              schema
+    """
+    A table that holds the data for the tags with timestamps.
+
+        data_id: unique id for data (primary key)
+        timestamp: timestamp of the data
+        value: raw value of the data (before conversion)
+        last_modified: last modified date of the data
+        tag_id: unique id for tag (foreign key)
+        tag: tag of the data (many-to-one relationship)
     """
 
     __tablename__ = "Data"
diff --git a/src/astra/data/database/db_manager.py b/src/astra/data/database/db_manager.py
index 91ed5f4..0ab6f15 100644
--- a/src/astra/data/database/db_manager.py
+++ b/src/astra/data/database/db_manager.py
@@ -1,6 +1,9 @@
+"""This module provides functions for interacting with the database."""
+
+from collections.abc import Sequence
 from datetime import datetime
 
-from sqlalchemy import func
+from sqlalchemy import func, Row
 from sqlalchemy import select, insert, update, delete
 from sqlalchemy.orm import sessionmaker
 
@@ -23,13 +26,14 @@
 
 def create_update_tag(tag_name: str, tag_parameter: dict, device_id: int):
     """
-        create (if not exist) or update the tag in database
-        tag exists means the combination of tag_name and device_id
-        exists in database
-    Args:
-        tag_name (str): the name of the tag
-        tag_parameter (dict): the parameter of the tag
-        device_id (int): the id of the device
+    Create (if it does not already exist) or update a tag in the database.
+
+    A tag exists if the combination of tag_name and device_id
+    exists in the database.
+
+    :param tag_name: the name of the tag
+    :param tag_parameter: the parameter of the tag
+    :param device_id: the id of the device
     """
     with Session.begin() as session:
         # check if tag exists in database
@@ -63,9 +67,9 @@ def create_update_tag(tag_name: str, tag_parameter: dict, device_id: int):
 
 def create_update_device(metadata: dict):
     """
-        create (if not exist) or update the device in database
-    Args:
-        metadata (_type_): metadata of the configuration file
+    Create (if it does not already exist) or update a device in the database.
+
+    :param metadata: metadata from the configuration file of the device
     """
     device_id = None
     device = get_device(metadata["device"])
@@ -96,29 +100,28 @@ def create_update_device(metadata: dict):
     return device_id
 
 
-def create_update_alarm(dictionary_of_alarms: dict, device_id: int):
+def create_update_alarm(alarm_dicts: Sequence[dict], device_id: int):
     """
-        if alarm for the device exists in database, delete the old alarm and
-        create new alarms in database based on the dictionary of alarms
-    Args:
-        dictionary_of_alarms (dict): a dictionary that contains the alarm's
-                                     criticality and data
-        device_id (int): the id of the device
+    Create new alarms in the database based on the given alarm dictionaries.
+    Delete any preexisting alarms for the given device.
+
+    :param alarm_dicts: a sequence of dictionaries containing alarm criticalities and data
+    :param device_id: the id of the device
     """
     with Session.begin() as session:
-        # check if alarm for the device exists in database
+        # check if alarms for the device exist in database
         check_stmt = select(Alarm).where(
             Alarm.device_id == device_id,
         )
         alarm_exist = session.execute(check_stmt).first()
         if alarm_exist:
-            # delete the old alarm
+            # delete the old alarms
             delete_stmt = delete(Alarm).where(Alarm.device_id == device_id)
             session.execute(delete_stmt)
 
         # create new alarms in database
         alarm_list = []
-        for alarm_dict in dictionary_of_alarms:
+        for alarm_dict in alarm_dicts:
             alarm = Alarm(
                 alarm_criticality=alarm_dict["criticality"],
                 alarm_data=alarm_dict["event"],
@@ -130,43 +133,38 @@ def create_update_alarm(dictionary_of_alarms: dict, device_id: int):
 
 def get_device(device_name: str) -> Device | None:
     """
-        check if device exists in database and return the device
-    Args:
-        device_name (str): the name of the device
+    Get the device with the given name, if one exists.
 
-    Returns:
-        Device | None: the device with the given name, or None if none exists
+    :param device_name: the name of the device
+
+    :return: the device with the given name, or None if none exists
     """
     with Session.begin() as session:
-        # check if device exists in database
-        device_exist = (
+        return (
             session.query(Device)
             .filter(Device.device_name == device_name)
             .first()
         )
-        return None if device_exist is None else device_exist
 
 
 def device_exists(device_name: str) -> bool:
     """
-        check if device exists in database
-    Args:
-        device_name (str): the name of the device
+    Check if a device with the given name exists in the database.
 
-    Returns:
-        bool: True if device exists in database, False otherwise
+    :param device_name: the name of the device
+
+    :return: True if the device exists in database, False otherwise
     """
     return get_device(device_name) is not None
 
 
-def get_tags_for_device(device_name: str) -> list[tuple[str, dict]]:
+def get_tags_for_device(device_name: str) -> Sequence[Row[tuple[str, dict]]]:
     """
-        return all tags for the given device
-    Args:
-        device_name (str): the name of the device
+    Return all tags for the given device.
+
+    :param device_name: the name of the device
 
-    Returns:
-        list[tuple[str, dict]]: a list of tuples of (tag_name, tag_parameter)
+    :return: a sequence of (tag_name, tag_parameter)
     """
     with Session.begin() as session:
         select_stmt = (
@@ -177,14 +175,13 @@ def get_tags_for_device(device_name: str) -> list[tuple[str, dict]]:
         return session.execute(select_stmt).all()
 
 
-def get_alarm_base_info(device_name: str) -> list[tuple[str, dict]]:
+def get_alarm_base_info(device_name: str) -> Sequence[Row[tuple[str, dict]]]:
     """
-        return all alarm info for the given device
-    Args:
-        device_name (str): the name of the device
+    Return all alarm info for the given device.
 
-    Returns:
-        list[tuple[str, dict]]: a list of tuples of (alarm_criticality, alarm_data)
+    :param device_name: the name of the device
+
+    :return: a sequence of (alarm_criticality, alarm_data)
     """
     with Session.begin() as session:
         select_stmt = (
@@ -195,14 +192,13 @@ def get_alarm_base_info(device_name: str) -> list[tuple[str, dict]]:
         return session.execute(select_stmt).all()
 
 
-def get_tag_id_name(device_name: str) -> list[tuple[int, str]]:
+def get_tag_id_name(device_name: str) -> Sequence[Row[tuple[int, str]]]:
     """
-        A helper function that fetches the tags for a device and
-        converts that to a list of (tag_id, tag_name)
-    Args:
-        device_name (str): the name of the device
-    Returns:
-        list[tuple[int, str]]: a list of tuples of (tag_id, tag_name)
+    Helper function: fetch the IDs and names of the tags for a device.
+
+    :param device_name: the name of the device
+
+    :return: a sequence of (tag_id, tag_name)
     """
     with Session.begin() as session:
         tag_id_name = (
@@ -217,17 +213,15 @@ def num_telemetry_frames(
     device_name: str, start_time: datetime | None, end_time: datetime | None
 ) -> int:
     """
-        Number of telemetry frames for a device between start_time and end_time
-        For this function and all below functions: if start_time/end_time is None,
-        treat as if there are no restrictions in the relevant direction.
-    Args:
-        device_name (str): name of the device
-        start_time (datetime | None): the start time of the data
-        end_time (datetime | None): the end time of the data
-
-    Returns:
-        int: the number of telemetry frames for the given device between
-             start_time and end_time
+    Number of telemetry frames for a device between start_time and end_time
+    For this function and all below functions: if start_time/end_time is None,
+    treat as if there are no restrictions in the relevant direction.
+
+    :param device_name: name of the device
+    :param start_time: the start time of the data
+    :param end_time: the end time of the data
+
+    :return: the number of telemetry frames for the given device between start_time and end_time
     """
     device = get_device(device_name)
     with Session.begin() as session:
@@ -244,115 +238,33 @@ def num_telemetry_frames(
                 select_stmt = select_stmt.where(Data.timestamp >= start_time)
             if end_time is not None:
                 select_stmt = select_stmt.where(Data.timestamp <= end_time)
-            return session.execute(select_stmt).scalar()
+            result = session.execute(select_stmt).scalar()
+            assert result is not None  # The way the query is constructed, shouldn't ever be None
+            return result
         else:
             raise ValueError("Device does not exist in database")
 
 
-# def get_timestamp_by_index(
-#     device_name: str,
-#     start_time: datetime | None,
-#     end_time: datetime | None,
-#     index: int,
-# ) -> datetime:
-#     """
-#         The <index>th timestamp for a device between start_time and end_time
-#         May assume: 0 <= <index> < <number of timestamps>
-#     Args:
-#         device_name (str): name of the device
-#         start_time (datetime | None): the start time of the data
-#         end_time (datetime | None): the end time of the data
-#         index (int): the index of the timestamp
-
-#     Returns:
-#         datetime: the ith timestamp for the given device between start_time
-#                   and end_time
-#     """
-#     device = get_device(device_name)
-#     with Session.begin() as session:
-#         if device:
-#             device_name = device.device_name
-#             # tag_id_name = get_tag_id_name(device_name)
-#             # tag_ids = [tag_id for tag_id, _ in tag_id_name]
-#             select_stmt = (
-#                 select(Data.timestamp)
-#                 .where(
-#                     Device.device_name == device_name,
-#                 )
-#                 .where(
-#                     Tag.device_id == Device.device_id,
-#                 )
-#                 .where(
-#                     Tag.tag_id == Data.tag_id,
-#                 )
-#                 .group_by(Data.timestamp)
-#                 .order_by(Data.timestamp)
-#                 .limit(index + 1)
-#             )
-#             if start_time is not None:
-#                 select_stmt = select_stmt.where(Data.timestamp >= start_time)
-#             if end_time is not None:
-#                 select_stmt = select_stmt.where(Data.timestamp <= end_time)
-#             return session.execute(select_stmt).all()[-1][0]
-#         else:
-#             raise ValueError("Device does not exist in database")
-
-
-# def get_telemetry_data_by_timestamp(
-#     device_name: str, tags: set[str] | None, timestamp: datetime
-# ) -> list[tuple[str, float]]:
-#     """
-#         All the data for the telemetry frame with the given timestamp for a device.
-#         May assume: timestamp is valid for the device
-#     Args:
-#         device_name (str): name of the device
-#         tags (set[str]): set of tags for the data to be returned
-#         timestamp (datetime): the timestamp of the data
-
-#     Returns:
-#         list[tuple[str, float]]: a list of tuple (tag_name, value) for the given
-#                                  device/tags with the given timestamp
-#     """
-#     device = get_device(device_name)
-#     with Session.begin() as session:
-#         if device:
-#             device_id = device.device_id
-#             select_stmt = (
-#                 select(Tag.tag_name, Data.value)
-#                 .where(Data.tag_id == Tag.tag_id)
-#                 .where(Tag.device_id == device_id)
-#                 .where(Data.timestamp == timestamp)
-#             )
-#             if tags is not None:
-#                 select_stmt = select_stmt.where(Tag.tag_name.in_(tags))
-
-#             return session.execute(select_stmt).all()
-#         else:
-#             raise ValueError("Device does not exist in database")
-
-
 def get_telemetry_data_by_index(
     device_name: str,
     tags: set[str] | None,
     start_time: datetime | None,
     end_time: datetime | None,
     index: int,
-) -> tuple[list[tuple[str, float]], datetime]:
+) -> tuple[Sequence[Row[tuple[str, float | None]]], datetime]:
     """
-        All the data for the telemetry frame with the <index>th timestamp
-        for a device between start_time and end_time.
-        May assume: 0 <= <index> < <number of timestamps>
-    Args:
-        device_name (str): name of the device
-        tags (set[str]): set of tags for the data to be returned
-        start_time (datetime | None): the start time of the data
-        end_time (datetime | None): the end time of the data
-        index (int): the index of the timestamp
-
-    Returns:
-        tuple[list[tuple[str, float]], datetime]: a tuple that contains
-         1. a list of tuple (tag_name, value) for the given device/tags with the
-            given timestamp
+    All the data for the telemetry frame with the <index>th timestamp
+    for a device between start_time and end_time.
+    Precondition: 0 <= <index> < <number of timestamps>
+
+    :param device_name: name of the device
+    :param tags: set of tags for the data to be returned
+    :param start_time: the start time of the data
+    :param end_time: the end time of the data
+    :param index: the index of the timestamp
+
+    :return: a two-element tuple that contains:
+         1. a sequence of (tag_name, value) for the given device/tags with the given timestamp;
          2. the timestamp for the data
     """
     device = get_device(device_name)
@@ -374,7 +286,7 @@ def get_telemetry_data_by_index(
                 sub_query = sub_query.filter(Data.timestamp >= start_time)
             if end_time is not None:
                 sub_query = sub_query.filter(Data.timestamp <= end_time)
-            timestamp = sub_query.limit(1).offset(index).all()
+            timestamp = sub_query.limit(1).offset(index).scalar()
 
             query = (
                 session.query(Tag.tag_name, Data.value)
@@ -382,14 +294,14 @@ def get_telemetry_data_by_index(
                 .join(Tag.device)
                 .filter(
                     Device.device_name == device_name,
-                    Data.timestamp == timestamp[0][0],
+                    Data.timestamp == timestamp,
                 )
             )
 
             if tags is not None:
                 query = query.filter(Tag.tag_name.in_(tags))
 
-            return (query.all(), timestamp[0][0])
+            return query.all(), timestamp
     else:
         raise ValueError("Device does not exist in database")
 
@@ -400,23 +312,20 @@ def get_telemetry_data_by_tag(
     end_time: datetime | None,
     tag: str,
     step: int = 1,
-) -> list[tuple[float, datetime]]:
+) -> Sequence[Row[tuple[float, datetime]]]:
     """
-        Every <step>th data for the given tag for a device between
-        start_time and end_time
-        Should be sorted by time -- 0 earliest, <num frames> - 1 latest
-        May assume: tag exists for the given device
-    Args:
-        device_name (str): name of the device
-        start_time (datetime | None): the start time of the data
-        end_time (datetime | None): the end time of the data
-        tag (str): the tag of the data
-        step (int): the step of choosing the data within the given time range
-
-    Returns:
-        list[tuple[float, datetime]]:
-            a list of tuple (value, timestamp) for the given device/tag between
-            start_time and end_time
+    Every <step>th data for the given tag for a device between start_time and end_time.
+    Should be sorted by time -- 0 earliest, <num frames> - 1 latest.
+    Precondition: tag exists for the given device
+
+    :param device_name: name of the device
+    :param start_time: the start time of the data
+    :param end_time: the end time of the data
+    :param tag: the tag of the data
+    :param step: the step of choosing the data within the given time range
+
+    :return: a sequence of (value, timestamp) for the given device/tag
+    between start_time and end_time
     """
     device = get_device(device_name)
     with Session.begin() as session:
@@ -452,9 +361,9 @@ def get_telemetry_data_by_tag(
 
 def get_device_data() -> list[tuple[str, str]]:
     """
-        Return all the names and descriptions of devices in the database
-    Returns:
-        list[tuple[str, str]]: a list of (device name, device description) tuples
+    Return all the names and descriptions of devices in the database.
+
+    :return: a sequence of (device name, device description)
     """
     with Session.begin() as session:
         select_stmt = select(Device.device_name, Device.device_description)
@@ -463,10 +372,10 @@ def get_device_data() -> list[tuple[str, str]]:
 
 def delete_device(device_name: str) -> None:
     """
-        Delete the device with the given name from the database
-        Note that all the corresponding tags and data will be deleted as well
-    Args:
-        device_name (str): the name of the device
+    Delete the device with the given name from the database.
+    Note that all the corresponding tags and data will be deleted as well.
+
+    :param device_name: the name of the device
     """
     device = get_device(device_name)
     with Session.begin() as session:
diff --git a/src/astra/data/dict_parsing.py b/src/astra/data/dict_parsing.py
index f171162..6500822 100644
--- a/src/astra/data/dict_parsing.py
+++ b/src/astra/data/dict_parsing.py
@@ -24,7 +24,11 @@
     AllEventBase,
     AnyEventBase,
 )
-from astra.data.parameters import DisplayUnit, Parameter, ParameterValue, Tag
+from astra.data.parameters import DisplayUnit, Parameter, Tag
+
+
+# Define ParameterValue here as a UnionType to work around some mypy thing
+ParameterValue: UnionType = bool | int | float
 
 
 class ParsingError(Exception):
@@ -53,18 +57,23 @@ def add(self, element: int | str) -> 'Path':
         return Path(self.base, self.elements + [element])
 
     def __str__(self):
+        """
+        Format this path in a human-readable way.
+
+        Current format looks something like: base[index0].key0[index1][index2].key1.key2
+        """
         return self.base + ''.join(
             (f'[{element}]' if isinstance(element, int) else f'.{element}')
             for element in self.elements
         )
 
 
-def _format_type(t: type) -> str:
+def _format_type(t: type | UnionType) -> str:
     # Stringify types in a nice way.
     return repr('None' if t is NoneType else t.__name__ if isinstance(t, type) else str(t))
 
 
-def _check_type[T](path: Path, value: object, expected_type: type[T]) -> T:
+def _check_type(path: Path, value: object, expected_type: type | UnionType) -> Any:
     # Return the value unchanged if it is of the expected type and raise an error otherwise.
     if isinstance(value, expected_type):
         return value
@@ -98,6 +107,17 @@ class PathedList:
     _list: list
 
     def __init__(self, path: Path, value: object):
+        """
+        Construct a PathedList.
+
+        :param path:
+            The path for the PathedList.
+        :param value:
+            The underlying list for the PathedList, validated as a list during runtime.
+
+        :raise ParsingError:
+            If value is not a list.
+        """
         self._path = path
         self._list = _check_type(path, value, list)
 
@@ -162,6 +182,17 @@ class PathedDict:
     _dict: dict
 
     def __init__(self, path: Path, value: object):
+        """
+        Construct a PathedDict.
+
+        :param path:
+            The path for the PathedDict.
+        :param value:
+            The underlying dict for the PathedDict, validated as a dict during runtime.
+
+        :raise ParsingError:
+            If value is not a dict.
+        """
         self._path = path
         self._dict = _check_type(path, value, dict)
 
diff --git a/src/astra/data/parameters.py b/src/astra/data/parameters.py
index 2edf7b6..037cc51 100644
--- a/src/astra/data/parameters.py
+++ b/src/astra/data/parameters.py
@@ -1,3 +1,5 @@
+"""This module defines various types relevant to tags and parameters."""
+
 from dataclasses import dataclass
 from typing import NewType
 
@@ -7,6 +9,13 @@
 
 @dataclass(frozen=True)
 class DisplayUnit:
+    """
+    Information on how to display a value, separate from the storage of the value.
+
+    More or less follows Panoptes.
+
+    value --display-> f'{multiplier * value + constant} {symbol}'
+    """
     description: str
     symbol: str
     multiplier: float
@@ -15,6 +24,13 @@ class DisplayUnit:
 
 @dataclass(frozen=True)
 class Parameter:
+    """
+    A specific kind of telemetry data to monitor.
+
+    Equivalent to TagEntry in Panoptes.
+
+    Restriction: for dtype bool, display_units should always be None.
+    """
     tag: Tag
     description: str
     dtype: type[ParameterValue]
diff --git a/src/astra/data/telemetry_data.py b/src/astra/data/telemetry_data.py
index 36b7c63..865d606 100644
--- a/src/astra/data/telemetry_data.py
+++ b/src/astra/data/telemetry_data.py
@@ -62,7 +62,7 @@ def tags(self) -> Iterable[Tag]:
         """The tags for this TelemetryData."""
         return self._tags
 
-    def _convert_dtype(self, tag: Tag, value: float | None) -> ParameterValue:
+    def _convert_dtype(self, tag: Tag, value: float | None) -> ParameterValue | None:
         # Convert the float telemetry value from the database
         # to the correct type for the given parameter.
         if value is None:
diff --git a/src/astra/data/telemetry_manager.py b/src/astra/data/telemetry_manager.py
index e221745..671b175 100644
--- a/src/astra/data/telemetry_manager.py
+++ b/src/astra/data/telemetry_manager.py
@@ -1,3 +1,5 @@
+"""This module provides functionality for reading telemetry files."""
+
 from datetime import datetime
 
 import h5py
@@ -19,8 +21,9 @@ def _read_telemetry_hdf5(filename: str) -> datetime:
     datetime.
     The data is then written to the database.
 
-    Args:
-        filename (str): full path to the telemetry file
+    :param filename: full path to the telemetry file
+
+    :return: earliest timestamp in the telemetry data
     """
 
     with h5py.File(filename, "r") as h5file:
@@ -37,6 +40,7 @@ def _read_telemetry_hdf5(filename: str) -> datetime:
                 len(values) for values in h5file["telemetry"].values()
             }
             # get the telemetry data and use pandas to store it in a dataframe
+            # use None for parameters not included in the telemetry file
             telemetry_data = pd.DataFrame(
                 {
                     header: values
@@ -48,14 +52,6 @@ def _read_telemetry_hdf5(filename: str) -> datetime:
                 }
             )
 
-            # # create a dataframe from the telemetry data
-            # telemetry_data = pd.DataFrame(
-            #     {
-            #         header: values
-            #         for header, values in h5file["telemetry"].items()
-            #     }
-            # )
-
             # write the data to database
             earliest_added_timestamp = _dataframe_to_database(
                 telemetry_data, device
@@ -71,8 +67,9 @@ def _read_telemetry_yaml(filename: str) -> datetime:
     """
     Read in a yaml telemetry file and store it in the database.
 
-    Args:
-        filename (str): full path to the telemetry file
+    :param filename: full path to the telemetry file
+
+    :return: earliest timestamp in the telemetry data
     """
     with open(filename, "r") as yaml_file:
         # Load the yaml file and get the data
@@ -91,6 +88,7 @@ def _read_telemetry_yaml(filename: str) -> datetime:
                 len(values) for values in telemetry_data.values()
             }
             # get the telemetry data and use pandas to store it in a dataframe
+            # use None for parameters not included in the telemetry file
             telemetry_dataframe = pd.DataFrame(
                 {header: values for header, values in telemetry_data.items()}
                 | {
@@ -99,8 +97,7 @@ def _read_telemetry_yaml(filename: str) -> datetime:
                 }
             )
 
-            # # create a dataframe from the telemetry data
-            # telemetry_dataframe = pd.DataFrame(telemetry_data)
+            # create a dataframe from the telemetry data
             earliest_added_timestamp = _dataframe_to_database(
                 telemetry_dataframe, device
             )
@@ -111,7 +108,7 @@ def _read_telemetry_yaml(filename: str) -> datetime:
             raise ValueError("Device does not exist in database")
 
 
-# A dictionary that map file extensions to reader functions
+# A dictionary that maps file extensions to reader functions
 _file_readers = {
     "h5": _read_telemetry_hdf5,
     "yaml": _read_telemetry_yaml
@@ -122,13 +119,12 @@ def _read_telemetry_yaml(filename: str) -> datetime:
 def _dataframe_to_database(
     telemetry_data: pd.DataFrame, device: Device
 ) -> datetime:
-    """A helper function that stores a pandas dataframe to the database.
+    """Helper function: save data from a pandas dataframe to the database.
 
-    Args:
-        telemetry_data (pd.DataFrame): the telemetry data
+    :param telemetry_data: the telemetry data in the form of a pandas dataframe --
+    should have an EPOCH column for timestamps and one column for each parameter
 
-    Returns:
-        datetime: the earliest timestamp of the telemetry data
+    :return: earliest timestamp in the telemetry data
     """
     # convert EPOCH to datetime
     telemetry_data["timestamp"] = pd.to_datetime(
@@ -139,7 +135,7 @@ def _dataframe_to_database(
 
     # convert the dataframe to long format for database insertion
     telemetry_data = pd.melt(
-        telemetry_data, id_vars="timestamp", value_name="value"
+        telemetry_data, id_vars=["timestamp"], value_name="value"
     )
     telemetry_data.rename(columns={"variable": "tag_name"}, inplace=True)
 
@@ -168,12 +164,13 @@ def _dataframe_to_database(
 
 def read_telemetry(filename: str) -> datetime:
     """
-    Read in a telemetry file with the given path and return
-    it as a pandas dataframe.
-    Raise ValueError when the type of the telemetry is incorrect.
+    Read in a telemetry file with the given path and save the telemetry data in the database.
+
+    :param filename: full path to the telemetry file
+
+    :raise ValueError: when the type of the telemetry is incorrect
 
-    Args:
-        filename (str): full path to the telemetry file
+    :return: earliest timestamp in the telemetry data
     """
     file_extension = filename.split(".")[-1]
     reader_func = _file_readers.get(file_extension)
diff --git a/src/astra/frontend/__pycache__/__init__.cpython-310.pyc b/src/astra/frontend/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index ff3cab0..0000000
Binary files a/src/astra/frontend/__pycache__/__init__.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/__init__.cpython-312.pyc b/src/astra/frontend/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index a5bf2c4..0000000
Binary files a/src/astra/frontend/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/model.cpython-310.pyc b/src/astra/frontend/__pycache__/model.cpython-310.pyc
deleted file mode 100644
index 7cba56f..0000000
Binary files a/src/astra/frontend/__pycache__/model.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/model.cpython-312.pyc b/src/astra/frontend/__pycache__/model.cpython-312.pyc
deleted file mode 100644
index 54c03e9..0000000
Binary files a/src/astra/frontend/__pycache__/model.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view.cpython-310.pyc b/src/astra/frontend/__pycache__/view.cpython-310.pyc
deleted file mode 100644
index 18320fd..0000000
Binary files a/src/astra/frontend/__pycache__/view.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view.cpython-312.pyc b/src/astra/frontend/__pycache__/view.cpython-312.pyc
deleted file mode 100644
index cd0eb2c..0000000
Binary files a/src/astra/frontend/__pycache__/view.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view_draw_functions.cpython-310.pyc b/src/astra/frontend/__pycache__/view_draw_functions.cpython-310.pyc
deleted file mode 100644
index b8ed819..0000000
Binary files a/src/astra/frontend/__pycache__/view_draw_functions.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view_draw_functions.cpython-312.pyc b/src/astra/frontend/__pycache__/view_draw_functions.cpython-312.pyc
deleted file mode 100644
index 8eb887e..0000000
Binary files a/src/astra/frontend/__pycache__/view_draw_functions.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view_model.cpython-310.pyc b/src/astra/frontend/__pycache__/view_model.cpython-310.pyc
deleted file mode 100644
index f1e92b6..0000000
Binary files a/src/astra/frontend/__pycache__/view_model.cpython-310.pyc and /dev/null differ
diff --git a/src/astra/frontend/__pycache__/view_model.cpython-312.pyc b/src/astra/frontend/__pycache__/view_model.cpython-312.pyc
deleted file mode 100644
index 20c2873..0000000
Binary files a/src/astra/frontend/__pycache__/view_model.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/frontend/alarm_view.py b/src/astra/frontend/alarm_view.py
index a6e25ff..d25d609 100644
--- a/src/astra/frontend/alarm_view.py
+++ b/src/astra/frontend/alarm_view.py
@@ -10,27 +10,38 @@
 from astra.frontend.timerange_input import OperationControl, TimerangeInput
 from .tag_searcher import AlarmTagSearcher
 from ..data.alarms import Alarm
+from ..data.parameters import Tag
 from ..usecase.alarms_request_receiver import AlarmsRequestReceiver
 
 
 class AlarmView:
+    """Contains the GUI elements of the Alarm Tab"""
 
     def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
+        """
+        Initializes the elements of the Alarm Tab
+
+        :param frame: The notebook of tabs which this view should be inserted into
+        :param num_rows: Used for scaling to fullscreen
+        :param dm: Contains all data known to the program
+        """
         self.dm = dm
         self.overall_frame = Frame(frame)
 
         self.controller = AlarmsRequestReceiver()
 
+        # Configuring row and column weightings
         for i in range(num_rows):
             self.overall_frame.grid_rowconfigure(i, weight=1)
 
         self.overall_frame.grid_columnconfigure(0, weight=0)
         self.overall_frame.grid_columnconfigure(1, weight=1)
 
+        # Configuring search widget
         self.alarms_searcher = AlarmTagSearcher(num_rows, self.overall_frame, self.dm,
                                                 self.alarms_searcher_update)
 
-        # alarms filters (for the table)
+        # alarms filter options (for the table)
         alarms_tag_table = Frame(self.overall_frame)
         style = ttk.Style()
         style.theme_use('clam')
@@ -39,50 +50,56 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
         self.dangers = ['WARNING', 'LOW', 'MEDIUM', 'HIGH', 'CRITICAL']
         self.types = ['RATE_OF_CHANGE', 'STATIC', 'THRESHOLD', 'SETPOINT', 'SOE', 'L_AND', 'L_OR']
 
+        # Acknowledgement filter
         button = Button(alarms_tag_table, text='Show new alarms only', relief='raised',
-                        command=lambda: self.flick_new())
+                        command=lambda: self._flick_new())
         button.grid(sticky='w', row=0, columnspan=8)
         self.alarms_button_new = button
 
+        # Priority filter
         self.alarms_buttons_priority = []
         label = Label(alarms_tag_table, text='Filter priority:')
         label.grid(sticky='news', row=1, column=0)
 
         for i in range(len(self.dangers)):
             button = Button(alarms_tag_table, text=self.dangers[i], relief='sunken',
-                            command=lambda x=i: self.flick_priority(x))
+                            command=lambda x=i: self._flick_priority(x))
             button.grid(sticky='news', row=1, column=i + 1)
             self.alarms_buttons_priority.append(button)
 
+        # Criticality filter
         label = Label(alarms_tag_table, text='Filter criticality:')
         label.grid(sticky='news', row=2, column=0)
         self.alarms_buttons_criticality = []
 
         for i in range(len(self.dangers)):
             button = Button(alarms_tag_table, text=self.dangers[i], relief='sunken',
-                            command=lambda x=i: self.flick_criticality(x))
+                            command=lambda x=i: self._flick_criticality(x))
             button.grid(sticky='news', row=2, column=i + 1)
             self.alarms_buttons_criticality.append(button)
 
+        # Register time filter
         TimerangeInput(
-            alarms_tag_table, 'Registered', self.update_alarm_registered_times
+            alarms_tag_table, 'Registered', self._update_alarm_registered_times
         ).grid(sticky='W', row=3, columnspan=8)
 
+        # Confirm time filter
         TimerangeInput(
-            alarms_tag_table, 'Confirmed', self.update_alarm_confirmed_times
+            alarms_tag_table, 'Confirmed', self._update_alarm_confirmed_times
         ).grid(sticky='W', row=4, columnspan=8)
 
+        # Alarm type filter
         label = Label(alarms_tag_table, text='Filter type:')
         label.grid(sticky='news', row=5, column=0)
         self.alarms_buttons_type = []
 
         for i in range(len(self.types)):
             button = Button(alarms_tag_table, text=self.types[i], relief='sunken',
-                            command=lambda x=i: self.flick_type(x))
+                            command=lambda x=i: self._flick_type(x))
             button.grid(sticky='news', row=5, column=i + 1)
             self.alarms_buttons_type.append(button)
 
-        # alarms table
+        # Configuring alarms table
         alarms_table_frame = Frame(self.overall_frame)
         alarms_table_frame.grid(sticky='NSEW', row=2, column=1, rowspan=num_rows - 3)
         style = ttk.Style()
@@ -109,106 +126,161 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
         alarms_table.column('Description', anchor=CENTER, width=200)
 
         alarms_table.heading('ID', text='ID ▲', anchor=CENTER,
-                             command=lambda: self.sort_alarms('ID'))
+                             command=lambda: self._sort_alarms('ID'))
         alarms_table.heading('Priority', text='Priority ●', anchor=CENTER,
-                             command=lambda: self.sort_alarms('PRIORITY'))
+                             command=lambda: self._sort_alarms('Priority'))
         alarms_table.heading('Criticality', text='Criticality ●', anchor=CENTER,
-                             command=lambda: self.sort_alarms('CRITICALITY'))
+                             command=lambda: self._sort_alarms('Criticality'))
         alarms_table.heading('Registered', text='Registered ●', anchor=CENTER,
-                             command=lambda: self.sort_alarms('REGISTERED'))
+                             command=lambda: self._sort_alarms('Registered'))
         alarms_table.heading('Confirmed', text='Confirmed ●', anchor=CENTER,
-                             command=lambda: self.sort_alarms('CONFIRMED'))
+                             command=lambda: self._sort_alarms('Confirmed'))
         alarms_table.heading('Type', text='Type ●', anchor=CENTER,
-                             command=lambda: self.sort_alarms('TYPE'))
+                             command=lambda: self._sort_alarms('Type'))
         alarms_table.heading('Parameter(s)', text='Parameter(s)', anchor=CENTER)
         alarms_table.heading('Description', text='Description', anchor=CENTER)
-        alarms_table.bind('<Double-1>', self.double_click_alarms_table_row)
+        alarms_table.bind('<Double-1>', self._double_click_alarms_table_row)
         self.controller.toggle_sort('ID')
         self.alarms_searcher.update_searched_tags()
 
         if self.dm.get_telemetry_data(None, None, {}).num_telemetry_frames > 0:
-            self.refresh_alarms_table()
+            self._refresh_alarms_table()
 
             self.alarms_searcher.update_searched_tags()
             self.alarms_searcher.select_all_tags()
 
-    def sort_alarms(self, tag: str):
-        headers = ['ID', 'Priority', 'Criticality', 'Registered', 'Confirmed', 'Type']
-        ascending = self.controller.toggle_sort(heading=tag)
+    def _sort_alarms(self, tag: str) -> None:
+        """
+        Sorts the alarms table by the header <tag>
 
-        if tag != 'ID':
-            header_name = tag[0] + tag[1:].lower()
-        else:
-            header_name = tag
+        :param tag: The table header to sort by
+        """
+        headers = ['ID', 'Priority', 'Criticality', 'Registered', 'Confirmed', 'Type']
+        ascending = self.controller.toggle_sort(heading=tag.upper())
 
-        if header_name in headers:
+        if tag in headers:
+            # Changing the header text to indicate sort
             if ascending:
-                self.alarms_table.heading(header_name, text=header_name + ' ▲')
+                self.alarms_table.heading(tag, text=tag + ' ▲')
             else:
-                self.alarms_table.heading(header_name, text=header_name + ' ▼')
+                self.alarms_table.heading(tag, text=tag + ' ▼')
 
             for header in headers:
-                if header != header_name:
+                if header != tag:
+                    # Resetting the symbol of all other headers
                     self.alarms_table.heading(header, text=header + ' ●')
         self.controller.update()
-        self.refresh_alarms_table()
+        self._refresh_alarms_table()
+
+    def _flick_new(self) -> None:
+        """
+        Defines actions once the new alarms only button is clicked
+        """
 
-    def flick_new(self):
+        # Switching if the alarm is raised or sunken
         if self.controller.get_new():
             self.alarms_button_new.config(relief='raised')
         else:
             self.alarms_button_new.config(relief='sunken')
+
+        # Updating filters and table
         self.controller.toggle_new_only()
         self.controller.update()
-        self.refresh_alarms_table()
+        self._refresh_alarms_table()
 
-    def flick_priority(self, index: int):
+    def _flick_priority(self, index: int) -> None:
+        """
+        Defines actions once one priority filter button is clicked
+
+        :param index: Indicates which priority filter button was clicked
+        """
+
+        # Switching if the alarm is raised or sunken
         tag = self.dangers[index]
         if tag in self.controller.get_priorities():
             self.alarms_buttons_priority[index].config(relief='raised')
         else:
             self.alarms_buttons_priority[index].config(relief='sunken')
-        self.controller.toggle_priority(tag)
-        self.refresh_alarms_table()
 
-    def flick_criticality(self, index: int):
+        # Updating filters and table
+        self.controller.toggle_priority(Tag(tag))
+        self._refresh_alarms_table()
+
+    def _flick_criticality(self, index: int) -> None:
+        """
+        Defines actions once one criticality filter button is clicked
+
+        :param index: Indicates which criticality filter button was clicked
+        """
+
+        # Switching if the alarm is raised or sunken
         tag = self.dangers[index]
         if tag in self.controller.get_criticalities():
             self.alarms_buttons_criticality[index].config(relief='raised')
         else:
             self.alarms_buttons_criticality[index].config(relief='sunken')
-        self.controller.toggle_criticality(tag)
-        self.refresh_alarms_table()
 
-    def update_alarm_registered_times(
+        # Updating filters and table
+        self.controller.toggle_criticality(Tag(tag))
+        self._refresh_alarms_table()
+
+    def _update_alarm_registered_times(
             self, start_time: datetime | None, end_time: datetime | None
     ) -> OperationControl:
+        """
+        Defines actions once the input registered time window has been updated
+
+        :param start_time: The minimum time alarms should have been registered from
+        :param end_time: The maximum time alarms should have been registered by
+        :return: An operational code indicating what should occur next
+        """
+
+        # Requesting updates to shown alarms
+
         self.controller.set_registered_start_time(start_time)
         self.controller.set_registered_end_time(end_time)
         self.controller.update()
-        self.refresh_alarms_table()
+
+        self._refresh_alarms_table()
         return OperationControl.CONTINUE
 
-    def update_alarm_confirmed_times(
+    def _update_alarm_confirmed_times(
             self, start_time: datetime | None, end_time: datetime | None
     ) -> OperationControl:
+        """
+        Defines actions once the input confirmed time window has been updated
+
+        :param start_time: The minimum time alarms should have been confirmed from
+        :param end_time: The maximum time alarms should have been confirmed by
+        """
+
+        # Requesting updates to shown alarms
         self.controller.set_confirmed_start_time(start_time)
         self.controller.set_confirmed_end_time(end_time)
         self.controller.update()
-        self.refresh_alarms_table()
-        self.refresh_alarms_table()
+
+        self._refresh_alarms_table()
         return OperationControl.CONTINUE
 
-    def flick_type(self, index: int):
+    def _flick_type(self, index: int) -> None:
+        """
+        Defines actions once one alarm type filter button is clicked
+
+        :param index: Indicates which alarm type filter button was clicked
+        """
+
+        # Switching if the alarm is raised or sunken
         tag = self.types[index]
         if tag in self.controller.get_types():
             self.alarms_buttons_type[index].config(relief='raised')
         else:
             self.alarms_buttons_type[index].config(relief='sunken')
-        self.controller.toggle_type(tag)
-        self.refresh_alarms_table()
 
-    def double_click_alarms_table_row(self, event) -> None:
+        # Updating filters and table
+        self.controller.toggle_type(Tag(tag))
+        self._refresh_alarms_table()
+
+    def _double_click_alarms_table_row(self, event) -> None:
         """
         This method specifies what happens if a double click were to happen
         in the alarms table
@@ -220,14 +292,19 @@ def double_click_alarms_table_row(self, event) -> None:
             index = self.alarms_table.index(cur_item)
 
             alarm = self.controller.get_table_entries()[index][-1]
-            self.open_alarm_popup(alarm)
+            self._open_alarm_popup(alarm)
+
+    def construct_alarms_table(self, event: Event = None) -> None:
+        """
+        Makes a request to obtain all data pertaining to the current telemetry frame and
+        reconstructs the shown data table
+        """
 
-    def construct_alarms_table(self, event: Event = None):
         self.controller.toggle_all()
         self.controller.create(self.dm)
-        self.refresh_alarms_table()
+        self._refresh_alarms_table()
 
-    def refresh_alarms_table(self) -> None:
+    def _refresh_alarms_table(self) -> None:
         """
         This method wipes the data from the dashboard table and re-inserts
         the new values
@@ -237,16 +314,18 @@ def refresh_alarms_table(self) -> None:
         for item in self.controller.get_table_entries():
             self.alarms_table.insert('', END, values=tuple(item))
 
-    def open_alarm_popup(self, alarm: Alarm) -> None:
+    def _open_alarm_popup(self, alarm: Alarm) -> None:
         """
         This method opens a popup displaying details and options for an alarm
 
-        Args:
-            alarm (Alarm): the alarm the popup pertains to
+        :param: alarm (Alarm): the alarm the popup pertains to
         """
+
         new_window = Toplevel(self.overall_frame)
         new_window.grab_set()
         event = alarm.event
+
+        # Configuring shown alarm values
         new_window.title(f'{'[NEW] ' if not alarm.acknowledged else ''}Alarm #{event.id}')
         new_window.geometry('300x300')
         Label(new_window, text=f'Priority: {alarm.priority.value}', anchor='w').pack(fill=BOTH)
@@ -267,44 +346,57 @@ def open_alarm_popup(self, alarm: Alarm) -> None:
         Label(new_window).pack()
         Label(new_window, text=f'Description: {event.description}', anchor='w').pack(fill=BOTH)
         buttons = Frame(new_window)
+
+        # If an alarm is not acknowledged, show an extra button to let it be acknowledged
         if not alarm.acknowledged:
             Button(
                 buttons, text='Acknowledge', width=12,
-                command=lambda: self.acknowledge_alarm(alarm, new_window)
+                command=lambda: self._acknowledge_alarm(alarm, new_window)
             ).grid(row=0, column=0, padx=10, pady=10)
+
+        # Configuring the remove alarm button
         Button(
-            buttons, text='Remove', width=12, command=lambda: self.remove_alarm(alarm, new_window)
+            buttons, text='Remove', width=12, command=lambda: self._remove_alarm(alarm, new_window)
         ).grid(row=0, column=1, padx=10, pady=10)
         buttons.pack(side=BOTTOM)
 
-    def acknowledge_alarm(self, alarm: Alarm, popup: Toplevel) -> None:
+    def _acknowledge_alarm(self, alarm: Alarm, popup: Toplevel) -> None:
         """
         This method handles acknowledging an alarm.
 
-        Args:
-            alarm (Alarm): the alarm to acknowledge
-            popup (Toplevel): the popup that the alarm acknowledgement happens from,
-                closed upon alarm acknowledgement
+        :param: alarm: the alarm to acknowledge
+        :type: Alarm
+
+        :param: popup: the popup that the alarm acknowledgement happens from,
+        closed upon alarm acknowledgement
+        :type: Toplevel
         """
+
         self.controller.acknowledge_alarm(alarm, self.dm)
         popup.destroy()
 
-    def remove_alarm(self, alarm: Alarm, popup: Toplevel) -> None:
+    def _remove_alarm(self, alarm: Alarm, popup: Toplevel) -> None:
         """
         This method handles removing an alarm.
 
-        Args:
-            alarm (Alarm): the alarm to remove
-            popup (Toplevel): the popup that the alarm removal happens from,
-                closed upon alarm removal
+        :param: alarm (Alarm): the alarm to remove
+        :type: Alarm
+
+        :param: popup: the popup that the alarm removal happens from,
+        closed upon alarm removal
+        :type: Toplevel
         """
         if messagebox.askokcancel(title='Remove alarm', message=f'Remove alarm #{alarm.event.id}?'):
             self.controller.remove_alarm(alarm, self.dm)
             popup.destroy()
 
     def alarms_searcher_update(self):
+        """Watcher method that handles updates to the alarm tag searcher"""
+
         # Convert to list to enforce ordering
         selected_tags = self.alarms_searcher.selected_tags
         self.controller.set_shown_tags(selected_tags)
+
+        # Updating shown alarms
         self.controller.update()
-        self.refresh_alarms_table()
+        self._refresh_alarms_table()
diff --git a/src/astra/frontend/graphing_view.py b/src/astra/frontend/graphing_view.py
index e794508..177a9ee 100644
--- a/src/astra/frontend/graphing_view.py
+++ b/src/astra/frontend/graphing_view.py
@@ -20,14 +20,14 @@ class GraphingView:
     """
     Defines the actual view and some minor logic for the graphing tab
 
-    :param dm: Contains all data known to the program
-    :param overall_frame: Contains all visual aspects of the view
-    :param controller: Interface for backend requests
-    :param searcher: The tag searcher used to select parameters to plot
-    :param figure: The actual graphing data to be shown
-    :param figure_canvas: A canvas to display <cls.figure> on
-    :param y_axis_selection_text: Contains the most recently selected y-axis selection option
-    :param y_axis_selector: Allows user to select a tag to use for y-axis values
+    :param: dm: Contains all data known to the program
+    :param: overall_frame: Contains all visual aspects of the view
+    :param: controller: Interface for backend requests
+    :param: searcher: The tag searcher used to select parameters to plot
+    :param: figure: The actual graphing data to be shown
+    :param: figure_canvas: A canvas to display <cls.figure> on
+    :param: y_axis_selection_text: Contains the most recently selected y-axis selection option
+    :param: y_axis_selector: Allows user to select a tag to use for y-axis values
     """
 
     def __init__(self, frame: ttk.Notebook, num_rows: int, width, dm: DataManager):
@@ -61,7 +61,7 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, width, dm: DataManager):
         graphing_time_option = Frame(graphing_frame)
         graphing_time_option.grid(sticky='news', row=0, column=0)
 
-        time_input = TimerangeInput(graphing_time_option, 'Time range', self.times_update)
+        time_input = TimerangeInput(graphing_time_option, 'Time range', self._times_update)
         time_input.grid(row=0, column=0, padx=20, pady=20, )
 
         # Creating graphing region UI
@@ -84,14 +84,14 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, width, dm: DataManager):
         self.y_axis_selector = Combobox(y_axis_selection_region,
                                         textvariable=self.y_axis_selection_text)
         self.y_axis_selector.grid(row=0, column=1, padx=5, pady=20)
-        self.y_axis_selector.bind('<<ComboboxSelected>>', self.set_graph_y_axis_label)
+        self.y_axis_selector.bind('<<ComboboxSelected>>', self._set_graph_y_axis_label)
 
         # Creating region for export data button
         button_selection_region = Frame(graphing_frame)
         button_selection_region.grid(sticky='nes', row=2, column=0, pady=20)
 
         export_data_button = Button(button_selection_region, text='Export Data',
-                                    command=self.export_data)
+                                    command=self._export_data)
         export_data_button.grid(row=0, column=1, pady=20)
 
         self.searcher.deselect_all_tags()
@@ -124,9 +124,9 @@ def searcher_update(self) -> None:
             self.y_axis_selection_text.set(detailed_tags[0])
 
         self.controller.set_shown_tags(selected_tags)
-        self.create_graph()
+        self._create_graph()
 
-    def times_update(self, start_time: datetime | None, end_time: datetime | None) -> (
+    def _times_update(self, start_time: datetime | None, end_time: datetime | None) -> (
             OperationControl):
         """
         Changes filtering for times once the user changes their input
@@ -143,18 +143,23 @@ def times_update(self, start_time: datetime | None, end_time: datetime | None) -
             return OperationControl.CANCEL
         self.controller.set_start_date(start_time)
         self.controller.set_end_date(end_time)
-        self.create_graph()
+        self._create_graph()
         return OperationControl.CONTINUE
 
-    def export_data(self) -> None:
+    def _export_data(self) -> None:
+        """
+        Defines actions once the export data button is clicked
+        """
         config_path = filedialog.asksaveasfilename(title='Save file as', defaultextension='.csv',
                                                    filetypes=[('csv file', '.csv')])
-        try:
-            self.controller.export_data_to_file(config_path)
-        except Exception as e:
-            messagebox.showerror(title='Could not save data', message=f'{type(e).__name__}: {e}')
-
-    def create_graph(self) -> None:
+        if config_path:
+            try:
+                self.controller._export_data_to_file(config_path)
+            except Exception as e:
+                messagebox.showerror(title='Could not save data', message=f'{type(e).__name__}: '
+                                                                          f'{e}')
+
+    def _create_graph(self) -> None:
         """
         Constructs the graph according to previous user inputs
         """
@@ -217,12 +222,12 @@ def create_graph(self) -> None:
             new_plot.set_xticks(xticks_positions)
             new_plot.set_xticklabels(xticks_labels, rotation=0, fontsize=7)
             new_plot.legend()
-            self.set_graph_y_axis_label()
+            self._set_graph_y_axis_label()
 
         self.figure_canvas.draw()
         self.figure_canvas.get_tk_widget().pack()
 
-    def set_graph_y_axis_label(self, args: any = None) -> None:
+    def _set_graph_y_axis_label(self, args: any = None) -> None:
         """
         Changes the y_axis range for the graph to the selected tag from
         the dropdown
diff --git a/src/astra/frontend/startup_screen.py b/src/astra/frontend/startup_screen.py
index 25e9bcf..049ce89 100644
--- a/src/astra/frontend/startup_screen.py
+++ b/src/astra/frontend/startup_screen.py
@@ -1,8 +1,9 @@
 """This module provides the GUI for Astra's startup screen."""
 
-from tkinter import Button, Frame, Label, Tk, Toplevel
-from tkinter import filedialog, font, messagebox, simpledialog, ttk, Event
 from tkinter import BOTTOM, LEFT, X, Y
+from tkinter import Button, Frame, Label, Tk, Toplevel
+from tkinter import filedialog, font, messagebox, simpledialog, ttk, Event, PhotoImage
+
 from astra.frontend.view import View
 from astra.usecase.request_receiver import DataRequestReceiver
 
@@ -14,6 +15,7 @@ def __init__(self):
         """Initialize the screen, adding all the UI elements."""
         super().__init__()
         self.title('Astra')
+        self.iconphoto(True, PhotoImage(file='logo.png'))
         self.state('zoomed')
         self.controller = DataRequestReceiver()
 
diff --git a/src/astra/frontend/tag_searcher.py b/src/astra/frontend/tag_searcher.py
index bd4c737..c1f325b 100644
--- a/src/astra/frontend/tag_searcher.py
+++ b/src/astra/frontend/tag_searcher.py
@@ -3,7 +3,7 @@
 
 from astra.data.data_manager import DataManager
 from astra.data.parameters import Tag
-from astra.usecase.request_receiver import DashboardRequestReceiver
+from astra.usecase.dashboard_request_receiver import DashboardRequestReceiver
 
 
 class TagSearcher:
@@ -11,14 +11,27 @@ class TagSearcher:
     Defines a widget that can be used to search through a series of tags and allows the user to
     make selections on those tags for a number of purposes
 
-    :param search_bar: Contains the text held in the search bar
-    :param search_controller: Defines the controller used to make search requests
-    :param dm: Stores all data known to the program
-    :param shown_tags: An ordered list of tags and their descriptions to show in the search results
-    :param selected_tags: The set of tags selected by the user
-    :param watcher: A arbitrary function with no inputs to call any time a search toggle
+    :param: search_bar: Contains the text held in the search bar
+    :type: Entry
+
+    :param: search_controller: Defines the controller used to make search requests
+    :type: DashboardRequestReceiver
+
+    :param: dm: Stores all data known to the program
+    :type: DataManager
+
+    :param: shown_tags: An ordered list of tags and their descriptions to show in the search results
+    :type: Iterable[str]
+
+    :param: selected_tags: The set of tags selected by the user
+    :type: set[str]
+
+    :param: watcher: A arbitrary function with no inputs to call any time a search toggle
     occurs
-    :param tag_table: Re[resemts the area of the screen holding all tags matching search query
+    :type: Callable
+
+    :param: tag_table: Represents the area of the screen holding all tags matching search query
+    :type: TreeView
     """
 
     def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callable):
@@ -31,7 +44,7 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
         :param watcher: The watcher function to call on toggle
         """
 
-        # elements of dashboard_frame
+        # setting up class attributes
         self.search_bar = StringVar()
         self.search_controller = DashboardRequestReceiver()
         self.dm = dm
@@ -41,6 +54,8 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
 
         self.watcher = watcher
 
+        # Configuring layout weighting of the widget
+
         filter_tags = Frame(frame)
         filter_tags.config(background='#fff')
         filter_tags.grid_columnconfigure(0, weight=1)
@@ -49,6 +64,7 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
         for i in range(num_rows):
             filter_tags.grid_rowconfigure(i, weight=1)
 
+        # Configuring the area of the widget with the search bar
         filter_tags.grid(sticky='NSEW', row=0, column=0, rowspan=num_rows - 1, padx=(0, 3))
         Label(filter_tags, text=self.get_label_text(), background='#fff').grid(
             sticky='NSEW', row=0, column=0, columnspan=2)
@@ -58,16 +74,19 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
         tag_search_area.grid_columnconfigure(1, weight=3)
         tag_search_area.grid(sticky='NSEW', row=1, column=0, columnspan=2)
 
+        # Configuring the search bar label and search bar itself
         Label(tag_search_area, text="Search", background='#fff').grid(sticky='NSEW', row=0,
                                                                       column=0)
         Entry(tag_search_area, textvariable=self.search_bar).grid(sticky='NSEW', row=0, column=1)
         self.search_bar.trace_add("write", self.search_bar_change)
 
+        # Configuring the check/uncheck all buttons
         (Button(filter_tags, text="Check all search results",
                 wraplength=80, command=self.select_all_tags).grid(row=2, column=0, rowspan=2))
         (Button(filter_tags, text="Uncheck all search results",
                 wraplength=80, command=self.deselect_all_tags).grid(row=2, column=1, rowspan=2))
 
+        # Configuring the area where tag results appear
         tag_table = ttk.Treeview(filter_tags, show='tree')
         tag_table_scroll = ttk.Scrollbar(filter_tags, orient="vertical", command=tag_table.yview)
         tag_table.configure(yscrollcommand=tag_table_scroll.set)
@@ -80,7 +99,7 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
         tag_table.bind('<ButtonRelease-1>', self.toggle_tag_table_row)
 
     def get_label_text(self) -> str:
-        """Returns an appropriate descriptor for this search widget"""
+        """Getter for the widget label"""
         return "Parameters to display"
 
     def search_bar_change(self, *args) -> None:
@@ -95,18 +114,19 @@ def search_bar_change(self, *args) -> None:
 
     def update_searched_tags(self) -> None:
         """
-        Updates the actual view of tag results
+        Updates the tags shown to the user in the search widget
         """
         # Refreshing the table
         for tag in self.tag_table.get_children():
             self.tag_table.delete(tag)
+
         # Inserting rows based on what tags match search query and if they were toggled or not
         for tag in self.shown_tags:
             check = " "
             tag_index = tag.index(':')
             if tag[:tag_index] in self.selected_tags:
                 check = "x"
-            self.tag_table.insert("", END, value=(f"[{check}] {tag}",))
+            self.tag_table.insert("", END, values=(f"[{check}] {tag}",))
 
     def toggle_tag_table_row(self, event) -> None:
         """
@@ -131,53 +151,62 @@ def toggle_tag_table_row(self, event) -> None:
 
         # Indicating tag is not selected
         if tag in self.selected_tags:
-            self.selected_tags.remove(tag)
+            self.selected_tags.remove(Tag(tag))
         else:
             # Indicating tag is now selected
-            self.selected_tags.add(tag)
+            self.selected_tags.add(Tag(tag))
         self.update_searched_tags()
         self.watcher()
 
     def select_all_tags(self) -> None:
         """
-        Force selects every single tag, not just shown ones
+        Force selects every single shown tag
         """
 
         # Iterate through all shown tags and force choose them
         for tag_info in self.shown_tags:
             tag_index = tag_info.index(':')
-            self.selected_tags.add(tag_info[:tag_index])
+            self.selected_tags.add(Tag(tag_info[:tag_index]))
+
+        # updating the view and any relevant observer
         self.update_searched_tags()
         self.watcher()
 
     def deselect_all_tags(self) -> None:
         """
-        Force de-selects all tags, not just shown ones
+        Force de-selects all shown tags
         """
-        # Clone the toggled tags, as it will mutate
+        # Iterate through all shown tags and force unselect them
         for tag_info in self.shown_tags:
             tag_index = tag_info.index(':')
             if tag_info[:tag_index] in self.selected_tags:
-                self.selected_tags.remove(tag_info[:tag_index])
+                self.selected_tags.remove(Tag(tag_info[:tag_index]))
+
+        # updating the view and any relevant observer
         self.update_searched_tags()
         self.watcher()
 
 
 class AlarmTagSearcher(TagSearcher):
     """
-    A child class of TagSearcher helping distinguish certain shown text
+    A child class of TagSearcher helping distinguish the widget label
     """
 
     def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callable):
         super().__init__(num_rows, frame, dm, watcher)
 
     def get_label_text(self) -> str:
+        """Getter for the widget label"""
         return "Filter Parameters"
 
 
 class GraphingTagSearcher(TagSearcher):
     """
     A child class of TagSearcher helping distinguish certain shown text
+
+    :param: tag_description_lookup: Maps tags to their descriptions for use with y-axis label
+    chooser
+    :type: dict[str, str]
     """
 
     def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callable):
@@ -189,4 +218,5 @@ def __init__(self, num_rows: int, frame: Frame, dm: DataManager, watcher: Callab
             self.tag_description_lookup[tag[:tag_index]] = tag
 
     def get_label_text(self) -> str:
+        """Getter for the widget label"""
         return "Select Parameters to Graph"
diff --git a/src/astra/frontend/telemetry_view.py b/src/astra/frontend/telemetry_view.py
index e314aa7..17656e2 100644
--- a/src/astra/frontend/telemetry_view.py
+++ b/src/astra/frontend/telemetry_view.py
@@ -11,51 +11,67 @@
 from astra.data.data_manager import DataManager
 from astra.frontend.timerange_input import OperationControl, TimerangeInput
 from .tag_searcher import TagSearcher
-from ..usecase.request_receiver import DashboardRequestReceiver, DataRequestReceiver
+from ..usecase.dashboard_request_receiver import DashboardRequestReceiver
+from ..usecase.request_receiver import DataRequestReceiver
 
 
 class TelemetryView:
+    """Contains the GUI elements of the Telemetry Dashboard"""
+
     def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
+        """
+        Initializes all GUI elements of the telemetry dashboard
+
+        :param frame: The notebook of tabs which this view should be inserted into
+        :param num_rows: Used for scaling to fullscreen
+        :param dm: Contains all data known to the program
+        """
         self.dm = dm
         self.overall_frame = Frame(frame)
         self.controller = DashboardRequestReceiver()
         self.data_controller = DataRequestReceiver()
 
+        # Configuring row/column weightings
         for i in range(num_rows):
             self.overall_frame.grid_rowconfigure(i, weight=1)
 
         self.overall_frame.grid_columnconfigure(0, weight=1)
         self.overall_frame.grid_columnconfigure(1, weight=2)
 
+        # Configuring search widget
         self.dashboard_searcher = TagSearcher(num_rows, self.overall_frame, self.dm,
                                               self.dashboard_searcher_update)
 
-        add_data_button = Button(self.overall_frame, text='Add data...', command=self.open_file)
+        # Configuring button to add new data
+        add_data_button = Button(self.overall_frame, text='Add data...', command=self._open_file)
         add_data_button.grid(sticky='W', row=0, column=1)
 
+        # Configuring timerange input for changing available telemetry frames
         TimerangeInput(
-            self.overall_frame, 'Time range', self.update_dashboard_times
+            self.overall_frame, 'Time range', self._update_dashboard_times
         ).grid(sticky='W', row=1, column=1)
 
         self.dashboard_current_frame_number = 0
         self.navigation_text = StringVar(value='Frame --- at ---')
 
+        # Configuring column header for changing telemetry frame and seeing current frame
+        # information
         self.navigation_row_outside = Frame(self.overall_frame)
         self.navigation_row_outside.grid(sticky='ew', row=2, column=1, pady=(10, 0))
         self.navigation_row = Frame(self.navigation_row_outside)
         self.navigation_row.pack(expand=False)
         Button(self.navigation_row, text='|<',
-               command=self.first_frame).grid(sticky='w', row=0, column=0)
+               command=self._first_frame).grid(sticky='w', row=0, column=0)
         Button(self.navigation_row, text='<',
-               command=self.decrement_frame).grid(sticky='w', row=0, column=1)
+               command=self._decrement_frame).grid(sticky='w', row=0, column=1)
         (Label(self.navigation_row, textvariable=self.navigation_text)
          .grid(sticky='ew', row=0, column=2))
         Button(self.navigation_row, text='>',
-               command=self.increment_frame).grid(sticky='e', row=0, column=3)
+               command=self._increment_frame).grid(sticky='e', row=0, column=3)
         Button(self.navigation_row, text='>|',
-               command=self.last_frame).grid(sticky='e', row=0, column=4)
+               command=self._last_frame).grid(sticky='e', row=0, column=4)
 
-        # dashboard table
+        # Configuring dashboard table
         style = ttk.Style()
         style.theme_use('clam')
         style.configure('Treeview.Heading', background='#ddd', font=('TkDefaultFont', 10, 'bold'))
@@ -74,20 +90,20 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
         dashboard_table.column('setpoint', anchor=CENTER, width=80)
         dashboard_table.column('units', anchor=CENTER, width=80)
         dashboard_table.column('alarm', anchor=CENTER, width=80)
-        dashboard_table.heading('tag', text='Tag ▼', anchor=CENTER, command=self.toggle_tag)
+        dashboard_table.heading('tag', text='Tag ▼', anchor=CENTER, command=self._toggle_tag)
         dashboard_table.heading('description', text='Description ●', anchor=CENTER,
-                                command=self.toggle_description)
+                                command=self._toggle_description)
         dashboard_table.heading('value', text='Value', anchor=CENTER)
         dashboard_table.heading('setpoint', text='Setpoint', anchor=CENTER)
         dashboard_table.heading('units', text='Units', anchor=CENTER)
         dashboard_table.heading('alarm', text='Alarm', anchor=CENTER)
-        dashboard_table.bind('<Double-1>', self.double_click_dashboard_table_row)
+        dashboard_table.bind('<Double-1>', self._double_click_dashboard_table_row)
 
-        dashboard_table.bind('<Up>', self.move_row_up)
-        dashboard_table.bind('<Down>', self.move_row_down)
+        dashboard_table.bind('<Up>', self._move_row_up)
+        dashboard_table.bind('<Down>', self._move_row_down)
 
         self.data_controller.set_data_manager(self.dm)
-        self.toggle_tag()
+        self._toggle_tag()
         self.dashboard_searcher.update_searched_tags()
 
         if self.data_controller.data_exists():
@@ -95,14 +111,13 @@ def __init__(self, frame: ttk.Notebook, num_rows: int, dm: DataManager):
 
             self.controller.change_index(0)
             self.controller.create(self.dm)
-            self.refresh_data_table()
+            self._refresh_data_table()
 
             self.dashboard_searcher.select_all_tags()
 
-    def toggle_tag(self) -> None:
+    def _toggle_tag(self) -> None:
         """
-        This method is the toggle action for the tag header
-        in the dashboard table
+        Defines what occurs when the "tag" table header is clicked
         """
         ascending = self.controller.toggle_sort('TAG')
         if ascending:
@@ -112,12 +127,11 @@ def toggle_tag(self) -> None:
             self.dashboard_table.heading('tag', text='Tag ▼')
             self.dashboard_table.heading('description', text='Description ●')
         self.controller.update()
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def toggle_description(self) -> None:
+    def _toggle_description(self) -> None:
         """
-        This method is the toggle action for the description header
-        in the dashboard table
+        Defines what occurs when the "Description" table header is clicked
         """
         ascending = self.controller.toggle_sort('DESCRIPTION')
         if ascending:
@@ -127,9 +141,9 @@ def toggle_description(self) -> None:
             self.dashboard_table.heading('description', text='Description ▼')
             self.dashboard_table.heading('tag', text='Tag ●')
         self.controller.update()
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def double_click_dashboard_table_row(self, event) -> None:
+    def _double_click_dashboard_table_row(self, event) -> None:
         """
         This method specifies what happens if a double click were to happen
         in the dashboard table
@@ -138,31 +152,34 @@ def double_click_dashboard_table_row(self, event) -> None:
 
         region = self.dashboard_table.identify('region', event.x, event.y)
         if cur_item and region != 'heading':
-            self.open_telemetry_popup(self.dashboard_table.item(cur_item)['values'])
+            self._open_telemetry_popup(self.dashboard_table.item(cur_item)['values'])
 
-    def refresh_data_table(self) -> None:
+    def _refresh_data_table(self) -> None:
         """
         This method wipes the data from the dashboard table and re-inserts
         the new values
         """
         if self.controller.get_table_entries() is not None:
-            self.change_frame_navigation_text()
+            self._change_frame_navigation_text()
             for item in self.dashboard_table.get_children():
                 self.dashboard_table.delete(item)
             for item in self.controller.get_table_entries():
                 self.dashboard_table.insert('', END, values=tuple(item))
 
-    def construct_dashboard_table(self):
+    def construct_dashboard_table(self) -> None:
+        """
+        Makes a request to obtain all data pertaining to the current telemetry frame and
+        reconstructs the shown data table
+        """
         self.controller.create(self.dm)
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def open_telemetry_popup(self, values: list[str]) -> None:
+    def _open_telemetry_popup(self, values: list[str]) -> None:
         """
         This method opens a new window to display one row of telemetry data
 
-        Args:
-            values (list[str]): the values to be displayed in the
-                new window
+        :params: values (list[str]): the values to be displayed in the
+        new window
         """
         new_window = Toplevel(self.overall_frame)
         new_window.title('Telemetry information')
@@ -170,7 +187,7 @@ def open_telemetry_popup(self, values: list[str]) -> None:
         for column in values:
             Label(new_window, text=column).pack()
 
-    def open_file(self):
+    def _open_file(self) -> None:
         """
         This method specifies what happens when the add data button
         is clicked
@@ -181,6 +198,7 @@ def open_file(self):
             return
 
         try:
+            # Uses the input file and makes a request to insert new data
             self.data_controller.set_filename(file)
             self.data_controller.update()
             self.controller.create(self.dm)
@@ -188,76 +206,109 @@ def open_file(self):
             messagebox.showerror(title='Cannot read telemetry', message=f'{type(e).__name__}: {e}')
             return
 
-        self.refresh_data_table()
+        self._refresh_data_table()
 
         self.dashboard_searcher.update_searched_tags()
 
-    def update_dashboard_times(
+    def _update_dashboard_times(
             self, start_time: datetime | None, end_time: datetime | None
     ) -> OperationControl:
+        """
+
+        :param start_time: The minimum requested time for telemetry frames
+        :param end_time: The maximum requested time for telemetry frames
+        :return: An operation code indicating how to proceed
+        """
         if self.dm.get_telemetry_data(start_time, end_time, {}).num_telemetry_frames == 0:
             messagebox.showinfo(
                 title='No telemetry frames',
                 message='The chosen time range does not have any telemetry frames.'
             )
             return OperationControl.CANCEL
+
+        # Making a backend request to change the minimum/maximum time and update the table
         self.controller.set_start_time(start_time)
         self.controller.set_end_time(end_time)
         self.dashboard_current_frame_number = 0
         self.controller.change_index(0)
         self.controller.create(self.dm)
-        self.change_frame_navigation_text()
+        self._change_frame_navigation_text()
 
-        self.refresh_data_table()
+        self._refresh_data_table()
         return OperationControl.CONTINUE
 
-    def first_frame(self):
+    def _first_frame(self) -> None:
+        """
+        Sets the current frame to the first available telemetry frame
+        """
         if self.controller.get_num_frames() == 0:
             return
         self.dashboard_current_frame_number = 0
         self.controller.change_index(0)
         self.controller.create(self.dm)
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def last_frame(self):
+    def _last_frame(self) -> None:
+        """
+        Sets the current frame to the last available telemetry frame
+        """
         if self.controller.get_num_frames() == 0:
             return
         last = self.controller.get_num_frames() - 1
         self.dashboard_current_frame_number = last
         self.controller.change_index(last)
         self.controller.create(self.dm)
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def decrement_frame(self):
+    def _decrement_frame(self) -> None:
+        """
+        Sets the current frame to the previous available telemetry frame, if any exist
+        """
+        # Case for no available frames
         if self.controller.get_num_frames() == 0:
             return
+
+        # Ensures nothing occurs when on the first available frame
         if self.dashboard_current_frame_number > 0:
             self.dashboard_current_frame_number -= 1
+
         index = self.dashboard_current_frame_number
         self.controller.change_index(index)
         self.controller.create(self.dm)
-        self.refresh_data_table()
+        self._refresh_data_table()
+
+    def _increment_frame(self) -> None:
+        """
+        Sets the current frame to the next available telemetry frame, if any exist
+        """
 
-    def increment_frame(self):
         if self.controller.get_num_frames() == 0:
             return
         last = self.controller.get_num_frames() - 1
+
+        # Ensures nothing occurs when on the last available frame
         if self.dashboard_current_frame_number < last:
             self.dashboard_current_frame_number += 1
         index = self.dashboard_current_frame_number
         self.controller.change_index(index)
         self.controller.create(self.dm)
-        self.refresh_data_table()
+        self._refresh_data_table()
 
-    def move_row_up(self, event: Event):
+    def _move_row_up(self, event: Event):
+        """
+        Moves the currently selected row up one row
+        """
         focus_item = self.dashboard_table.focus()
 
         region = self.dashboard_table.identify('region', event.x, event.y)
+
+        # Ensuring the current focus is a table row
         if focus_item and region != 'heading':
             focus_row = self.dashboard_table.selection()
             index = self.dashboard_table.index(focus_item)
 
             if len(focus_row) == 1 and index > 0:
+                # If focusing the first available row, nothing happens
                 self.dashboard_table.move(focus_row[0],
                                           self.dashboard_table.parent(focus_row[0]), index - 1)
 
@@ -266,7 +317,10 @@ def move_row_up(self, event: Event):
                 self.dashboard_table.focus(prev_row)
                 self.dashboard_table.selection_set(prev_row)
 
-    def move_row_down(self, event: Event):
+    def _move_row_down(self, event: Event) -> None:
+        """
+        Moves the currently selected row down one row
+        """
         focus_item = self.dashboard_table.focus()
 
         region = self.dashboard_table.identify('region', event.x, event.y)
@@ -283,7 +337,11 @@ def move_row_down(self, event: Event):
                 self.dashboard_table.focus(prev_row)
                 self.dashboard_table.selection_set(prev_row)
 
-    def change_frame_navigation_text(self):
+    def _change_frame_navigation_text(self) -> None:
+        """
+        Changes the table header to account for changes in number of available frame
+        or change in examined frame
+        """
         curr = self.dashboard_current_frame_number + 1
         total = self.controller.get_num_frames()
         time = self.controller.get_time()
@@ -291,11 +349,16 @@ def change_frame_navigation_text(self):
             f'Frame {curr}/{total} at {time}'
         )
 
-    def dashboard_searcher_update(self):
+    def dashboard_searcher_update(self) -> None:
+        """
+        Watcher function to be called once any update occurs in the search widget
+        """
         # Convert to list to enforce ordering
         selected_tags = list(self.dashboard_searcher.selected_tags)
+
+        # changing available tags
         self.controller.set_shown_tags(selected_tags)
         if self.controller.get_num_frames() > 0:
 
             self.controller.update()
-            self.refresh_data_table()
+            self._refresh_data_table()
diff --git a/src/astra/frontend/timerange_input.py b/src/astra/frontend/timerange_input.py
index f3e7103..b32025b 100644
--- a/src/astra/frontend/timerange_input.py
+++ b/src/astra/frontend/timerange_input.py
@@ -105,7 +105,8 @@ def __init__(self, timerange_input: TimerangeInput):
         time_entries: list[tuple[Entry, StringVar, int]] = []
         for row, time_vars in enumerate([self.start_time_vars, self.end_time_vars]):
             time_display_frame = Frame(self)
-            for element in [4, '-', 2, '-', 2, ' ', 2, ':', 2, ':', 2, ' ']:
+            elements: list[int | str] = [4, '-', 2, '-', 2, ' ', 2, ':', 2, ':', 2, ' ']
+            for element in elements:
                 if isinstance(element, int):
                     time_var = StringVar()
                     time_vars.append(time_var)
@@ -197,7 +198,7 @@ def set_entries_by_time(time_vars: list[StringVar], time: datetime | None) -> No
 
     def set_timerange(self) -> None:
         """Actually perform the action of setting a timerange."""
-        times = [None, None]
+        times: list[datetime | None] = [None, None]
         for i, (time_vars, time_type_capitalized, time_type_lowercase) in enumerate(
             [(self.start_time_vars, 'Start', 'start'), (self.end_time_vars, 'End', 'end')]
         ):
@@ -233,7 +234,7 @@ def set_timerange(self) -> None:
             self.timerange_input.update_timerange(start_time, end_time)
 
     @staticmethod
-    def switch_entry(entry: Entry, next_entry: Entry, entry_len: int):
+    def switch_entry(entry: Entry, next_entry: Entry, entry_len: int) -> None:
         """Switch focus from entry to next_entry as long as entry has entry_length characters."""
         if len(entry.get()) == entry_len:
             next_entry.focus_set()
diff --git a/src/astra/frontend/view.py b/src/astra/frontend/view.py
index 0f97de9..da25494 100644
--- a/src/astra/frontend/view.py
+++ b/src/astra/frontend/view.py
@@ -3,9 +3,9 @@
 """
 
 import itertools
-from tkinter import Frame
 from tkinter import BOTH
-from tkinter import ttk, Tk, Label
+from tkinter import Frame, Label, Tk
+from tkinter import ttk, PhotoImage
 
 from astra.data.data_manager import DataManager
 from .graphing_view import GraphingView
@@ -15,7 +15,7 @@
 
 class View(Tk):
     """
-    View class
+    The container class for all GUI elements of the main screen
     """
     _dm: DataManager
 
@@ -33,6 +33,7 @@ def __init__(self, device_name: str) -> None:
         # Root frame of tkinter
         super().__init__()
         self.title(f'Astra - {device_name}')
+        self.iconphoto(True, PhotoImage(file='logo.png'))
 
         # tab widget
         tab_control = ttk.Notebook(self)
@@ -50,6 +51,7 @@ def __init__(self, device_name: str) -> None:
         self.graphing_tab = GraphingView(tab_control, height // 4, width, self._dm)
         graphing_frame = self.graphing_tab.overall_frame
 
+        # setting up observers for alarm updates
         watchers = [
             self.telemetry_tab.construct_dashboard_table,
             self.alarm_tab.construct_alarms_table,
diff --git a/src/astra/frontend/view_draw_functions.py b/src/astra/frontend/view_draw_functions.py
index 58b8a17..54e7022 100644
--- a/src/astra/frontend/view_draw_functions.py
+++ b/src/astra/frontend/view_draw_functions.py
@@ -9,9 +9,8 @@ def draw_status(status_frame, descriptions):
     """
     Draws the status frame of the dashboard
 
-    Args:
-        status_frame: frame of the status
-        descriptions: content to be displayed in the frame
+    :param: status_frame: frame of the status
+    :param: descriptions: content to be displayed in the frame
     """
 
     # Wipe the frame first
@@ -31,9 +30,8 @@ def draw_warnings(warnings_frame, descriptions):
     Draws the warnings frame of the dashboard
     Assumes warnings are sorted by critical first
 
-    Args:
-        warnings_frame: frame for warnings
-        descriptions: informations for what to go in the warnings
+    :param: warnings_frame: frame for warnings
+    :param: descriptions: informations for what to go in the warnings
     """
 
     # Wipe the frame first
@@ -63,9 +61,8 @@ def draw_frameview(frameview_frame, descriptions):
     Takes a tkinter Frame, and a 2d array of label strings
     Can be called whenever an update is required
 
-    Args:
-        frameview_frame (_type_): tkinter frame
-        descriptions (_type_): list of lists to display
+    :param frameview_frame: tkinter frame to insert descriptions into
+    :param descriptions: 2D list of label strings to display
     """
 
     # Wipe the frame first
diff --git a/src/astra/usecase/__pycache__/__init__.cpython-312.pyc b/src/astra/usecase/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 75afa78..0000000
Binary files a/src/astra/usecase/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/alarm_checker.cpython-312.pyc b/src/astra/usecase/__pycache__/alarm_checker.cpython-312.pyc
deleted file mode 100644
index fcb1417..0000000
Binary files a/src/astra/usecase/__pycache__/alarm_checker.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/alarm_handler.cpython-312.pyc b/src/astra/usecase/__pycache__/alarm_handler.cpython-312.pyc
deleted file mode 100644
index fbd3aff..0000000
Binary files a/src/astra/usecase/__pycache__/alarm_handler.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/alarm_strategies.cpython-312.pyc b/src/astra/usecase/__pycache__/alarm_strategies.cpython-312.pyc
deleted file mode 100644
index a186fbf..0000000
Binary files a/src/astra/usecase/__pycache__/alarm_strategies.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/alarms_request_receiver.cpython-312.pyc b/src/astra/usecase/__pycache__/alarms_request_receiver.cpython-312.pyc
deleted file mode 100644
index dbe6993..0000000
Binary files a/src/astra/usecase/__pycache__/alarms_request_receiver.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/dashboard_handler.cpython-312.pyc b/src/astra/usecase/__pycache__/dashboard_handler.cpython-312.pyc
deleted file mode 100644
index 947fa8b..0000000
Binary files a/src/astra/usecase/__pycache__/dashboard_handler.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/request_receiver.cpython-312.pyc b/src/astra/usecase/__pycache__/request_receiver.cpython-312.pyc
deleted file mode 100644
index 39dd5db..0000000
Binary files a/src/astra/usecase/__pycache__/request_receiver.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/use_case_handlers.cpython-312.pyc b/src/astra/usecase/__pycache__/use_case_handlers.cpython-312.pyc
deleted file mode 100644
index a5ed2ef..0000000
Binary files a/src/astra/usecase/__pycache__/use_case_handlers.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/__pycache__/utils.cpython-312.pyc b/src/astra/usecase/__pycache__/utils.cpython-312.pyc
deleted file mode 100644
index 469af5c..0000000
Binary files a/src/astra/usecase/__pycache__/utils.cpython-312.pyc and /dev/null differ
diff --git a/src/astra/usecase/alarm_checker.py b/src/astra/usecase/alarm_checker.py
index 2325f34..fa7d488 100644
--- a/src/astra/usecase/alarm_checker.py
+++ b/src/astra/usecase/alarm_checker.py
@@ -7,23 +7,31 @@
 def check_alarms(dm: DataManager,
                  earliest_time: datetime) -> None:
     """
-    Goes through all possible alarms to check and, if any exists, adds them to <alarms>
-    based on their criticality
+    Goes through all possible alarm bases to check, and calls the appropriate
+    strategy to evaluate them
 
-    :param earliest_time:
-    :param dm: The manager of all data known to the program
+    This should only be called once new telemetry data is added to the system
+
+    :param dm: Contains all data known to the program
+    :param earliest_time: Details the earliest timestamp amongst newly added telemetry frames
     """
 
     alarm_bases = dm.alarm_bases
+
+    # condition variable allows us to make a notification once all strategies have completed
     cv = Condition()
     threads = []
 
     for alarm_base in alarm_bases:
+        # The base and criticality were seperated due to how things worked previously. This would
+        # be a good and simple thing to refactor
         base = alarm_base.event_base
         criticality = alarm_base.criticality
 
+        # Acquiring the correct strategy for the event base then running it in a new thread
         strategy = get_strategy(base)
         new_thread = Thread(target=strategy, args=[dm, base, criticality, earliest_time, False, cv])
+
         new_thread.start()
         threads.append(new_thread)
     wait_for_children(dm, cv, threads)
@@ -31,16 +39,18 @@ def check_alarms(dm: DataManager,
 
 def wait_for_children(dm: DataManager, cv: Condition, threads: list[Thread]) -> None:
     """
-    Waits for all child threads to be completed, then notifies the alarm container that
-    all tasks are done
+    Waits for all threads in <threads> to be completed, then notifies the alarm container that
+    all alarm bases have been evaluated
 
-    :param dm: Container of the alarm container
-    :param cv: The condition variable to track child completion
+    :param dm: Contains all data known to the program
+    :param cv: The condition variable each thread in <threads> has to track thread completion
     :param threads: Contains all child threads of this process
     """
+
     thread_active = check_alive(threads)
 
     with cv:
+        # Simple loop to check if any child thread is alive and block if so
         while thread_active:
             # Note: this idea might be doable with a semaphore? My only concern is if the child
             # threads don't acquire a semaphore before this thread, then it won't work
@@ -51,10 +61,11 @@ def wait_for_children(dm: DataManager, cv: Condition, threads: list[Thread]) ->
 
 def check_alive(threads: list[Thread]) -> bool:
     """
-    Checks if any thread in <threds> is alive and returns an appropriate boolean
+    Checks if any thread in <threads> is alive and returns an appropriate boolean
 
     :param threads: The list of threads to check
     """
+
     thread_active = False
     for thread in threads:
         if thread.is_alive():
diff --git a/src/astra/usecase/alarm_handler.py b/src/astra/usecase/alarm_handler.py
index ee5a429..3d83f4e 100644
--- a/src/astra/usecase/alarm_handler.py
+++ b/src/astra/usecase/alarm_handler.py
@@ -1,10 +1,7 @@
-from queue import Queue
-
 from astra.data.alarms import (AlarmPriority, RateOfChangeEventBase, Alarm,
                                StaticEventBase, ThresholdEventBase, SetpointEventBase,
-                               SOEEventBase, AllEventBase, EventBase, AnyEventBase)
+                               SOEEventBase, AllEventBase)
 from astra.data.data_manager import DataManager
-from astra.data.parameters import Tag
 from astra.usecase.filters import AlarmsFilters
 from astra.usecase.table_return import TableReturn
 
@@ -21,24 +18,30 @@
 OLD_QUEUE_KEY = 'o'
 NEW_PREFIX = "[NEW] "
 MAX_BANNER_SIZE = 6
+MAX_NEW_SIZE = 3
+MAX_OLD_SIZE = 3
 
 
-class LimitedSlotAlarms:
+class AlarmBanner:
     """
-    Contains all alarms to be shown in the banner at the top of the screen
+    Stores alarms to be shown in the banner at the top of the screen according to acknowledgement
+
+    :param _slots: Maps constant strings to the appropriate alarms list
+    :type: dict[str, list[Alarm]]
 
-    :param _slots: A dict of priority queues
     :param _priorities: an ordered list of keys in _slots, where elements are ordered by
     descending importance
+    :type: list[str]
     """
-    _slots = {NEW_QUEUE_KEY: [], OLD_QUEUE_KEY: []}
+
+    _slots = {NEW_QUEUE_KEY: [], OLD_QUEUE_KEY: []}  # type: dict[str, list[Alarm]]
     _priorities = [NEW_QUEUE_KEY, OLD_QUEUE_KEY]
 
     @staticmethod
     def create_banner_string(alarm: Alarm) -> str:
         """Creates an appropriate string for the banner provided an alarm
 
-        :param alarm: The alarm to use in creating a string
+        :param alarm: The alarm to detail in the returned string
         :return A representation of the alarm for the banner
         """
         priority_str = (f"{alarm.priority.name[0] + alarm.priority.name[1:].lower()}"
@@ -50,14 +53,21 @@ def create_banner_string(alarm: Alarm) -> str:
     @classmethod
     def get_all(cls) -> list[str]:
         """
-        Compacts all data amongst <cls._slots> into one list in a readable format
+        Determines which alarms should be shown in the banners and returns an ordered list
+        of strings to display
+
+        Currently, uses the following criteria to determine what should be shown:
+            1. 3 new alarms and 3 old alarms should be shown. If there are less than 3 of either,
+            the other may take its place
+            2. In each age bracket, we use the highest priority to determine which should be shown
 
-        :return: An ordered list of data compiled from <cls._slots>
+        :return: An ordered list of strings to show in the banner
         """
-        all_items = []
+
+        all_items: list[str] = []
 
         # Note: while this implementation may seem slow, due to the nature of alarms
-        # being rare and banner slots being limited, it's effectively fast
+        # being rare and banner slots being limited, speed should not be an issue
         new_q = cls._slots[NEW_QUEUE_KEY]
         new_q_items = new_q.copy()
         new_q_items.sort(reverse=True)
@@ -66,10 +76,10 @@ def get_all(cls) -> list[str]:
         # We want to reserve 3 slots for old alarms, but if there's less than 3 old alarms,
         # populate the banner with more new ones
         old_q_size = len(old_q)
-        if old_q_size > 3:
-            max_new = 3
+        if old_q_size > MAX_NEW_SIZE:
+            max_new = MAX_NEW_SIZE
         else:
-            max_new = 6 - old_q_size
+            max_new = MAX_BANNER_SIZE - old_q_size
 
         # Getting and formatting strings for the top priority new alarms
         i = 0
@@ -83,7 +93,10 @@ def get_all(cls) -> list[str]:
         i = 0
         old_q_items = old_q.copy()
         old_q_items.sort(reverse=True)
-        while i < len(old_q_items) and len(all_items) < MAX_BANNER_SIZE:
+
+        # We run a while loop over the size of <all_items> to ensure the
+        # banner is as populated as possible
+        while len(all_items) < MAX_BANNER_SIZE:
             item = old_q_items[i]
             old_str = cls.create_banner_string(item)
             all_items.append(old_str)
@@ -96,7 +109,7 @@ def insert_into_new(cls, alarm: Alarm) -> None:
         """
         Inserts <alarm> into the new alarms queue in <cls._slots>
 
-        :param alarm: The alarm to insert into the banner slots
+        :param alarm: The alarm to insert into the new alarms queue
         """
         new_q = cls._slots[NEW_QUEUE_KEY]
         new_q.append(alarm)
@@ -104,9 +117,9 @@ def insert_into_new(cls, alarm: Alarm) -> None:
     @classmethod
     def insert_into_old(cls, alarm: Alarm) -> None:
         """
-        Moves <alarm> from the new alarms queue and into the old alarms queue
+        Moves <alarm> from the new alarms list and into the old alarms list
 
-        :param alarm: The alarm to insert into the banner slots
+        :param alarm: The alarm to insert into the old banner slots
 
         PRECONDITION: <alarm> is in <cls._slots[NEW_QUEUE_KEY]>
         """
@@ -121,9 +134,9 @@ def remove_alarm_from_banner(cls, alarm: Alarm) -> None:
         """
         Removes <alarm> from the appropriate queue
 
-        :param alarm: The alarm to insert into the banner slots
+        :param alarm: The alarm to remove from any banner slots
 
-        PRECONDITION: <alarm> is in one queue in <cls._slots>
+        PRECONDITION: <alarm> is in one list in <cls._slots>
         """
         if alarm.acknowledged:
             old_q = cls._slots[OLD_QUEUE_KEY]
@@ -134,16 +147,28 @@ def remove_alarm_from_banner(cls, alarm: Alarm) -> None:
 
 
 class AlarmsHandler:
-    banner_container = LimitedSlotAlarms()
+    """
+    Processes requests of the program when it comes to displaying alarm information
+
+    :param banner_container: Data structure to determine what information to store in the
+    alarm banner at the top of the screen
+    :type: AlarmBanner
+    """
+
+    banner_container = AlarmBanner()
 
     @staticmethod
     def _get_alarm_type(alarm: Alarm) -> str:
         """
         Returns the string representation of the underlying EventBase of <alarm>
 
-        :param alarm: The alarm to examine
+        NOTE: This is a pretty bad code smell. It will work--and if there are no further alarm
+        types to add then this is fine enough--but this should be refactored.
+
+        :param alarm: The alarm to extract a type from
         :return: A string representation of the alarm type
         """
+
         base = alarm.event.base
         match base:
             case RateOfChangeEventBase():
@@ -161,24 +186,6 @@ def _get_alarm_type(alarm: Alarm) -> str:
             case _:
                 return 'L_OR'
 
-    @classmethod
-    def _get_relevant_tags(cls, event_base: EventBase) -> set[Tag]:
-        """
-        Takes an event base and outputs a list of all relevant tags to the base
-
-        :param event_base: The event base to examine
-        :return: A list of all relevant tags to the base
-        """
-        if type(event_base) is not AllEventBase \
-                and type(event_base) is not AnyEventBase \
-                and type(event_base) is not SOEEventBase:
-            return {event_base.tag}
-        else:
-            all_tags = set()
-            for inner_event_base in event_base.event_bases:
-                all_tags = all_tags.union(cls._get_relevant_tags(inner_event_base))
-            return all_tags
-
     @classmethod
     def _determine_toggled(cls, alarm: Alarm, filter_args: AlarmsFilters) -> bool:
         """
@@ -188,38 +195,38 @@ def _determine_toggled(cls, alarm: Alarm, filter_args: AlarmsFilters) -> bool:
         :param filter_args: Contains arguments that will determine if <alarm> is shown
         :return: true iff <alarm> should be shown
         """
-        show = True
+
         # First, checking if it satisfies priority requirements
+
+        show: bool = True
         show = alarm.priority.name in filter_args.priorities
 
         # Next, checking if it satisfies criticality arguments
         show = show and alarm.criticality.name in filter_args.criticalities
 
         # Checking if the alarm type matches
-        show = show and cls._get_alarm_type(alarm) in filter_args.types
+        if filter_args.types is not None:
+            show = show and cls._get_alarm_type(alarm) in filter_args.types
 
         # Checking if the tag of the alarm is requested to be shown
-        relevant_tags = set(cls._get_relevant_tags(alarm.event.base))
+        relevant_tags = set(alarm.event.base.tags)
         show = show and len(relevant_tags.difference(filter_args.tags)) == 0
 
         # Now we need to make sure the alarm fits in the time parameters
         alarm_confirm_time = alarm.event.confirm_time
         alarm_register_time = alarm.event.confirm_time
-        if filter_args.confirmed_start_time is not None:
-            compare_time = filter_args.confirmed_start_time
-            show = show and alarm_confirm_time >= compare_time
 
-        if filter_args.confirmed_end_time is not None:
-            compare_time = filter_args.confirmed_end_time
-            show = show and alarm_confirm_time <= compare_time
+        compare_time = filter_args.confirmed_start_time
+        show = show and alarm_confirm_time >= compare_time
 
-        if filter_args.registered_start_time is not None:
-            register_time = filter_args.registered_start_time
-            show = show and alarm_register_time >= register_time
+        compare_time = filter_args.confirmed_end_time
+        show = show and alarm_confirm_time <= compare_time
 
-        if filter_args.registered_end_time is not None:
-            register_time = filter_args.registered_end_time
-            show = show and alarm_register_time <= register_time
+        register_time = filter_args.registered_start_time
+        show = show and alarm_register_time >= register_time
+
+        register_time = filter_args.registered_end_time
+        show = show and alarm_register_time <= register_time
 
         # Finally, checking if we only show unacknowledged alarms
         if filter_args.new:
@@ -232,28 +239,27 @@ def _sort_output(cls, return_data: TableReturn, sort: tuple[str, str]):
         sorts the <table> field of return_data based on <sort>
 
         :param return_data: the output container to sort data from
-        :param sort: defines how output should be sorted
-
-        PRECONDITION: The values of sort satisfy the docstrings of the sort field in
-        AlarmsFilters
+        :param sort: indicates what type of sort should be applied to which column.
+        A tuple in the form (sort_type, sort_column), where <sort_type> is one
+        of '>' or '<', and <sort_column> is in VALID_SORTING_COLUMNS.
         """
-        if sort is not None:
-            # Determining which column to sort by
-            key_index = 0
-            for i in range(len(VALID_SORTING_COLUMNS)):
-                if sort[1] == VALID_SORTING_COLUMNS[i]:
-                    key_index = i
-                    break
-
-            # By default, sorting occurs by ascending values, so a case is
-            # needed to check if it should occur by descending order
-            reverse = False
-            if sort[0] == DESCENDING:
-                reverse = True
-
-            return_data.table = sorted(return_data.table,
-                                       key=lambda x: (x[key_index], x[0]),
-                                       reverse=reverse)
+
+        # Determining which column to sort by
+        key_index = 0
+        for i in range(len(VALID_SORTING_COLUMNS)):
+            if sort[1] == VALID_SORTING_COLUMNS[i]:
+                key_index = i
+                break
+
+        # By default, sorting occurs by ascending values, so a case is
+        # needed to check if it should occur by descending order
+        reverse = False
+        if sort[0] == DESCENDING:
+            reverse = True
+
+        return_data.table = sorted(return_data.table,
+                                   key=lambda x: (x[key_index], x[0]),
+                                   reverse=reverse)
 
     @classmethod
     def _extract_alarm_data(cls, alarm: Alarm, priority: AlarmPriority) -> list:
@@ -266,13 +272,14 @@ def _extract_alarm_data(cls, alarm: Alarm, priority: AlarmPriority) -> list:
         <alarm> register time, <alarm> confirm time, <alarm> type, <alarm> description, and the
         alarm itself
         """
+
         alarm_id = alarm.event.id
         alarm_priority = priority
         alarm_criticality = alarm.criticality
         alarm_register_time = alarm.event.register_time
         alarm_confirm_time = alarm.event.confirm_time
         alarm_type = cls._get_alarm_type(alarm)
-        alarm_tags = cls._get_relevant_tags(alarm.event.base)
+        alarm_tags = alarm.event.base.tags
         tag_string = ''
         for tag in alarm_tags:
             tag_string += tag + ' '
@@ -284,41 +291,50 @@ def _extract_alarm_data(cls, alarm: Alarm, priority: AlarmPriority) -> list:
         return new_row
 
     @classmethod
-    def get_data(cls, dm: dict[AlarmPriority | str, set[Alarm] | Queue],
+    def get_data(cls, dm: DataManager,
                  filter_args: AlarmsFilters) -> TableReturn:
         """
         Using the current data structure of alarms, packs all data stored by the alarms into
         an easily accessible format
 
-        :param dm: Contains all alarms known to the program
+        :param dm: Contains all data known to the program
         :param filter_args: Describes all filters to apply to the filter
         :return: A container for all data to be shown by the table
         """
         shown = []
         removed = []
+
+        alarms_container = dm.alarms
+        alarms = alarms_container.get_alarms()
+
+        # simply iterating through all alarms and extracting their data then adding it into
+        # the appropriate list from those defined above
         for priority in PRIORITIES:
-            for alarm in dm[priority]:
+            for alarm in alarms[priority]:
                 new_row = cls._extract_alarm_data(alarm, AlarmPriority(priority))
                 if cls._determine_toggled(alarm, filter_args):
                     shown.append(new_row)
                 else:
                     removed.append(new_row)
 
-        while dm[NEW_QUEUE_KEY].qsize() > 0:
-            next_item = dm[NEW_QUEUE_KEY].get()
+        # emptying the queue of new alarms to inform the alarm banner of their presence
+        while alarms_container.new_alarms.qsize() > 0:
+            next_item = alarms_container.new_alarms.get()
             cls.banner_container.insert_into_new(next_item)
 
         return_table = TableReturn(shown, removed)
+        if filter_args.sort is not None:
+            cls._sort_output(return_table, filter_args.sort)
+
         return return_table
 
     @classmethod
     def update_data(cls, prev_data: TableReturn, filter_args: AlarmsFilters) -> None:
         """
-        Updates the previous data returned by get_data to apply any new filters
+        Updates the previous data returned by get_data to apply any new filters or sort
 
         :param prev_data: The data returned by the last call to cls.get_data
         :param filter_args: Describes all filters to apply to the table
-        :param dm: Contains all data known to the program
         """
         new_table = []
         new_removed = []
@@ -338,7 +354,9 @@ def update_data(cls, prev_data: TableReturn, filter_args: AlarmsFilters) -> None
 
         prev_data.table = new_table
         prev_data.removed = new_removed
-        cls._sort_output(prev_data, filter_args.sort)
+
+        if filter_args.sort is not None:
+            cls._sort_output(prev_data, filter_args.sort)
 
     @classmethod
     def acknowledge_alarm(cls, alarm: Alarm, dm: DataManager) -> None:
diff --git a/src/astra/usecase/alarm_strategies.py b/src/astra/usecase/alarm_strategies.py
index e29d1a3..3b20af9 100644
--- a/src/astra/usecase/alarm_strategies.py
+++ b/src/astra/usecase/alarm_strategies.py
@@ -7,7 +7,7 @@
                                StaticEventBase, ThresholdEventBase, SetpointEventBase,
                                SOEEventBase, AllEventBase, AlarmCriticality, Event, AnyEventBase)
 from astra.data.data_manager import DataManager
-from typing import Callable, Mapping
+from typing import Callable, Mapping, Union
 from astra.data.parameters import Tag, ParameterValue
 from astra.data.telemetry_data import TelemetryData
 from datetime import timedelta, datetime
@@ -16,15 +16,18 @@
 next_id = EventID(0)
 
 
-# TODO: if alarm descriptions are "formulaic", extract helper method for making alarms from list
-
-
 def get_strategy(base: EventBase) -> Callable:
     """
     Matches an unknown form of EventBase to the correct strategy to check them
 
+    NOTE: Major code smell here, we tried to factor it out but ran into some circular
+    dependency issues. If no further event bases are added, then this isn't too bad,
+    but should be refactored
+
     :param base: An EventBase to evaluate
+    :return: The function needed to evaluate <base>
     """
+
     match base:
         case RateOfChangeEventBase():
             return rate_of_change_check
@@ -43,20 +46,20 @@ def get_strategy(base: EventBase) -> Callable:
 
 
 def find_first_time(alarm_base: EventBase, earliest_time: datetime) -> tuple[datetime, float]:
-    """Finds the first time to check for persistence and returns it, along with
+    """Finds the first datetime to check for persistence on event bases and returns it, along with
     the length of time to check for persistence
 
-    :param alarm_base: the event for which persistence must be checked
-    :param earliest_time: The earliest time linked to the newest telemetry frame
+    :param: alarm_base: the event for which persistence must be checked
+    :param: earliest_time: The earliest time linked to the newest telemetry frame set
     recently added
-    :return A tuple where the first item is the first time which must be checked,
+    :return: A tuple where the first item is the first time which must be checked,
     and the second is the length of time to check
     """
 
     # Calculating the range of time that needs to be checked
     if alarm_base.persistence is None:
         subtract_time = timedelta(seconds=0)
-        sequence = 0
+        sequence = 0.0
     else:
         subtract_time = timedelta(seconds=alarm_base.persistence)
         sequence = alarm_base.persistence
@@ -72,13 +75,13 @@ def create_alarm(alarm_indexes: tuple[int, int], times: list[datetime],
     """
     Uses information on telemetry indexes to create an appropriate alarm
 
-    :param alarm_indexes: A tuple listing the index where an alarm condition is first met,
+    :param: alarm_indexes: A tuple listing the index where an alarm condition is first met,
     and another listing the first where the persistence time check is met
-    :param times: Lists in order the time of the i-th telemetry frame to be examined
-    :param description: Describes information about the event
-    :param event_base: The underlying type of alarm that occured
-    :param criticality: The base importance of the alarm
-    :return: An alarm detailing a certain event that has occured
+    :param: times: Lists in order the time of the i-th telemetry frame to be examined
+    :param: description: Describes information about the event
+    :param: event_base: The underlying type of alarm that occurred
+    :param: criticality: The base importance of the alarm
+    :return: An alarm detailing a certain event that has occurred
     """
     global next_id
 
@@ -88,7 +91,7 @@ def create_alarm(alarm_indexes: tuple[int, int], times: list[datetime],
 
     event = Event(event_base, next_id, register_timestamp, confirm_timestamp, datetime.now(),
                   event_base.description)
-    next_id += 1
+    next_id = EventID(next_id + 1)
 
     # Note: priority needs to be determined externally, so we temporarily set it to provided
     # criticality
@@ -105,7 +108,7 @@ def check_conds(td: TelemetryData, tag: Tag, condition: Callable,
     :param tag: The tag to use for checking conditions
     :param td: Contains all telemetry frames to examine
     :param condition: A function that returns a boolean with parameters
-                      (ParameterValue, ParameterValue
+                      (ParameterValue, ParameterValue)
     :param comparison: ParameterValues to be used as a point of comparison
     :param persistence: How long the condition has to last
     :return: A list of tuples where the first tuple element is the index of telemetry frame where
@@ -113,6 +116,7 @@ def check_conds(td: TelemetryData, tag: Tag, condition: Callable,
     confirmed. Also returns a list of booleans where each index i refers to whether or not the
     i-th frame of <td> had an active alarm.
     """
+
     alarm_data = []
     alarm_indices = []
     tag_values = td.get_parameter_values(tag)
@@ -145,17 +149,23 @@ def check_conds(td: TelemetryData, tag: Tag, condition: Callable,
 
         if not cond_frame_met:
             if confirmed_alarm:
+                # Now that we now how long the alarm lasted, we pad <alarm_indices> with
+                # the sufficient number of True values
                 true_indices = [True] * (i - curr_first_index)
                 alarm_indices += true_indices
                 confirmed_alarm = False
                 active_sequence = False
             elif active_sequence:
+                # Persistence failed, so we pad <alarm_indices> with the sufficient number of
+                # False values
                 false_indices = [False] * (i - curr_first_index)
                 alarm_indices += false_indices
                 active_sequence = False
             alarm_indices.append(False)
         i += 1
 
+    # Similar to the case under <if not conf_frame_met:>, we simply check again as if there is if
+    # conditions are still being met at the end of frames we examine, there may still be an alarm
     if confirmed_alarm:
         true_indices = [True] * (i - curr_first_index)
         alarm_indices += true_indices
@@ -267,13 +277,15 @@ def persistence_check(tuples: list[tuple[bool, datetime]], persistence: float,
 def running_average_at_time(data: Mapping[datetime, ParameterValue | None], times: list[datetime],
                             start_date: datetime, time_window: float) -> float:
     """
-    Gets the rate of change of the tag within the <td> from <start_date> to <end_date>.
+    Calculates the running average of the tag within the <data> from <start_date> to
+    <start_date> + <time_window>.
 
     :param data: The data to check
-    :param times: The times associated with <data> (its keys)
+    :param times: The times associated with the data: <data.keys()>
     :param start_date: The start date to check from
-    :param end_date: The end date to check to
-    :return: The rate of change of the tag within the <td> from <start_date> to <end_date>.
+    :param time_window: The time_window to check over
+    :return: The running average starting at <start_date> and ending at <start_date> +
+    <time_window>.
 
     PRECONDITION: <start_date> is in <times> and <times> are the keys of <data>.
     """
@@ -294,11 +306,11 @@ def running_average_at_time(data: Mapping[datetime, ParameterValue | None], time
 
         curr_index += 1
 
-    # If loop ended with <curr_time> as the same as <start_date>, then we have roc = 0.0
+    # If loop ended with <curr_time> as the same as <start_date>, then we have running average = 0.0
     if curr_time == start_date:
         return 0.0
 
-    # otherwise we have the n-point running average.
+    # otherwise we can take the n-point running average.
     roc = total / (curr_index - initial_index)
 
     return roc
@@ -308,8 +320,8 @@ def rate_of_change_check(dm: DataManager, alarm_base: RateOfChangeEventBase,
                          criticality: AlarmCriticality, earliest_time: datetime,
                          compound: bool, cv: Condition) -> list[bool]:
     """
-    Checks if in the telemetry frames with times in the range
-    (<earliest_time> - <alarm_base.persistence> -> present), there exists
+    Checks in the telemetry frames with times in the range
+    (<earliest_time> - <alarm_base.persistence> -> present), if there exists
     a sequence lasting <alarm_base.persistence> seconds where:
     a) <alarm_base.tag> reported a rate of change above <alarm_base.rate_of_rise_threshold>
     b) <alarm_base.tag> reported a rate of change below <alarm_base.rate_of_fall_threshold>
@@ -329,7 +341,7 @@ def rate_of_change_check(dm: DataManager, alarm_base: RateOfChangeEventBase,
     # Calculating the range of time that needs to be checked
     first_time, sequence = find_first_time(alarm_base, earliest_time)
 
-    # Getting all the values relevant to this alarm.
+    # Getting all the important values to this alarm.
     tag = alarm_base.tag
     telemetry_data = dm.get_telemetry_data(first_time, None, [tag])
     tag_values = telemetry_data.get_parameter_values(tag)
@@ -342,15 +354,16 @@ def rate_of_change_check(dm: DataManager, alarm_base: RateOfChangeEventBase,
     # fall alarm, and 0 indicates no alarm.
     rising_or_falling_list = []
 
-    curr_running_average = 0.0
+    # initialize the prev_running_average
     if len(times) > 0:
         prev_running_average = running_average_at_time(tag_values, times,
                                                        times[0], alarm_base.time_window)
     else:
         prev_running_average = 0.0
-    # Calculate the rate of change for each time window, and add the appropriate
-    # number to the list.
-    for start_date in times[1:-1]:
+
+    # We calculate the running average at each time, and then calculate the rate of change
+    # by comparing adjacent running averages.
+    for start_date in times[1:]:
 
         # ROC is found by subtracting the previous running average from the current one.
         curr_running_average = running_average_at_time(tag_values, times,
@@ -417,14 +430,16 @@ def rate_of_change_check(dm: DataManager, alarm_base: RateOfChangeEventBase,
 
 def repeat_checker(td: TelemetryData, tag: Tag) -> tuple[list[tuple[bool, datetime]], list[int]]:
     """
-    Checks all the frames in <td> and returns a list of tuples where each tuple
-    contains a boolean indicating if the value of <tag> is the same as the previous
-    frame, and the datetime associated with the frame.
+    Checks all the frames in <td> and returns a 2-element tuple where the first element
+    is list of tuples where each tuple contains a date and boolean indicating whether the
+    alarm was active on that date. The second element of the tuple is a list of indices
+    where the first tuple element is False.
 
     :param tag: The tag to check the values of.
     :param td: The relevant telemetry data to check.
-    :return: A list of tuples where each tuple contains a boolean indicating if the value of
-    <tag> is the same as the previous frame, and the datetime associated with the frame.
+    :return: A 2-element tuple where the first element is list of tuples where each tuple
+    contains a date and boolean indicating whether the alarm was active on that date.
+    The second element of the tuple is a list of indices where the first tuple element is False.
     """
 
     sequences_of_static = []
@@ -436,6 +451,7 @@ def repeat_checker(td: TelemetryData, tag: Tag) -> tuple[list[tuple[bool, dateti
     sequences_of_static.append((True, td.get_telemetry_frame(0).time))
 
     values_at_times = td.get_parameter_values(tag)
+
     # Iterate over each pair of timestamps and add a (True, datetime) to the list each time they
     # are the same or (False, datetime) when they aren't.
     for prev_time, curr_time in pairwise(values_at_times.keys()):
@@ -483,8 +499,10 @@ def static_check(dm: DataManager, alarm_base: StaticEventBase,
     # Check which frames share the same value as the previous frame.
     cond_met, false_indexes = repeat_checker(telemetry_data, tag)
 
+    # Check for persistence and create alarms if necessary.
     alarm_indexes = persistence_check(cond_met, sequence, false_indexes)
 
+    # Loop through the alarm indexes and create alarms for each one.
     alarms = []
     first_indexes = []
     for index in alarm_indexes:
@@ -540,7 +558,6 @@ def threshold_check(dm: DataManager, alarm_base: ThresholdEventBase,
     :param criticality: The base criticality of the alarm
     :param earliest_time: The earliest time from a set of the most recently added
     telemetry frames
-    :param all_alarms: Container for the list of all alarms
     :param compound: If this algorithm is being called as part of a compound alarm
     :param cv: Used to notify completion of this task
     :return: A list of all alarms that should be newly raised, and a list of bools
@@ -556,6 +573,7 @@ def threshold_check(dm: DataManager, alarm_base: ThresholdEventBase,
     alarms = []
     times = list(telemetry_data.get_parameter_values(tag).keys())
     all_alarm_frames = []
+
     if lower_threshold is not None:
         # Checking + generating all alarms for crossing the lower threshold
         lower_alarms, lower_alarm_frames = check_conds(telemetry_data, tag, lower_threshold_cond,
@@ -567,6 +585,7 @@ def threshold_check(dm: DataManager, alarm_base: ThresholdEventBase,
             alarms.append(new_alarm)
 
         all_alarm_frames = lower_alarm_frames
+
     if upper_threshold is not None:
         # Checking + generating all alarms for crossing the upper threshold
         upper_alarms, upper_alarm_frames = check_conds(telemetry_data, tag, upper_threshold_cond,
@@ -590,6 +609,7 @@ def threshold_check(dm: DataManager, alarm_base: ThresholdEventBase,
         with cv:
             cv.notify()
             return all_alarm_frames
+    return []
 
 
 def setpoint_cond(param_value: ParameterValue, setpoint: ParameterValue) -> bool:
@@ -656,7 +676,7 @@ def forward_checking_propagator(first_events: list[tuple[int, datetime]],
         -> list[tuple[int, datetime]]:
     """
     Returns a modification of <second_events> of elements where the datetime element occurs
-    in a specified time windows
+    in a specified time window
 
     :param first_events: The list of all events to check time windows after
     :param second_events: The list of all events to compare time window it started in
@@ -665,23 +685,29 @@ def forward_checking_propagator(first_events: list[tuple[int, datetime]],
     satisfying_events = []
     for second_event in second_events:
         for first_event in first_events:
+
+            # Checking if the window between events matches <window_duration>
             lower_threshold = first_event[1] + timedelta(seconds=window_duration[0])
+
             if window_duration[1] is not None:
                 upper_threshold = first_event[1] + timedelta(seconds=window_duration[1])
             else:
                 # If upper threshold is None, we need a time that's guaranteed to be greater than
                 # any second event time
-                upper_threshold = first_events[-1][1] + timedelta(seconds=10)
+                upper_threshold = second_events[-1][1] + timedelta(seconds=10)
 
             if lower_threshold < second_event[1] < upper_threshold:
                 satisfying_events.append(second_event)
                 break
+
     return satisfying_events
 
 
-def get_smallest_domain(events: list[list[tuple[int, datetime]]]) -> int:
+def get_smallest_domain(events: list[Union[list[tuple[int, datetime]], tuple[int, datetime]]]) \
+        -> int:
     """
-    Returns the index of the event with the smallest remaining domain values
+    Returns the index of the event with the smallest remaining domain values that isn't already
+    assigned
 
     :param events: A list of all events to check
     :return: The index of the event with the smallest domain
@@ -691,6 +717,7 @@ def get_smallest_domain(events: list[list[tuple[int, datetime]]]) -> int:
     smallest_index = -1
     for i in range(len(events)):
         event = events[i]
+
         # Skipping already assigned events
         if type(event) is list:
             event_size = len(event)
@@ -700,10 +727,9 @@ def get_smallest_domain(events: list[list[tuple[int, datetime]]]) -> int:
     return smallest_index
 
 
-def backtracking_search(events: list[tuple[int, datetime] | list[tuple[int, datetime]]],
-                        end_events: list[tuple[int, datetime] | list[tuple[int, datetime]]],
-                        time_window: list[tuple[float, float | None]]) \
-        -> list[int]:
+def backtracking_search(events: list[Union[list[tuple[int, datetime]], tuple[int, datetime]]],
+                        end_events: list[Union[list[tuple[int, datetime]], tuple[int, datetime]]],
+                        time_window: list[tuple[float, float | None]]) -> list[int]:
     """
     Employs the backtracking search algorithm to find a sequence of events where each sequential
     event occurs within <time_window> of one another
@@ -711,33 +737,81 @@ def backtracking_search(events: list[tuple[int, datetime] | list[tuple[int, date
     Note: the inputs should probably just be their own class, i'll make the change time permitting
 
     :param events: An ordered list of all events to check through
-    :param end_events: A list of the last index an event
-    occurred corresponding to each event in <events>
-    :param time_window: The window of time where each sequential event must occur within
+    Each index of the outermost list corresponds to an ordered list of events to check through,
+    with inner lists storing the dates and telemetry frame indexes the event occurred at.
+    If the inner list only stores a tuple, we consider it "assigned". That is, we work under the
+    operating assumption that if an SOE event occurred, the detailed start time was the start of
+    one event in the sequence
+
+    :param end_events: A list of the last index an event occurred corresponding to each
+    event in <events>. The choice of inner lists storing tuples vs lists works similarly
+
+    :param time_window: The window of time when each sequential event must occur within. Each
+    index corresponds to the pair of events that had to have occured (ex: index 0 -> the first
+    and seconds events
+
     :return: A list of the first and last index in the sequence of events
     """
-    # Using the MRV heuristic to speed up the search
+    # Using the minimum-remaining-values heuristic to speed up the search
+    # We exclude the last event in the domain as it must be assigned last implicitly
     chosen_domain = get_smallest_domain(events[:len(events) - 1])
+
     if chosen_domain == -1:
         # indicates solution was found
-        return [events[0][0], end_events[-1][-1][0]]
 
-    first_event = end_events[chosen_domain]
-    second_event = events[chosen_domain + 1]
+        # these assertion checks should always pass
+        assert type(events[0][0]) is int
+        first_event = events[0][0]
+
+        assert type(end_events[-1][-1]) is tuple
+        last_events = end_events[-1][-1][0]
+
+        return [first_event, last_events]
+
+    first_event_list = end_events[chosen_domain]
+    assert type(first_event_list) is list
 
-    events[chosen_domain + 1] = forward_checking_propagator(first_event, second_event,
+    second_event_list = events[chosen_domain + 1]
+    assert type(second_event_list) is list
+
+    events[chosen_domain + 1] = forward_checking_propagator(first_event_list, second_event_list,
                                                             time_window[chosen_domain])
+
+    # updating the end events to match the new domain of the chosen variable
+    updated_end_events = []
+    for updated_event in events[chosen_domain + 1]:
+        for i in range(len(end_events[chosen_domain + 1])):
+            curr_end_events = end_events[chosen_domain + 1][i]
+
+            assert type(updated_event) is tuple
+            assert type(curr_end_events) is tuple
+
+            if curr_end_events[0] > updated_event[0]:
+                updated_end_events.append(curr_end_events)
+                break
+
+    end_events[chosen_domain + 1] = updated_end_events
+
     if not events[chosen_domain + 1]:
+        # If any domain is empty, current assignment has no solution, so return the empty list
         return []
     else:
+        # these lists will be mutated, so we copy them so each iteration of the for loop
+        # can re-use values assigned in the current recursive case
         new_events = events.copy()
         new_end_events = end_events.copy()
+
         for i in range(len(events[chosen_domain])):
+            # For each element in the chosen domain, we assign one and check if a solution
+            # to the sequence of events exists
             event = events[chosen_domain][i]
+            assert type(event) is tuple
+
             new_events[chosen_domain] = event
 
             new_end_events[chosen_domain] = end_events[i]
             return backtracking_search(new_events, new_end_events, time_window)
+    return []
 
 
 def pad_alarm_indexes(inner_alarms: list[list[bool]], max_size) -> list[list[bool]]:
@@ -761,7 +835,7 @@ def sequence_of_events_check(dm: DataManager, alarm_base: SOEEventBase,
                              compound: bool, cv: Condition) -> list[bool]:
     """
     Checks that the alarms described in <alarm_base> were all raised and persisted,
-    and occured within the appropriate time window in correct sequential order.
+    and occurred within the appropriate time window in correct sequential order.
 
     :param dm: The source of all data known to the program
     :param alarm_base: Defines events to check
@@ -779,17 +853,21 @@ def sequence_of_events_check(dm: DataManager, alarm_base: SOEEventBase,
 
     # iterate through each of the eventbases and get their list indicating where alarm conditions
     # where met
-    first_indexes = []
-    last_indexes = []
+    first_indexes: list[Union[list[tuple[int, datetime]], tuple[int, datetime]]] = []
+    last_indexes: list[Union[list[tuple[int, datetime]], tuple[int, datetime]]] = []
 
     times = telemetry_data.timestamps()
 
+    # First, we go through each requested event in the sequence of events and collect data on alarms
+    # that did/did not occur
     for possible_event in possible_events:
         strategy = get_strategy(possible_event)
         inner_alarm_indexes = strategy(dm, possible_event, criticality, earliest_time, True,
                                        Condition())
 
         if not inner_alarm_indexes:
+            # If any nested alarm was not raised, sequence of events couldn't have happened,
+            # so return early
             with cv:
                 cv.notify()
                 return [False] * len(inner_alarm_indexes)
@@ -822,6 +900,8 @@ def sequence_of_events_check(dm: DataManager, alarm_base: SOEEventBase,
         first_index = sequence_of_events[0]
         last_index = sequence_of_events[1]
 
+        # We assume only one sequence of events to have occured, so we pad the return list with
+        # True/False using the return value of backtracking search
         up_to_first = [False] * first_index
         up_to_last = [True] * (last_index - first_index)
         up_to_end = [False] * (len(times) - last_index - 1)
@@ -862,7 +942,7 @@ def all_events_check(dm: DataManager, alarm_base: AllEventBase,
     # iterate through each of the eventbases and get their list indicating where alarm conditions
     # where met
 
-    alarm_indexes = []
+    alarm_indexes: list[bool] = []
     taken_indices = set()
     alarm_data = set()
 
@@ -906,7 +986,8 @@ def all_events_check(dm: DataManager, alarm_base: AllEventBase,
 
     alarms = []
     for alarm in alarm_data:
-        new_alarm = create_alarm(alarm, times[len(times) - max_len:], alarm_base, criticality)
+        times_index = int(len(times) - max_len)
+        new_alarm = create_alarm(alarm, times[times_index:], alarm_base, criticality)
         alarms.append(new_alarm)
 
     if not compound:
@@ -942,11 +1023,12 @@ def any_events_check(dm: DataManager, alarm_base: AnyEventBase,
 
     times = telemetry_data.timestamps()
 
-    alarm_indexes = []
+    alarm_indexes: list[bool] = []
     taken_indices = set()
     alarm_data = set()
-    inner_alarms = []
+    inner_alarms: list[list[bool]] = []
     max_len = -math.inf
+
     for possible_event in possible_events:
         strategy = get_strategy(possible_event)
         inner_alarm_indexes = strategy(dm, possible_event, criticality, earliest_time, True,
@@ -980,7 +1062,8 @@ def any_events_check(dm: DataManager, alarm_base: AnyEventBase,
 
     alarms = []
     for alarm in alarm_data:
-        new_alarm = create_alarm(alarm, times[len(times) - max_len:], alarm_base, criticality)
+        times_index = int(len(times) - max_len)
+        new_alarm = create_alarm(alarm, times[times_index:], alarm_base, criticality)
         alarms.append(new_alarm)
 
     if not compound:
diff --git a/src/astra/usecase/alarms_request_receiver.py b/src/astra/usecase/alarms_request_receiver.py
index d4c0f33..b5d88e1 100644
--- a/src/astra/usecase/alarms_request_receiver.py
+++ b/src/astra/usecase/alarms_request_receiver.py
@@ -30,17 +30,40 @@
 
 class AlarmsRequestReceiver(RequestReceiver):
     """
-    AlarmsRequestReceiver is a class that implements the RequestReceiver interface.
-    It handles requests from the alarms tab, such as creating the initial data table,
-    updating the currently represented information, changing the index of the datatable
-    that we are viewing, adding or removing priorities, criticalities or types
-    from the sets of them that we are viewing, and updating the sorting filter to be applied.
+    Handles requests relating to displaying alarms, such as creating the initial alarm table,
+    updating the currently represented information, adding or removing priorities,
+    criticalities or types from the sets of them that we are viewing,
+    and updating the sorting filter to be applied.
+
+    :param filters: Container class for all filters to apply to the table
+    :type: AlarmsFilters
+
+    :param handler: THe class that actually processes requests made by this request receiver
+    :type: AlarmsHandler
+
+    :param previous_data: Stores the return value of the previous call to <cls.create>
+    :type: TableReturn
+
+    :param _sorting: Tracks which direction each row should be sorted by
+    :type: list[int]
+
+    :param _new: Tracks if only new alarms should be shown
+    :type: bool
+
+    :param _priorities: Stores the priorities currently being shown
+    :type: set[str]
+
+    :param _criticalities: Stores the criticalities currently being shown
+    :type: set[str]
+
+    :param _types: Stores the types currently being shown
+    :type: set[str]
     """
 
-    filters = AlarmsFilters(None, None, CRITICALITIES, PRIORITIES, ALL_TYPES, None, None, None,
-                            None, False)
+    filters = AlarmsFilters({Tag("")}, None, CRITICALITIES, PRIORITIES, ALL_TYPES, datetime.min,
+                            datetime.max, datetime.min, datetime.max, False)
     handler = AlarmsHandler()
-    previous_data = None
+    previous_data = TableReturn([], [])
     _sorting = [-1, 1, 1, 1, 1, 1]
     _new = False
     _priorities = {'WARNING', 'LOW', 'MEDIUM', 'HIGH', 'CRITICAL'}
@@ -50,57 +73,47 @@ class AlarmsRequestReceiver(RequestReceiver):
     @classmethod
     def create(cls, dm: DataManager) -> TableReturn:
         """
-        Create is a method that creates the initial data table,
-        with all priorities/types/criticalities shown, no sorting applied and at the first index.
+        Creates a table of data using all alarms and applies any relevant filters or sorts
 
-        :param model: The model of currently shown data
         :param dm: Contains all data stored by the program to date.
         """
-        if cls.filters.tags is None:
-            # Since this needs to be supplied externally, we make a special case for it
+        if "" in cls.filters.tags:
+            # Since the filter tags list needs to be provided externally via the DataManager, a
+            # special case needs to be made to update the filter tags
             cls.filters.tags = set(dm.tags)
 
         # Create the initial table.
-        cls.previous_data = cls.handler.get_data(dm.alarms.get_alarms(), cls.filters)
+        cls.previous_data = cls.handler.get_data(dm, cls.filters)
         return cls.previous_data
 
     @classmethod
     def update(cls):
         """
-        update is a method that updates the currently represented information
-
-        :param previous_data: The previous table that was in the view and we want to update.
-        :param dm: Contains all data stored by the program to date.
+        Updates the current data in the table to represent changes to filters or sorting
         """
-        if cls.previous_data is not None:
-            cls.handler.update_data(cls.previous_data, cls.filters)
+
+        cls.handler.update_data(cls.previous_data, cls.filters)
 
     @classmethod
     def set_shown_tags(cls, tags: set[Tag]):
         """
-        Sets the filtered tags to be equivalent to <tags>
-
-        :param tags: The new set of tags to exclusively include in the table
+        Setter method for <cls.filters.tags>
         """
         cls.filters.tags = tags
 
     @classmethod
     def add_shown_priority(cls, add: str) -> bool:
         """
-        add_shown_priority is a method that adds a priority to the set of priorities
-        that we are viewing. It returns True if it was successful and False otherwise.
+        Adds an alarm priority to the set of priorities that we are viewing.
+        It returns True if it was successful and False otherwise.
 
         :param add: the priority that we want to add to the set of priorities that we are viewing.
-        :returns: True if the priority was successfully added and False otherwise.
+        :returns: True iff the priority was successfully added
         """
 
-        # Make sure that the set of priorities that we are viewing is not None.
-        if cls.filters.priorities is None:
-            cls.filters.priorities = set()
-
         # Determine if we can add <add> to the set of priorities that we are viewing.
         if add not in cls.filters.priorities:
-            cls.filters.priorities.add(AlarmCriticality(add))
+            cls.filters.priorities.add(add)
             return True
         else:
             # <add> was already in the set of priorities that we are viewing.
@@ -109,21 +122,17 @@ def add_shown_priority(cls, add: str) -> bool:
     @classmethod
     def add_shown_criticality(cls, add: AlarmCriticality) -> bool:
         """
-        add_shown_criticality is a method that adds a criticality to the set of criticalities
-        that we are viewing. It returns True if it was successful and False otherwise.
+        Adds a criticality to the set of criticalities that we are viewing. Returns True iff
+        it was successful
 
         :param add: the criticality that we want to add to the set of criticalities that we
         are viewing.
-        :returns: True if the criticality was successfully added and False otherwise.
+        :returns: True iff the criticality was successfully added
         """
 
-        # Make sure that the set of criticalities that we are viewing is not None.
-        if cls.filters.criticalities is None:
-            cls.filters.criticalities = set()
-
         # Determine if we can add <add> to the set of criticalities that we are viewing.
         if add not in cls.filters.criticalities:
-            cls.filters.criticalities.add(add)
+            cls.filters.criticalities.add(add.name)
             return True
         else:
             # <add> was already in the set of criticalities that we are viewing.
@@ -152,35 +161,139 @@ def add_shown_type(cls, add: str) -> bool:
             return False
 
     @classmethod
-    def set_shown_priorities(cls, priorities: set[AlarmPriority]):
+    def toggle_sort(cls, heading: str) -> bool:
         """
-        Sets <cls.filters.priorities> to the set of priorities to be shown
+        Method for toggling sorting on a specific heading
+        The headings include:
+        - TAG
+        - PRIORITY
+        - CRITICALITY
+        - REGISTERED
+        - CONFIRMED
+        - TYPE
+        This method will filter the data according to which heading was toggled
 
-        PRECONDITION: <priority> is an element of <cls.filters.priorities>
+        :param heading: the sort name that was toggled
+        """
+        sort_value = 1
+        for i in range(len(ALARM_HEADINGS)):
+            check_heading = ALARM_HEADINGS[i]
+            if check_heading == heading:
+                cls._sorting[i] *= -1
+                sort_value = cls._sorting[i] * (heading == check_heading)
+            else:
+                cls._sorting[i] = 1
+
+        if sort_value == 1:
+            # ascending
+            cls.update_sort(('<', heading))
+        elif sort_value == -1:
+            # descending
+            cls.update_sort(('>', heading))
+
+        return sort_value == 1
 
-        :param priorities: a set of priorities to show
+    @classmethod
+    def toggle_priority(cls, tag: Tag):
         """
-        cls.filters.priorities = priorities
+        Method for toggling filtering of specific priority
+        The headings include:
+        - WARNING
+        - LOW
+        - MEDIUM
+        - HIGH
+        - CRITICAL
+        This method will filter the data according to which heading was toggled
+
+        :param tag: The priority name to toggle on/off
+        """
+        if tag not in cls._priorities:
+            cls._priorities.add(tag)
+        else:
+            cls._priorities.remove(tag)
+
+        cls.set_shown_priorities(cls._priorities)
+        cls.update()
 
     @classmethod
-    def set_shown_criticalities(cls, criticalities: set[AlarmCriticality]):
+    def toggle_criticality(cls, tag: Tag):
         """
-        Sets <cls.filters.criticalities> to the set of criticalities to be shown
+        Method for toggling filtering of specific criticality
+        The headings include:
+        - WARNING
+        - LOW
+        - MEDIUM
+        - HIGH
+        - CRITICAL
+        This method will filter the data according to which heading was toggled
+
+        :param tag: string representing which criticality was toggled
+        """
+        if tag not in cls._criticalities:
+            cls._criticalities.add(tag)
+        else:
+            cls._criticalities.remove(tag)
 
-        PRECONDITION: <criticality> is an element of <cls.filters.criticalities>
+        cls.set_shown_criticalities(cls._criticalities)
+        cls.update()
 
-        :param criticalities: a set of criticalities to show
+    @classmethod
+    def toggle_type(cls, tag: Tag):
         """
-        cls.filters.criticalities = criticalities
+        Method for toggling filtering of specific criticality
+        The headings include:
+        - RATE-OF-CHANGE
+        - STATIC
+        - THRESHOLD
+        - SETPOINT
+        - SOE
+        - LOGICAL
+        This method will filter the data according to which heading was toggled
+
+        :param tag: string representing which type of alarm was toggled
+        """
+
+        if tag not in cls._types:
+            cls._types.add(tag)
+        else:
+            cls._types.remove(tag)
+
+        cls.set_shown_types(cls._types)
+        cls.update()
 
     @classmethod
-    def set_shown_types(cls, types: set[str]):
+    def toggle_all(cls) -> None:
+        """
+        Resets all non-parameter filters to their default options. That is,
+        all alarms of different acknowledgement levels, priorities, criticalities, and types are
+        shown
+        """
+
+        cls.set_new_alarms(False)
+        cls.set_shown_priorities(cls._priorities)
+        cls.set_shown_criticalities(cls._criticalities)
+        cls.set_shown_types(cls._types)
+
+    @classmethod
+    def set_shown_priorities(cls, priorities: set[str]):
+        """
+        Setter method for <cls.filters.priorities>
         """
-        Sets <cls.filters.types> to the set of types to be shown
 
-        PRECONDITION: <type> is an element of <cls.filters.types>
+        cls.filters.priorities = priorities
 
-        :param types: a set of types to show
+    @classmethod
+    def set_shown_criticalities(cls, criticalities: set[str]):
+        """
+        Setter method for <cls.filters.criticalities>
+        """
+
+        cls.filters.criticalities = criticalities
+
+    @classmethod
+    def set_shown_types(cls, types: set[str]):
+        """
+        Setter method for <cls.filters.types>
         """
         cls.filters.types = types
 
@@ -201,7 +314,7 @@ def remove_shown_priority(cls, remove: AlarmPriority) -> bool:
 
         # Determine if we can remove <remove> from the set of priorities that we are viewing.
         if remove in cls.filters.priorities:
-            cls.filters.priorities.remove(remove)
+            cls.filters.priorities.remove(remove.name)
             return True
         else:
             # <remove> was not in the set of priorities that we are viewing.
@@ -224,7 +337,7 @@ def remove_shown_criticality(cls, remove: AlarmCriticality) -> bool:
 
         # Determine if we can remove <remove> from the set of criticalities that we are viewing.
         if remove in cls.filters.criticalities:
-            cls.filters.criticalities.remove(remove)
+            cls.filters.criticalities.remove(remove.name)
             return True
         else:
             # <remove> was not in the set of criticalities that we are viewing.
@@ -278,48 +391,50 @@ def update_sort(cls, sort: tuple[str, str]) -> bool:
     @classmethod
     def set_registered_start_time(cls, start_time: datetime):
         """
-        Modifies <cls.filters.registered_start_time> to be equal to <start_time>
-
-        :param start_time: the datetime to be set
+        setter method for <cls.filters.confirmed_start_time>
         """
-        cls.filters.registered_start_time = start_time
+        if start_time is None:
+            cls.filters.registered_start_time = datetime.min
+        else:
+            cls.filters.registered_start_time = start_time
 
     @classmethod
     def set_registered_end_time(cls, end_time: datetime):
         """
-        Modifies <cls.filters.registered_end_time> to be equal to <end_time>
-
-        :param end_time: the datetime to be set
+        setter method for <cls.filters.registered_end_time>
         """
-        cls.filters.registered_end_time = end_time
+
+        if end_time is None:
+            cls.filters.registered_end_time = datetime.max
+        else:
+            cls.filters.registered_end_time = end_time
 
     @classmethod
     def set_confirmed_start_time(cls, start_time: datetime):
         """
-        Modifies <cls.filters.confirmed_start_time> to be equal to <start_time>
-
-        :param start_time: the datetime to be set
+        setter method for <cls.filters.confirmed_start_time>
         """
-        cls.filters.confirmed_start_time = start_time
+        if start_time is None:
+            cls.filters.confirmed_start_time = datetime.min
+        else:
+            cls.filters.confirmed_start_time = start_time
 
     @classmethod
     def set_confirmed_end_time(cls, end_time: datetime):
         """
-        Modifies <cls.filters.confirmed_end_time> to be equal to <end_time>
-
-        :param end_time: the datetime to be set
+        setter method for <cls.filters.confirmed_end_time>
         """
-        cls.filters.confirmed_end_time = end_time
+        if end_time is None:
+            cls.filters.confirmed_end_time = datetime.max
+        else:
+            cls.filters.confirmed_end_time = end_time
 
     @classmethod
     def set_new_alarms(cls, new: bool):
         """
-        Sets the <cls.filters.new> to <new>.
-
-        :param new: the value to set <cls.filters.new> to. True indicates
-        that we will only show new/unacknowledged alarms, False indicates that we will
-        show all alarms.
+        setter method for <cls.filters.new>
         """
+
         cls.filters.new = new
 
     @classmethod
@@ -327,6 +442,7 @@ def toggle_new_only(cls) -> None:
         """
         Switches the boolean value of <cls.filters.new>
         """
+
         cls.filters.new = not cls.filters.new
 
     @classmethod
@@ -337,6 +453,7 @@ def acknowledge_alarm(cls, alarm: Alarm, dm: DataManager) -> None:
         :param alarm: The alarm whose acknowledgment needs to be modified
         :param dm: Stores all data known to the program
         """
+
         cls.handler.acknowledge_alarm(alarm, dm)
 
     @classmethod
@@ -347,11 +464,15 @@ def remove_alarm(cls, alarm: Alarm, dm: DataManager) -> None:
         :param alarm: The alarm to remove
         :param dm: The holder of the global alarm container
         """
+
         cls.handler.remove_alarm(alarm, dm)
 
     @classmethod
     def get_alarm_banner(cls) -> list[str]:
-        """Returns a list of strings in order to show in the alarm banners"""
+        """
+        Returns a list of strings in order to show in the alarm banners
+        """
+
         return cls.handler.get_banner_elems()
 
     @classmethod
@@ -359,140 +480,45 @@ def install_alarm_watcher(cls, dm: DataManager, watcher: Callable) -> None:
         """
         An interfacing function for the alarm container to install a watcher function
         """
+
         dm.alarms.observer.add_watcher(watcher)
 
     @classmethod
     def get_table_entries(cls) -> list[list]:
-        if cls.previous_data is not None:
-            return cls.previous_data.table
-        return []
-
-    @classmethod
-    def get_new(cls) -> bool:
-        return cls.filters.new
-
-    @classmethod
-    def get_priorities(cls):
-        return cls._priorities
-
-    @classmethod
-    def get_criticalities(cls):
-        return cls._criticalities
+        """
+        getter method for the data to actually be shown in the alarms table
+        """
 
-    @classmethod
-    def get_types(cls):
-        return cls._types
+        return cls.previous_data.table
 
     @classmethod
-    def toggle_sort(cls, heading: str) -> bool:
+    def get_new(cls) -> bool:
         """
-        Method for toggling sorting on a specific heading
-        The headings include (for now):
-        - TAG
-        - PRIORITY
-        - CRITICALITY
-        - REGISTERED
-        - CONFIRMED
-        - TYPE
-        This method will ask the model to sort the data
-        according to which heading was toggled
-
-        Args:
-            heading (str): string representing which heading was toggled
+        getter method for whether only unacknowledged alarms should be shown or not
         """
-        sort_value = 1
-        for i in range(len(ALARM_HEADINGS)):
-            check_heading = ALARM_HEADINGS[i]
-            if check_heading == heading:
-                cls._sorting[i] *= -1
-                sort_value = cls._sorting[i] * (heading == check_heading)
-            else:
-                cls._sorting[i] = 1
-
-        if sort_value == 1:
-            # ascending
-            cls.update_sort(('<', heading))
-        elif sort_value == -1:
-            # descending
-            cls.update_sort(('>', heading))
 
-        return sort_value == 1
+        return cls.filters.new
 
     @classmethod
-    def toggle_priority(cls, tag: Tag):
+    def get_priorities(cls):
         """
-        Method for toggling filtering of specific priority
-        The headings include (for now):
-        - WARNING
-        - LOW
-        - MEDIUM
-        - HIGH
-        - CRITICAL
-        This method will ask the model to sort the data
-        according to which heading was toggled
-
-        Args:
-            heading (str): string representing which heading was toggled
+        getter method for the priorities currently shown
         """
-        if tag not in cls._priorities:
-            cls._priorities.add(tag)
-        else:
-            cls._priorities.remove(tag)
 
-        cls.set_shown_priorities(cls._priorities)
-        cls.update()
+        return cls._priorities
 
-    def toggle_criticality(cls, tag: Tag):
+    @classmethod
+    def get_criticalities(cls):
         """
-        Method for toggling filtering of specific criticality
-        The headings include (for now):
-        - WARNING
-        - LOW
-        - MEDIUM
-        - HIGH
-        - CRITICAL
-        This method will ask the model to sort the data
-        according to which heading was toggled
-
-        Args:
-            heading (str): string representing which heading was toggled
+        getter method for the criticalities currently shown
         """
-        if tag not in cls._criticalities:
-            cls._criticalities.add(tag)
-        else:
-            cls._criticalities.remove(tag)
 
-        cls.set_shown_criticalities(cls._criticalities)
-        cls.update()
+        return cls._criticalities
 
     @classmethod
-    def toggle_type(cls, tag: Tag):
+    def get_types(cls):
         """
-        Method for toggling filtering of specific criticality
-        The headings include (for now):
-        - RATE-OF-CHANGE
-        - STATIC
-        - THRESHOLD
-        - SETPOINT
-        - SOE
-        - LOGICAL
-        This method will ask the model to sort the data
-        according to which heading was toggled
-
-        Args:
-            heading (str): string representing which heading was toggled
+        getter method for the types of alarms shown
         """
-        if tag not in cls._types:
-            cls._types.add(tag)
-        else:
-            cls._types.remove(tag)
-
-        cls.set_shown_types(cls._types)
-        cls.update()
 
-    @classmethod
-    def toggle_all(cls) -> None:
-        cls.set_new_alarms(False)
-        cls.set_shown_priorities(cls._priorities)
-        cls.set_shown_criticalities(cls._criticalities)
-        cls.set_shown_types(cls._types)
+        return cls._types
diff --git a/src/astra/usecase/dashboard_handler.py b/src/astra/usecase/dashboard_handler.py
index ba23fe3..d6f6c55 100644
--- a/src/astra/usecase/dashboard_handler.py
+++ b/src/astra/usecase/dashboard_handler.py
@@ -1,11 +1,11 @@
-import queue
+from queue import Queue
 from typing import Iterable
 
 from astra.data.alarms import (
     Alarm,
     AlarmCriticality,
-    AlarmPriority,
 )
+
 from .filters import DashboardFilters
 from .table_return import TableReturn, TelemetryTableReturn
 from astra.data.data_manager import DataManager
@@ -22,7 +22,7 @@
 CONFIG = 'CONFIG'
 ROUNDING_DECMIALS = 2
 # For now, this choice is somewhat arbitrary
-CACHE_SIZE = 20
+CACHE_SIZE = 200
 
 
 class DashboardHandler:
@@ -31,9 +31,10 @@ class DashboardHandler:
     """
 
     @staticmethod
-    def search_tags(search: str, cache: dict[str: Iterable[Tag]], eviction: queue) -> list[Tag]:
+    def search_tags(search: str, cache: dict[str, Iterable[str]], eviction: Queue) \
+            -> Iterable[str]:
         """
-        Searches for all tags where <search> is a substring of the tag
+        Finds any tag where their tag name or description matches <tag> and returns them
 
         :param search: The substring to search for
         :param cache: Stores CACHE_SIZE + 1 keys, where each key matches a previous <search>
@@ -51,8 +52,12 @@ def search_tags(search: str, cache: dict[str: Iterable[Tag]], eviction: queue) -
                 closest = prev_search
                 max_len = len(prev_search)
 
+        # If search request is already in the cache
         if closest == search:
             return cache[search]
+
+        # Search request is not already in the cache, so we perform the search on the closest
+        # option
         matching = []
         for tag in cache[closest]:
             lower_tag = tag.lower()
@@ -63,6 +68,7 @@ def search_tags(search: str, cache: dict[str: Iterable[Tag]], eviction: queue) -
             cache[search] = matching
             eviction.put(search)
 
+        # evicting from the cache if needed
         if len(cache) == CACHE_SIZE + 2:
             remove = eviction.get()
             cache.pop(remove)
@@ -71,7 +77,7 @@ def search_tags(search: str, cache: dict[str: Iterable[Tag]], eviction: queue) -
     @classmethod
     def _format_param_value(cls, tag_data: ParameterValue | None) -> str:
         """
-        Formats the <tag_data>.
+        Formats the <tag_data> for viewing in the telemetry dashboard
 
         :param tag_data: The (converted) data to format
         :return: A string with the appropriate formatting
@@ -97,7 +103,7 @@ def _format_alarm_data(cls, alarm: Alarm | None) -> str:
 
     @classmethod
     def _tag_to_alarms(cls, tags: list[Tag],
-                       alarms: dict[AlarmPriority, list[Alarm]]) -> dict[Tag, Alarm]:
+                       alarms: dict[str, list[Alarm]]) -> dict[Tag, Alarm]:
         """
         Finds and returns the highest priority alarm for each Tag in <tags, for use in
         displaying some alarm data in the telemetry dashboard.
@@ -168,14 +174,17 @@ def _add_rows_to_output(cls, input_tags: Iterable[Tag], dm: DataManager, tf: Tel
             tag_setpoint_value = eval_param_value(
                 tag_parameters, raw_tag_setpoint_value)
 
+            # creating strings for relevant tag data
             tag_value = cls._format_param_value(tag_data)
             tag_setpoint = cls._format_param_value(tag_setpoint_value)
 
+            # creating strings for unit of measurement of each tag
             if tag_parameters.display_units is None:
                 tag_units = "-"
             else:
                 tag_units = tag_parameters.display_units.symbol
 
+            # creating strings for the highest priority alarm associated with the tag
             tag_alarm_data = cls._format_alarm_data(tag_alarm)
 
             include_tag = tag in input_tags
@@ -219,8 +228,7 @@ def _sort_output(cls, return_data: TableReturn, sort: tuple[str, str]):
     @classmethod
     def get_data(cls, dm: DataManager, filter_args: DashboardFilters):
         """
-        An implementation of get_data for the Telemetry Dashboard to create a
-        data table pertaining to a single telemetry frame with data filtering
+        Creates a data table pertaining to a single telemetry frame with data filtering
         requested by the user
 
         :param dm: Contains all data stored by the program to date
@@ -238,6 +246,7 @@ def get_data(cls, dm: DataManager, filter_args: DashboardFilters):
 
         # First, all the return data
         timestamp = telemetry_frame.time
+
         include, remove = cls._add_rows_to_output(
             filter_args.tags, dm,
             telemetry_frame)
@@ -254,11 +263,8 @@ def get_data(cls, dm: DataManager, filter_args: DashboardFilters):
     @classmethod
     def update_data(cls, previous_table: TelemetryTableReturn, filter_args: DashboardFilters):
         """
-        An implementation of update_data for the Telemetry Dashboard to update fields
-        based on new sorting requests from the user
+        Updates the currently shown table based on new filter or sort requests from the user
 
-
-        :param dm: Contains all data stored by the program to date
         :param filter_args: Defines all filters to be applied
         :param previous_table: A representation of the current shown data in
         the Telemetry Dashboard
diff --git a/src/astra/usecase/dashboard_request_receiver.py b/src/astra/usecase/dashboard_request_receiver.py
new file mode 100644
index 0000000..dca61a7
--- /dev/null
+++ b/src/astra/usecase/dashboard_request_receiver.py
@@ -0,0 +1,272 @@
+from datetime import datetime
+from queue import Queue
+from typing import Iterable
+
+from astra.data.data_manager import DataManager
+from astra.data.parameters import Tag
+from astra.usecase.dashboard_handler import DashboardHandler
+from astra.usecase.filters import DashboardFilters
+from astra.usecase.request_receiver import RequestReceiver
+from astra.usecase.table_return import TableReturn
+
+VALID_SORTING_DIRECTIONS = {'>', '<'}
+VALID_SORTING_COLUMNS = {'TAG', 'DESCRIPTION'}
+DASHBOARD_HEADINGS = ['TAG', 'DESCRIPTION']
+
+
+class DashboardRequestReceiver(RequestReceiver):
+    """
+    DashboardRequestReceiver is a class that implements the RequestReceiver interface.
+    It handles requests from the dashboard, such as creating the initial data table,
+    updating the currently represented information, changing the index of the datatable
+    that we are viewing, adding or removing a tag from the set of tags that we are viewing,
+    and updating the sorting filter to be applied.
+    """
+
+    filters = DashboardFilters({Tag("")}, (">", "TAG"),
+                               0, datetime.min, datetime.max)
+    handler = DashboardHandler()
+    search_cache: dict[str, Iterable[str]] = dict()
+    search_eviction: Queue[str] = Queue()
+    _sorting = [-1, 1]
+    previous_data = None
+
+    @classmethod
+    def create(cls, dm: DataManager) -> TableReturn:
+        """
+        Create is a method that creates the initial data table,
+        with all tags shown, no sorting applied and at the first index.
+
+        :param dm: Contains all data stored by the program to date.
+        """
+
+        all_tags = dm.tags
+
+        # Add all tags to the shown tags by default.
+        if "" in cls.filters.tags:
+            cls.filters.tags = set(all_tags)
+
+        # Set the index to the first index by default.
+        if cls.filters.index is None:
+            cls.filters.index = 0
+
+        # Create the initial table.
+        cls.previous_data = cls.handler.get_data(dm, cls.filters)
+        return cls.previous_data
+
+    @classmethod
+    def update(cls):
+        """
+        update is a method that updates the currently represented information
+        """
+        if cls.previous_data is not None:
+            cls.handler.update_data(cls.previous_data, cls.filters)
+
+    @classmethod
+    def change_index(cls, index: int) -> bool:
+        """
+        change_index changes the index of the datatable
+        that we are viewing. It returns True if it was successful and False otherwise.
+
+        :param index: the index of the datatable that we want to change to.
+        :returns: True if the index was successfully changed and False otherwise.
+        """
+
+        cls.filters.index = index
+
+        # Determine if we can update the view without issues.
+        if cls.filters.tags is None:
+            return False
+        return True
+
+    @classmethod
+    def add_shown_tag(cls, add: str) -> bool:
+        """
+        add_shown_tag is a method that adds a tag to the set of tags
+        that we are viewing. It returns True if it was successful and False otherwise.
+
+        :param add: the tag that we want to add to the set of tags that we are viewing.
+        :returns: True if the tag was successfully added and False otherwise.
+        """
+        if cls.filters.tags is None:
+            cls.filters.tags = set()
+
+        # Determine if we can add the tag to the set of tags that we are viewing.
+        tag_index = add.index(':')
+        add_tag = add[:tag_index]
+        if add_tag not in cls.filters.tags:
+            cls.filters.tags.add(Tag(add_tag))
+            return True
+        else:
+            # Tag was already in the set of tags that we are viewing.
+            return False
+
+    @classmethod
+    def set_shown_tags(cls, tags: Iterable[Tag]):
+        """
+        Sets <cls.filters.tags> to the set of tags to be shown
+
+        PRECONDITION: <tag> is an element of <cls.filters.tags>
+
+        :param tags: a set of tags to show
+        """
+        cls.filters.tags = set(tags)
+
+    @classmethod
+    def remove_shown_tag(cls, remove: str) -> bool:
+        """
+        Remove a tag from the set of tags that we are viewing.
+        It returns True if it was successful and False otherwise.
+
+        :param remove: The tag that we want to remove from the set of tags that we are viewing.
+        :return: True if the tag was successfully removed and False otherwise.
+        """
+        if cls.filters.tags is None:
+            cls.filters.tags = set()
+
+        # Determine if we can remove the tag from the set of tags that we are viewing.
+        tag_index = remove.index(':')
+        remove_tag = remove[:tag_index]
+        if remove_tag in cls.filters.tags:
+            cls.filters.tags.remove(Tag(remove_tag))
+            return True
+        else:
+            return False  # Tag was not in the set of tags that we are viewing.
+
+    @classmethod
+    def toggle_sort(cls, heading: str) -> bool:
+        """
+        Method for toggling sorting on a specific heading
+        The headings include (for now):
+        - TAG
+        - DESCRIPTION
+        This method will ask the model to sort the data
+        according to which heading was toggled
+
+        Args:
+            heading (str): string representing which heading was toggled
+        """
+        sort_value = -1
+        for i in range(len(DASHBOARD_HEADINGS)):
+            check_heading = DASHBOARD_HEADINGS[i]
+            if heading == check_heading:
+                cls._sorting[i] *= -1
+                sort_value = cls._sorting[i]
+            else:
+                cls._sorting[i] = 1
+
+        if sort_value == 1:
+            # ascending
+            cls.update_sort(('>', heading))
+        elif sort_value == -1:
+            # descending
+            cls.update_sort(('<', heading))
+        return sort_value == 1
+
+    @classmethod
+    def update_sort(cls, sort: tuple[str, str]) -> bool:
+        """
+        Updates the sorting filter to be applied.
+        It returns True if the sorting filter was successfully applied and False otherwise.
+
+        :param sort: the first value in the tuple for this key will
+             be either ">", indicating sorting by increasing values,
+             and "<" indicating sorting by decreasing values. The second
+             value will indicate the name of the column to sort by.
+        :returns: True if the sorting filter was successfully updated and False otherwise.
+        """
+
+        # Determine if the sorting filter is valid.
+        if sort[0] not in VALID_SORTING_DIRECTIONS:
+            return False
+        if sort[1] not in VALID_SORTING_COLUMNS:
+            return False
+
+        # both if statements failed, so the filter is valid.
+        cls.filters.sort = sort
+        return True
+
+    @classmethod
+    def set_start_time(cls, start_time: datetime):
+        """
+        Modifies <cls.filters.start_time> to be equal to <start_time>
+
+        :param start_time: the datetime to be set
+        """
+        cls.filters.start_time = start_time
+
+    @classmethod
+    def set_end_time(cls, end_time: datetime):
+        """
+        Modifies <cls.filters.end_time> to be equal to <end_time>
+
+        :param end_time: the datetime to be set
+        """
+        cls.filters.end_time = end_time
+
+    @classmethod
+    def search_tags(cls, search: str, dm: DataManager) -> Iterable[str]:
+        """
+        Finds all tags in <cls.filters.tags> where <search> is a substring
+
+        :param search: The substring to search for
+        :param dm: The source of all data known to the program
+        :return: A list of all satisfying tags
+        """
+        all_tags = dm.tags
+        if len(cls.search_cache) == 0:
+            all_params = dm.parameters
+            tag_strs = []
+            for tag in all_tags:
+                param = all_params[tag]
+                tag_strs.append(tag + ": " + param.description)
+            tag_strs.sort()
+            cls.search_cache[''] = tag_strs
+
+        return cls.handler.search_tags(search, cls.search_cache, cls.search_eviction)
+
+    @classmethod
+    def get_num_frames(cls) -> int:
+        """
+        Returns the number of frames from the last call to <cls.create> or <cls.update>
+
+        :return: The number of telemetry frames in consideration
+        """
+        if cls.previous_data is not None:
+            return cls.previous_data.frame_quantity
+        else:
+            return 0
+
+    @classmethod
+    def get_time(cls) -> datetime | None:
+        """
+        Returns the time of the currently examined frame
+
+        :return: The time of the currently examined frame, or None if no data is in the
+        telemetry dashboard
+        """
+
+        if cls.previous_data is not None:
+            return cls.previous_data.timestamp
+        return None
+
+    @classmethod
+    def load_file(cls, file: str, dm: DataManager) -> None:
+        """
+        Adds a telemetry file to the database
+
+        :param dm: Stores all data known to the program
+        :param file: The file storing data to add
+        """
+
+    @classmethod
+    def get_table_entries(cls) -> list[list] | None:
+        """
+        Returns the table entries from the previous call to <create> or <update>
+
+        :return: the table entries from the previous call to <create> or <update>
+        """
+        if cls.previous_data is None:
+            return None
+        else:
+            return cls.previous_data.table
diff --git a/src/astra/usecase/filters.py b/src/astra/usecase/filters.py
index f75f402..48a38b2 100644
--- a/src/astra/usecase/filters.py
+++ b/src/astra/usecase/filters.py
@@ -1,7 +1,5 @@
 from dataclasses import dataclass
 from datetime import datetime
-
-from astra.data.alarms import AlarmPriority, AlarmCriticality
 from astra.data.parameters import Tag
 
 
@@ -12,7 +10,7 @@ class Filters:
 
     :param tags: A set of all tags to be shown
     """
-    tags: set[Tag] | None
+    tags: set[Tag]
 
 
 @dataclass
@@ -31,10 +29,10 @@ class DashboardFilters(Filters):
     All of the above parameters may be None iff they have never been set before
     """
 
-    sort: tuple[str, str] | None
-    index: int | None
-    start_time: datetime | None
-    end_time: datetime | None
+    sort: tuple[str, str]
+    index: int
+    start_time: datetime
+    end_time: datetime
 
 
 @dataclass
@@ -61,13 +59,13 @@ class AlarmsFilters(Filters):
     """
 
     sort: tuple[str, str] | None
-    priorities: set[AlarmPriority] | None
-    criticalities: set[AlarmCriticality] | None
-    types: set[str] | None
-    registered_start_time: datetime | None
-    registered_end_time: datetime | None
-    confirmed_start_time: datetime | None
-    confirmed_end_time: datetime | None
+    priorities: set[str]
+    criticalities: set[str]
+    types: set[str]
+    registered_start_time: datetime
+    registered_end_time: datetime
+    confirmed_start_time: datetime
+    confirmed_end_time: datetime
     new: bool
 
 
@@ -78,8 +76,7 @@ class GraphingFilters(Filters):
 
     :param start_time: the earliest time that values for each tag are from.
     :param end_time: the latest time that values for each tag are from.
-    :param interval: The number of frams between each value in the list of values.
     """
 
-    start_time: datetime | None
-    end_time: datetime | None
+    start_time: datetime
+    end_time: datetime
diff --git a/src/astra/usecase/graphing_handler.py b/src/astra/usecase/graphing_handler.py
index 806f2ae..2cd1397 100644
--- a/src/astra/usecase/graphing_handler.py
+++ b/src/astra/usecase/graphing_handler.py
@@ -11,11 +11,11 @@
 @dataclass
 class GraphingData:
     """
-    A container for data needed by the fronted to graph the requested tags. For each tag,
+    A container for data needed by the frontend to graph the requested tags. For each tag,
     the length of their times and values lists must be the same.
 
     :param shown_tags: A dictionary where each key is a tag, and each value is a tuple of lists.
-    the first list is a list of strings representing times and the second is a list of values at
+    The first list is a list of strings representing times and the second is a list of values at
     those times for that tag. These lists must be the same length.
     :param curr_telemetry_data: The telemetry data that was used to create the <shown_tags>. It is
     used to correctly filter data when it is requested without accessing the database each time.
@@ -28,7 +28,7 @@ class GraphingData:
 
 class GraphingHandler:
     """
-    GraphingHandler is a implementation of UseCaseHandler for the graphing tab.
+    GraphingHandler is an implementation of UseCaseHandler for the graphing tab.
     It takes care of acquiring and formatting data needed by the graphing tab.
     """
 
@@ -42,7 +42,7 @@ def get_data(cls, dm: DataManager, filter_args: GraphingFilters) -> GraphingData
         :param filter_args: Contains all information on filters to be applied
         :return: A GraphingData object containing the data needed to graph the requested tags.
         """
-        # get the data from the database
+        # get all data from the database
         telemetry_data = dm.get_telemetry_data(
             None, None, dm.tags)
 
@@ -58,19 +58,19 @@ def get_data(cls, dm: DataManager, filter_args: GraphingFilters) -> GraphingData
     def update_data(cls, prev_data: GraphingData, filter_args: GraphingFilters) -> None:
         """
         update_data is a method that updates the currently represented information,
-        by modifying <prev_data> to match the current filters. Note, this method
-        will not add new data from the database.
+        by modifying <prev_data> to match the current filters given in <filter_args>.
+        Note, this method will not add new data from the database.
 
         :param prev_data: The representation of the current state of displayed data
         :param filter_args: Contains all information on filters to be applied
-        :param dm: Contains all data stored by the program to date
         """
         cls._filter_graphing_data(prev_data, filter_args)
 
     @classmethod
     def export_data_to_file(cls, prev_data: GraphingData, file_name: str) -> None:
         """
-        export_data_to_file is a method that exports the graph to a file.
+        export_data_to_file is a method that exports the current data to the file given by
+        <file_name>.
 
         :param prev_data: The representation of the current state of displayed data
         :param file_name: The name of the file to export the graph to.
@@ -78,6 +78,7 @@ def export_data_to_file(cls, prev_data: GraphingData, file_name: str) -> None:
 
         interval = 1
 
+        # call on the telemetry data to save the data to the file.
         prev_data.curr_telemetry_data.save_to_file(file_name, interval)
 
     @classmethod
@@ -101,7 +102,8 @@ def _filter_graphing_data(cls, graphing_data: GraphingData,
         formatted_times_list = [time.strftime(DATETIME_FORMAT)
                                 for time in times_list[min_index: max_index + 1]]
 
-        # Remove all tags before looking through the filter to get only the required tags
+        # Remove all tags before looking through the filter so that the tags that are not
+        # in the filter are not shown.
         graphing_data.shown_tags.clear()
 
         # If the max and min index are the same, there are no values within the time_frame.
@@ -126,7 +128,7 @@ def _filter_times(cls, times_list: list[datetime],
         This method returns a tuple of ints representing indices that give a slice
         of the <times_list> where all times in it are >= <start_time> and <= <end_time>.
 
-        :param imtes_list: The list of times in chronological order that we need the slice of, which
+        :param times_list: The list of times in chronological order that we need the slice of, which
         is between the <start_time> and <end_time>.
         :param start_time: The datetime that is the earliest time that values for each tag
         are from.
@@ -146,9 +148,12 @@ def _find_min_index(times_list: list[datetime], start_time: datetime | None) ->
 
         Precondition: times_list is sorted chronologically and there are no duplicate times
         """
+
+        # Determine if the start_time is None, and if so, return 0.
         if start_time is None:
             return 0
 
+        # Perform a binary search to find the index of the first time that is >= <start_time>.
         curr_min = 0
         curr_max = len(times_list) - 1
 
@@ -165,7 +170,7 @@ def _find_min_index(times_list: list[datetime], start_time: datetime | None) ->
             elif times_list[index] < start_time:
                 curr_min = index + 1
 
-        # In the case that the loop ends, curr_min will be the index of the first time
+        # In the case that the loop ends, <curr_min> will be the index of the first time
         # that is after <start_time>.
         return curr_min
 
@@ -181,9 +186,11 @@ def _find_max_index(times_list: list[datetime], end_time: datetime | None) -> in
 
         Precondition: times_list is sorted chronologically and there are no duplicate times
         """
+        # Determine if the start_time is None, and if so, return 0.
         if end_time is None:
             return len(times_list) - 1
 
+        # Perform a binary search to find the index of the first time that is <= <end_time>.
         curr_min = 0
         curr_max = len(times_list) - 1
 
@@ -200,6 +207,6 @@ def _find_max_index(times_list: list[datetime], end_time: datetime | None) -> in
             elif times_list[index] < end_time:
                 curr_min = index + 1
 
-        # In the case that the loop ends, curr_max will be the index of the last time
+        # In the case that the loop ends, <curr_max> will be the index of the last time
         # that is before <end_time>.
         return curr_max
diff --git a/src/astra/usecase/graphing_request_receiver.py b/src/astra/usecase/graphing_request_receiver.py
index 10fa322..f420cf7 100644
--- a/src/astra/usecase/graphing_request_receiver.py
+++ b/src/astra/usecase/graphing_request_receiver.py
@@ -16,7 +16,7 @@ class GraphingRequestReceiver(RequestReceiver):
     """
 
     handler = GraphingHandler()
-    filters = GraphingFilters(set(), None, None)
+    filters = GraphingFilters(set(), datetime.min, datetime.max)
 
     @classmethod
     def create(cls, dm: DataManager) -> GraphingData:
@@ -32,7 +32,8 @@ def create(cls, dm: DataManager) -> GraphingData:
     def update(cls) -> None:
         """
         update is a method that updates the currently represented information,
-        by mutating the data in <previous_data> to match the current filters.
+        by mutating the data in <cls.previous_data> to match the current filters
+        given in <cls.filters>.
         """
 
         cls.handler.update_data(cls.previous_data, cls.filters)
@@ -40,9 +41,9 @@ def update(cls) -> None:
     @classmethod
     def set_start_date(cls, start_date: datetime) -> None:
         """
-        Sets the start date of the graph by updating the filters.
+        Sets the start date of the graph by updating <cls.filters>.
 
-        :param start_time: The new start date of the graph.
+        :param start_date: The new start date of the graph.
         """
 
         cls.filters.start_time = start_date
@@ -50,17 +51,27 @@ def set_start_date(cls, start_date: datetime) -> None:
     @classmethod
     def set_end_date(cls, end_date: datetime) -> None:
         """
-        Sets the end date of the graph by updating the filters.
+        Sets the end date of the graph by updating >cls.filters>.
 
-        :param end_time: The new end date of the graph.
+        :param end_date: The new end date of the graph.
         """
 
         cls.filters.end_time = end_date
 
+    @classmethod
+    def add_shown_tag(cls, tag: str) -> None:
+        """
+        Adds a single tag to the set of shown tags by updating <cls.filters>.
+
+        :param tag: The name of the tag to be added.
+        """
+
+        cls.filters.tags.add(Tag(tag))
+
     @classmethod
     def set_shown_tags(cls, tags: set[str]) -> None:
         """
-        Sets the entire set of shown tags by updating the filters.
+        Sets the entire set of shown tags at once by updating <cls.filters>.
 
         :param tags: The set of tags to be shown.
         """
@@ -72,32 +83,21 @@ def set_shown_tags(cls, tags: set[str]) -> None:
     @classmethod
     def remove_shown_tag(cls, tag: str) -> None:
         """
-        Removes a tag from the set of shown tags by updating the filters.
+        Removes a tag from the set of shown tags by updating <cls.filters>.
 
-        :param tags: The name of the tag to be removed.
+        :param tag: The name of the tag to be removed.
         """
 
         if tag in cls.filters.tags:
             cls.filters.tags.remove(Tag(tag))
 
-    @classmethod
-    def add_shown_tag(cls, tag: str) -> None:
-        """
-        Adds a tag to the set of shown tags by updating the filters.
-
-        :param tags: The name of the tag to be added.
-        """
-
-        cls.filters.tags.add(Tag(tag))
-
     @classmethod
     def export_data_to_file(cls, filename: str) -> None:
         """
-        Exports the current telemetry data to a file.
+        Exports the current telemetry data to a file. The export format is
+        determined based on the file extension in the <filename>.
 
-        :param filename: The path to save to. The export format is
-        determined based on the file extension.
-        :param data: The data to be exported.
+        :param filename: The path to save to.
         """
 
         cls.handler.export_data_to_file(cls.previous_data, filename)
diff --git a/src/astra/usecase/request_receiver.py b/src/astra/usecase/request_receiver.py
index c0d0345..6329a49 100644
--- a/src/astra/usecase/request_receiver.py
+++ b/src/astra/usecase/request_receiver.py
@@ -1,23 +1,17 @@
 from abc import ABC, abstractmethod
-from datetime import datetime
-from queue import Queue
 from threading import Thread
-from typing import Any, Iterable, Mapping
+from typing import Any, Mapping
 from .alarm_checker import check_alarms
-from .dashboard_handler import DashboardHandler, TableReturn, DashboardFilters
 from astra.data.data_manager import DataManager, Device
-from ..data.parameters import Tag
-
-VALID_SORTING_DIRECTIONS = {'>', '<'}
-VALID_SORTING_COLUMNS = {'TAG', 'DESCRIPTION'}
-DATA = 'DATA'
-CONFIG = 'CONFIG'
-DASHBOARD_HEADINGS = ['TAG', 'DESCRIPTION']
 
 
 class RequestReceiver(ABC):
     """
-    RequestReceiver is an abstract class that defines the interface for front end data requests.
+    RequestReceiver is an abstract class that defines the interface for front end data processing
+    requests.
+
+    :param previous_data: Stores the data last returned by the <create> function
+    :type: Any
     """
     previous_data: Any
 
@@ -39,13 +33,22 @@ def update(self):
 class DataRequestReceiver(RequestReceiver):
     """
     Receives new data files and updates our programs database accordingly.
+
+    :param file: A file to read from for requests
+    :type: str
+
+    :param previous_data: stores data manager last returned by this class' <create> function
+    :type: DataManager
     """
 
-    file = None
-    previous_data = None
+    file: str = ""
+    previous_data: DataManager | None = None
 
     @classmethod
     def set_filename(cls, file):
+        """
+        setter method for <cls.file>
+        """
         cls.file = file
 
     @classmethod
@@ -66,17 +69,30 @@ def update(cls) -> None:
         """
 
         if cls.previous_data is not None:
-            earliest_time = cls.previous_data.add_data_from_file(cls.file)
+            dm = cls.previous_data
+            filename = cls.file
+            earliest_time = dm.add_data_from_file(filename)
 
             checking_thread = Thread(target=check_alarms, args=[cls.previous_data, earliest_time])
             checking_thread.start()
 
     @classmethod
     def data_exists(cls) -> bool:
-        return cls.previous_data.get_telemetry_data(None, None, {}).num_telemetry_frames > 0
+        """
+        Determines if the data manager has any stored data in it
+
+        :return: True iff some telemetry data has been input to the DataManager
+        """
+
+        if cls.previous_data is not None:
+            return cls.previous_data.get_telemetry_data(None, None, {}).num_telemetry_frames > 0
+        return False
 
     @classmethod
     def set_data_manager(cls, dm: DataManager) -> None:
+        """
+        setter method for <cls.previous_data>
+        """
         cls.previous_data = dm
 
     @staticmethod
@@ -104,260 +120,3 @@ def remove_device(device_name: str) -> None:
         :param device_name: The device to remove from the data manager
         """
         DataManager.remove_device(device_name)
-
-
-class DashboardRequestReceiver(RequestReceiver):
-    """
-    DashboardRequestReceiver is a class that implements the RequestReceiver interface.
-    It handles requests from the dashboard, such as creating the initial data table,
-    updating the currently represented information, changing the index of the datatable
-    that we are viewing, adding or removing a tag from the set of tags that we are viewing,
-    and updating the sorting filter to be applied.
-    """
-
-    filters = DashboardFilters(None, None, None, None, None)
-    handler = DashboardHandler()
-    search_cache = dict()
-    search_eviction = Queue()
-    _sorting = [-1, 1]
-    previous_data = None
-
-    @classmethod
-    def create(cls, dm: DataManager) -> TableReturn:
-        """
-        Create is a method that creates the initial data table,
-        with all tags shown, no sorting applied and at the first index.
-
-        :param model: The model of currently shown data
-        :param dm: Contains all data stored by the program to date.
-        """
-
-        all_tags = dm.tags
-
-        # Add all tags to the shown tags by default.
-        if cls.filters.tags is None:
-            cls.filters.tags = set(all_tags)
-
-        # Set the index to the first index by default.
-        if cls.filters.index is None:
-            cls.filters.index = 0
-
-        # Create the initial table.
-        cls.previous_data = cls.handler.get_data(dm, cls.filters)
-        return cls.previous_data
-
-    @classmethod
-    def update(cls):
-        """
-        update is a method that updates the currently represented information
-        """
-        if cls.previous_data is not None:
-            cls.handler.update_data(cls.previous_data, cls.filters)
-
-    @classmethod
-    def change_index(cls, index: int) -> bool:
-        """
-        change_index changes the index of the datatable
-        that we are viewing. It returns True if it was successful and False otherwise.
-
-        :param dm: The interface for getting all data known to the program
-        :param index: the index of the datatable that we want to change to.
-        :returns: True if the index was successfully changed and False otherwise.
-        """
-
-        cls.filters.index = index
-
-        # Determine if we can update the view without issues.
-        if cls.filters.tags is None:
-            return False
-        return True
-
-    @classmethod
-    def add_shown_tag(cls, add: str) -> bool:
-        """
-        add_shown_tag is a method that adds a tag to the set of tags
-        that we are viewing. It returns True if it was successful and False otherwise.
-
-        :param add: the tag that we want to add to the set of tags that we are viewing.
-        :param previous_table: the previous table that was in the view.
-        :returns: True if the tag was successfully added and False otherwise.
-        """
-        if cls.filters.tags is None:
-            cls.filters.tags = set()
-
-        # Determine if we can add the tag to the set of tags that we are viewing.
-        tag_index = add.index(':')
-        add_tag = add[:tag_index]
-        if add_tag not in cls.filters.tags:
-            cls.filters.tags.add(add_tag)
-            return True
-        else:
-            # Tag was already in the set of tags that we are viewing.
-            return False
-
-    @classmethod
-    def set_shown_tags(cls, tags: Iterable[str]):
-        """
-        Sets <cls.filters.tags> to the set of tags to be shown
-
-        PRECONDITION: <tag> is an element of <cls.filters.tags>
-
-        :param tags: a set of tags to show
-        """
-        cls.filters.tags = set(tags)
-
-    @classmethod
-    def remove_shown_tag(cls, remove: str) -> bool:
-        """
-        Remove a tag from the set of tags that we are viewing.
-        It returns True if it was successful and False otherwise.
-
-        :param previous_table: The previous table that was in the view.
-        :param remove: The tag that we want to remove from the set of tags that we are viewing.
-        :return: True if the tag was successfully removed and False otherwise.
-        """
-        if cls.filters.tags is None:
-            cls.filters.tags = set()
-
-        # Determine if we can remove the tag from the set of tags that we are viewing.
-        tag_index = remove.index(':')
-        remove_tag = remove[:tag_index]
-        if remove_tag in cls.filters.tags:
-            cls.filters.tags.remove(remove_tag)
-            return True
-        else:
-            return False  # Tag was not in the set of tags that we are viewing.
-
-    @classmethod
-    def toggle_sort(cls, heading: str) -> bool:
-        """
-        Method for toggling sorting on a specific heading
-        The headings include (for now):
-        - TAG
-        - DESCRIPTION
-        This method will ask the model to sort the data
-        according to which heading was toggled
-
-        Args:
-            heading (str): string representing which heading was toggled
-        """
-        sort_value = -1
-        for i in range(len(DASHBOARD_HEADINGS)):
-            check_heading = DASHBOARD_HEADINGS[i]
-            if heading == check_heading:
-                cls._sorting[i] *= -1
-                sort_value = cls._sorting[i]
-            else:
-                cls._sorting[i] = 1
-
-        if sort_value == 1:
-            # ascending
-            cls.update_sort(('>', heading))
-        elif sort_value == -1:
-            # descending
-            cls.update_sort(('<', heading))
-        return sort_value == 1
-
-    @classmethod
-    def update_sort(cls, sort: tuple[str, str]) -> bool:
-        """
-        Updates the sorting filter to be applied.
-        It returns True if the sorting filter was successfully applied and False otherwise.
-
-        :param sort: the first value in the tuple for this key will
-             be either ">", indicating sorting by increasing values,
-             and "<" indicating sorting by decreasing values. The second
-             value will indicate the name of the column to sort by.
-        :returns: True if the sorting filter was successfully updated and False otherwise.
-        """
-
-        # Determine if the sorting filter is valid.
-        if sort[0] not in VALID_SORTING_DIRECTIONS:
-            return False
-        if sort[1] not in VALID_SORTING_COLUMNS:
-            return False
-
-        # both if statements failed, so the filter is valid.
-        cls.filters.sort = sort
-        return True
-
-    @classmethod
-    def set_start_time(cls, start_time: datetime):
-        """
-        Modifies <cls.filters.start_time> to be equal to <start_time>
-
-        :param start_time: the datetime to be set
-        """
-        cls.filters.start_time = start_time
-
-    @classmethod
-    def set_end_time(cls, end_time: datetime):
-        """
-        Modifies <cls.filters.end_time> to be equal to <end_time>
-
-        :param end_time: the datetime to be set
-        """
-        cls.filters.end_time = end_time
-
-    @classmethod
-    def search_tags(cls, search: str, dm: DataManager) -> list[Tag]:
-        """
-        Finds all tags in <cls.filters.tags> where <search> is a substring
-
-        :param search: The substring to search for
-        :param dm: The source of all data known to the program
-        :return: A list of all satisfying tags
-        """
-        all_tags = dm.tags
-        if len(cls.search_cache) == 0:
-            all_params = dm.parameters
-            tag_strs = []
-            for tag in all_tags:
-                param = all_params[tag]
-                tag_strs.append(tag + ": " + param.description)
-            tag_strs.sort()
-            cls.search_cache[''] = tag_strs
-
-        return cls.handler.search_tags(search, cls.search_cache, cls.search_eviction)
-
-    @classmethod
-    def get_num_frames(cls) -> int:
-        """
-        Returns the number of frames from the last call to <cls.create> or <cls.update>
-
-        :return: The number of telemetry frames in consideration
-        """
-        if cls.previous_data is not None:
-            return cls.previous_data.frame_quantity
-        else:
-            return 0
-
-    @classmethod
-    def get_time(cls) -> datetime:
-        """
-        Returns the time of the currently examined frame
-
-        :return: The time of the currently examined frame
-        """
-        return cls.previous_data.timestamp
-
-    @classmethod
-    def load_file(cls, file: str, dm: DataManager) -> None:
-        """
-        Adds a telemetry file to the database
-
-        :param dm: Stores all data known to the program
-        :param file: The file storing data to add
-        """
-
-    @classmethod
-    def get_table_entries(cls) -> list[list] | None:
-        """
-        Returns the table entries from the previous call to <create> or <update>
-
-        :return: the table entries from the previous call to <create> or <update>
-        """
-        if cls.previous_data is None:
-            return None
-        else:
-            return cls.previous_data.table
diff --git a/src/logo.png b/src/logo.png
new file mode 100644
index 0000000..a55c531
Binary files /dev/null and b/src/logo.png differ
diff --git a/tests/usecase/__pycache__/test_use_case_handlers.cpython-311-pytest-7.4.3.pyc b/tests/usecase/__pycache__/test_use_case_handlers.cpython-311-pytest-7.4.3.pyc
deleted file mode 100644
index 0a7ad6b..0000000
Binary files a/tests/usecase/__pycache__/test_use_case_handlers.cpython-311-pytest-7.4.3.pyc and /dev/null differ
diff --git a/tests/usecase/__pycache__/test_use_case_handlers.cpython-312-pytest-7.4.3.pyc b/tests/usecase/__pycache__/test_use_case_handlers.cpython-312-pytest-7.4.3.pyc
deleted file mode 100644
index 3610561..0000000
Binary files a/tests/usecase/__pycache__/test_use_case_handlers.cpython-312-pytest-7.4.3.pyc and /dev/null differ
diff --git a/tests/usecase/__pycache__/test_use_case_handlers.cpython-312.pyc b/tests/usecase/__pycache__/test_use_case_handlers.cpython-312.pyc
deleted file mode 100644
index 705ced5..0000000
Binary files a/tests/usecase/__pycache__/test_use_case_handlers.cpython-312.pyc and /dev/null differ
diff --git a/tests/usecase/astra.db b/tests/usecase/astra.db
deleted file mode 100644
index c853a3e..0000000
Binary files a/tests/usecase/astra.db and /dev/null differ
diff --git a/tests/usecase/test_use_case_handlers.py b/tests/usecase/test_use_case_handlers.py
index d65c96e..b85bea2 100644
--- a/tests/usecase/test_use_case_handlers.py
+++ b/tests/usecase/test_use_case_handlers.py
@@ -233,29 +233,12 @@ def test_search_tags_eviction():
     cache[''] = tags.copy()
     eviction = queue.Queue()
 
-    DashboardHandler.search_tags('abcde', cache, eviction)
-    DashboardHandler.search_tags('a', cache, eviction)
-    DashboardHandler.search_tags('b', cache, eviction)
-    DashboardHandler.search_tags('c', cache, eviction)
-    DashboardHandler.search_tags('d', cache, eviction)
-    DashboardHandler.search_tags('e', cache, eviction)
-    DashboardHandler.search_tags('f', cache, eviction)
-    DashboardHandler.search_tags('g', cache, eviction)
-    DashboardHandler.search_tags('h', cache, eviction)
-    DashboardHandler.search_tags('i', cache, eviction)
-    DashboardHandler.search_tags('j', cache, eviction)
-    DashboardHandler.search_tags('k', cache, eviction)
-    DashboardHandler.search_tags('l', cache, eviction)
-    DashboardHandler.search_tags('m', cache, eviction)
-    DashboardHandler.search_tags('n', cache, eviction)
-    DashboardHandler.search_tags('o', cache, eviction)
-    DashboardHandler.search_tags('p', cache, eviction)
-    DashboardHandler.search_tags('q', cache, eviction)
-    DashboardHandler.search_tags('r', cache, eviction)
-    DashboardHandler.search_tags('s', cache, eviction)
+    for i in range(200):
+        search = 'a' * (i + 1)
+        DashboardHandler.search_tags(search, cache, eviction)
 
     check = DashboardHandler.search_tags('t', cache, eviction)
     assert check == []
-    assert len(cache) == 21
-    # The function already evicted abcde, so 'a' should be the next one
-    assert eviction.get() == 'a'
+    assert len(cache) == 201
+    # The function already evicted 'a', so 'aa' should be the next one
+    assert eviction.get() == 'aa'