keywords.py

import typing

# Validates and extracts keyword arguments passed to calculation methods.
# Ensures each keyword has the correct type before use.
class Keywords():
    
    def __init__(self):

        self.ALLOWED_KEYWORDS = [
            "head", "game_state", "body", "neck", "snake",
            "calls", "move", "new_head", "safe_moves", "memory_moves", "my_length"
        ]

        self.TYPE_MAP = {
            "head":         dict,
            "game_state":   dict,
            "neck":         dict,
            "new_head":     dict,
            "safe_moves":   dict,
            "snake":        dict,
            "body":         list,
            "memory_moves": list,
            "move":         str,
            "calls":        int,
            "my_length":    int,
        }
    
    # Filters kwargs to only include allowed keywords.
    # Silently ignores any kwargs that are not in the allowed list.
    def get_allowed_keywords(self, **kwargs):

        return {key: kwargs[key] for key in self.ALLOWED_KEYWORDS if key in kwargs}
    
    # Validates that each keyword matches its expected type.
    # Raises TypeError if a keyword has the wrong type, RuntimeError if it is unlisted.
    def check_datatype(self, keywords: typing.Dict):

        for key, value in keywords.items():
            if key not in self.TYPE_MAP:
                raise RuntimeError(f"{key} is not a listed keyword")

            if not isinstance(value, self.TYPE_MAP[key]):
                raise TypeError(f"{key} requires type {self.TYPE_MAP[key].__name__}")
    
    # Extracts and validates required keywords from kwargs.
    # Raises KeyError if a required keyword is missing.
    def extract_keywords(self, needed_keywords: typing.List[str], **kwargs):

        keywords = self.get_allowed_keywords(**kwargs)
        self.check_datatype(keywords)

        found_keywords = []
        for keyword in needed_keywords:
            if keyword not in keywords:
                raise KeyError(f"{keyword} is required!")
            found_keywords.append(keywords[keyword])

        return found_keywords