Skeleton Classes

[TelloViz]

Skeleton Classes

The first code we wrote were the simple skeleton classes required for the design of our program. We simply included any necessary imports, class signatures, and function signatures. We linted each file to meet the Python coding style.

Example Skeleton Class

"""
Example class module.
Handles requesting data from backend that will be used for initializing the front end.
"""

class Example:  
    def __init__(self):  
        pass # pass not actually necesary  

    def my_func(self):  
        pass  # pass not actually necesary

    def my_other_func(self, parameter):  
        pass  # pass not actually necesary

---

The Classes We Wrote:

backend.py

Written by Christian

from pokemontcgsdk import Card, Set, RestClient

RestClient.configure('12345678-1234-1234-1234-123456789ABCD')

class Backend:
    def construct_query(self, search_parameters: list[tuple[str,str,str]]) -> str:
        """
        Constructs a query string from the given search parameters.
        Args:
            search_parameters (list[tuple[str,str,str]]): A list of tuples representing the search parameters.
              
        Returns:
            str: The constructed query string.
        """

    def query_api(self, query: str) -> list[Card]:
        """
        Queries the Pokemon TCG API using the constructed query string.
        Args: 
            query (str): The query string to spend to the API.
            
        Returns: 
            list[Card]: A list of Card objects returned by the API.
        """
    
    def all_sets(self) -> list[Set]:
        """
        Retrieves all available sets from the Pokemon TCG API.
        
        Returns:
            list[Set]: A list of Set objects retrieved from the API.
        """

---

searchhandler.py

Written by Batu

from backend import Backend

class SearchHandler:
    """
    The SearchHandler class performs the heavy lifting for the searching functionality. This class contains the method handle_search, which calls methods from the Backend class to execute the search requested by the user.

    Methods:
        handle_search(search_parameters): Constructs a query string using the Backend class, construct_query function.
    """

    def handle_search(self, search_parameters: list[tuple[str, str, str]]) -> list[Card]:
        """
        A function that takes a list of tuples representing search parameters, constructs a query string using the Backend class, and retrieves a list of Card objects from the API.

        Args:
            search_parameters (List[Tuple[str, str, str]]): A list of tuples where each tuple contains:
                - category (str): The main category for the search.
                - subcategory (str): The subcategory to refine the search.
                - target (str): The search target (value being searched).

        Returns:
            list[Card]: A list of Card objects as search results.
        """

---

backendcontroller.py

Written by Josh

from PySide6.QtCore import QObject, Slot, Signal

from pokemontcgsdk import Card
from pokemontcgsdk import Set
from pokemontcgsdk import Type
from pokemontcgsdk import Supertype
from pokemontcgsdk import Subtype
from pokemontcgsdk import Rarity


class BackendController(QObject):
    """
    Handles any front end requests for backend interaction.

    Args:
        QObject (_type_): Inheritance of QObject allows for the use of QT Signals and Slots

    ## Note:
    The `@Slot` decorator in this code is used to define a slot function that can be connected to a
    signal in a Qt application. Slots are functions or methods that can be called in response to a
    signal being emitted. By using the `@Slot` decorator, you are explicitly defining which functions
    can be connected to signals in the Qt framework. This helps in maintaining a clear separation
    between signals and slots in the codebase and ensures that the connections are set up correctly.
    """

    setsResults = Signal(str) # Signal that emits JSON string
    searchResults = Signal(str)  # Signal that emits JSON string
    discoverResults = Signal(str)  # Signal that emits JSON string
    loadResults = Signal(str)  # Signal that emits JSON string


    @Slot()
    def request_sets_retrieve(self):
        """
        ## Description:
            Provide an interface for the front end to retrieve all available sets.
        Args:
            params none
        """
    @Slot(list)
    def request_search(self, params: list[tuple[str, str, str]]):
        """
        ## Description:
            Provide an interface for the front end to make search requests with the given search parameters.
        Args:
            params (list[tuple[str, str, str]]): List of search parameter tuples of the form (category, subcategory, target)
        """

    @Slot(list)
    def request_discover(self, params: list[tuple[str, str, str]]):
        """
        ## Description
            Provide an interface for the front end to make discover requests with the given parameters.

        Args:
            params (list[tuple[str, str, str]]): List of search parameter tuples of the form (category, subcategory, target)
        """

    @Slot()
    def request_load_collection(self):
        """
        ## Description
            Provide an interface for the front end to request teh back end to load and return the user's collection.

        Args:
            none: This function does not take any arguments.
        """

    @Slot(list)
    def request_save_collection(self, params: list[tuple[str, str, str]]):
        """
        ## Description
            Provide an interface for the front end to save users collection to system using the given parameters.

        Args:
            params (list[tuple[str, str, str]]): List of tuples of the form (category, subcategory, target) representing the users collection.
        """

inithandler.py

Written by Josh

from pokemontcgsdk import Set
import backend

class InitHandler:
    """
    Handles any front end requests for requesting data for the front end to initalize components.
    """

    def handle_sets_retrieve(self) -> list[Set]:
        """
        ## Description:
            Provide an interface for the front end to retrieve all available sets.
        Args:
            params none
        """