AdventOfCode/fred.py

import re
import sys

def loadFile(input_f):
    """
    Loads a file and returns its lines as a list.

    Args:
        input_f (str): The file path to read from.

    Returns:
        list: A list of lines from the file, with each line stripped of trailing newlines.

    Raises:
        FileNotFoundError: If the file cannot be found.
        IOError: If there is an error reading the file.
    """
    lines = []
    try:
        with open(input_f) as file:
            for line in file:
                lines.append(line.rstrip())  # Removes trailing newline from each line
    except FileNotFoundError:
        raise FileNotFoundError(f"The file '{input_f}' was not found.")
    except IOError as e:
        raise IOError(f"Error reading file '{input_f}': {e}")
    return lines

def convert_list(input_list):
    """
    Converts a list of strings to integers where possible, leaving others as strings.

    Args:
        input_list (list): A list of strings to be converted.

    Returns:
        list: A list with integers or strings based on the input.

    Raises:
        TypeError: If the input is not a list.
    """
    if not isinstance(input_list, list):
        raise TypeError("Input must be a list.")
    
    converted_list = []
    for item in input_list:
        try:
            converted_list.append(int(item))  # Attempt to convert string to integer
        except ValueError:
            converted_list.append(item)  # Leave as string if conversion fails
    return converted_list

def toGrid(input, parser=None):
    """
    Converts input (file or data) into a grid (list of lists).
    
    Args:
        input (str): The file path or data to be converted into a grid.
        parser (function, optional): A parser function to process each line before adding to the grid. 
                                     Defaults to None.
    
    Returns:
        list: A 2D list (grid) representation of the input.

    Raises:
        FileNotFoundError: If the file cannot be found (if input is a file path).
        ValueError: If the parser function is invalid.
    """
    if parser is not None and not callable(parser):
        raise ValueError("The parser must be a callable function.")
    
    grid = []
    try:
        with open(input) as file:
            for line in file:
                grid.append(list2int(line.rstrip()) if parser else list(line.rstrip()))  # Use parser or default processing
    except FileNotFoundError:
        raise FileNotFoundError(f"The file '{input}' was not found.")
    except IOError as e:
        raise IOError(f"Error reading file '{input}': {e}")
    
    return grid

def swap(a: int, b: int, lst: list):
    """
    Swaps two elements in a list based on their indices.
    
    Args:
        a (int): Index of the first element.
        b (int): Index of the second element.
        lst (list): The list in which to swap elements.

    Returns:
        list: The list with swapped elements.
    
    Raises:
        IndexError: If any index is out of range.
        TypeError: If lst is not a list.
    """
    if not isinstance(lst, list):
        raise TypeError("The provided object is not a list.")
    if a < 0 or b < 0 or a >= len(lst) or b >= len(lst):
        raise IndexError("Index out of range.")  # Ensure indices are valid
    lst[a], lst[b] = lst[b], lst[a]  # Swap the elements
    return lst

def addTuples(x: tuple, y: tuple):
    """
    Adds two tuples element-wise.
    
    Args:
        x (tuple): The first tuple.
        y (tuple): The second tuple.
    
    Returns:
        tuple: A tuple with the sum of corresponding elements of x and y.

    Raises:
        TypeError: If x or y are not tuples.
    """
    if not isinstance(x, tuple) or not isinstance(y, tuple):
        raise TypeError("Both inputs must be tuples.")
    return (x[0] + y[0], x[1] + y[1])

def findDupes(input: list):
    """
    Finds duplicate elements in a list and returns their values.

    Args:
        input (list): The list to check for duplicates.

    Returns:
        list: A list of duplicate values in the input.

    Raises:
        TypeError: If the input is not a list.
    """
    if not isinstance(input, list):
        raise TypeError("Input must be a list.")
    return [item for item in set(input) if input.count(item) > 1]

def lprint(x: str, log: bool):
    """
    Prints a string if logging is enabled.

    Args:
        x (str): The string to print.
        log (bool): A flag to control logging.

    Returns:
        None
    """
    if log:
        print(x)

def expand_grid(grid):
    """
    Expands the grid by adding a border of '.' characters around it.

    Args:
        grid (list): A 2D grid to expand.

    Returns:
        list: A new 2D grid with a border added.

    Raises:
        TypeError: If grid is not a list of lists.
    """
    if not all(isinstance(row, list) for row in grid):
        raise TypeError("Grid must be a list of lists.")
    
    num_rows = len(grid)
    num_cols = len(grid[0])
    expanded_grid = []

    # Add top and bottom borders
    expanded_grid.append(['.'] * (num_cols + 2))

    # Add left and right borders for each row
    for row in grid:
        expanded_grid.append(['.'] + row + ['.'])

    expanded_grid.append(['.'] * (num_cols + 2))  # Bottom border

    return expanded_grid

def getCenter(grid):
    """
    Gets the center position of a grid (middle of the grid).

    Args:
        grid (list): A 2D grid.

    Returns:
        tuple: A tuple containing the row and column index of the center.

    Raises:
        TypeError: If grid is not a list of lists.
    """
    if not all(isinstance(row, list) for row in grid):
        raise TypeError("Grid must be a list of lists.")
    
    return (int(len(grid) / 2), int(len(grid[0]) / 2))

def nprint(grid, cur: set = None, sign: str = None):
    """
    Prints a grid, highlighting the current position if specified.

    Args:
        grid (list): A 2D grid to print.
        cur (set, optional): A set containing the (row, col) indices of the current position.
                             Defaults to None.
        sign (str, optional): The sign to highlight the current position with. Defaults to None.

    Returns:
        None

    Raises:
        TypeError: If cur is not a set or sign is not a string.
    """
    if cur is not None and not isinstance(cur, tuple):
        raise TypeError("Cur must be a tuple with (row, column) indices.")
    if sign is not None and not isinstance(sign, str):
        raise TypeError("Sign must be a string.")
    
    for idx, i in enumerate(grid):
        for jdx, j in enumerate(i):
            if (idx, jdx) == cur:
                if len(sign) > 1:
                    print(sign[0] + grid[idx][jdx] + sign[1], end='')  # Print with sign
                else:
                    print(sign, end=' ')  # Print sign
            else:
                print(grid[idx][jdx], end=' ')  # Regular grid element
        print()

def list2int(x):
    """
    Converts a list of strings to a list of integers.

    Args:
        x (list): A list of strings to convert.

    Returns:
        list: A list of integers.

    Raises:
        TypeError: If x is not a list.
    """
    if not isinstance(x, list):
        raise TypeError("Input must be a list.")
    return list(map(int, x))

def grid_valid(x, y, grid):
    """
    Checks if a grid position is valid (within bounds).

    Args:
        x (int): The row index.
        y (int): The column index.
        grid (list): The 2D grid to check against.

    Returns:
        bool: True if the position is within bounds, False otherwise.

    Raises:
        TypeError: If grid is not a list of lists.
    """
    if not all(isinstance(row, list) for row in grid):
        raise TypeError("Grid must be a list of lists.")
    
    rows = len(grid)
    cols = len(grid[0])
    return 0 <= x < rows and 0 <= y < cols

def get_re(pattern, str):
    """
    Returns a match object if the pattern matches the string, else None.

    Args:
        pattern (str): The regular expression pattern to match.
        str (str): The string to match against.

    Returns:
        match or None: A match object if a match is found, otherwise None.

    Raises:
        TypeError: If str is not a string.
    """
    if not isinstance(str, str):
        raise TypeError("Input string must be of type str.")
    
    match = re.match(pattern, str)
    if match:
        return match
    return None 

def ppprint(x):
    """
    Pretty prints a 2D grid or matrix.

    Args:
        x (list): A 2D grid to print.

    Returns:
        None

    Raises:
        TypeError: If x is not a list of lists.
    """
    if not all(isinstance(row, list) for row in x):
        raise TypeError("Input must be a list of lists.")
    
    for idx, i in enumerate(x):
        for jdx, j in enumerate(i):
            print(x[idx][jdx], end='')
        print()

def get_value_in_direction(grid, position, direction=None, length=1, type: str = None):
    """
    Get the value(s) in a specified direction from a given position in a grid.
    If no direction is provided, returns the value at the current position.

    Args:
        grid (list of list of int/float/str): The 2D grid.
        position (set): A set containing x (row index) and y (column index) as integers.
        direction (str, optional): The direction to check. Defaults to None.
        length (int, optional): The number of steps to check in the given direction. Default is 1.
        type (str, optional): The type of result to return ('list' or 'str'). Defaults to None.

    Returns:
        list or str: A list or string of values in the specified direction, or a single value.

    Raises:
        ValueError: If direction is invalid or position is not a set of two integers.
        TypeError: If grid is not a list of lists.
    """
    if not all(isinstance(row, list) for row in grid):
        raise TypeError("Grid must be a list of lists.")
    
    # Ensure position is a set of two integers
    if len(position) != 2 or not all(isinstance(coord, int) for coord in position):
        raise ValueError("Position must be a set containing two integers (x, y).")

    x, y = position
    offsets = {
        'up': (-1, 0),
        'down': (1, 0),
        'left': (0, -1),
        'right': (0, 1),
        'up-left': (-1, -1),
        'up-right': (-1, 1),
        'down-left': (1, -1),
        'down-right': (1, 1)
    }
    
    # If no direction is given, return the value at the current position
    if direction is None:
        if 0 <= x < len(grid) and 0 <= y < len(grid[x]):
            return grid[x][y]
        else:
            return None

    # Validate direction
    if direction not in offsets:
        raise ValueError(f"Invalid direction: {direction}. Choose from {list(offsets.keys())}")
    
    dx, dy = offsets[direction]
    new_x, new_y = x + dx, y + dy
    
    values = []

    if length == 1:
        # Check for out-of-bounds
        if 0 <= new_x < len(grid) and 0 <= new_y < len(grid[new_x]):
            return grid[new_x][new_y]
        else:
            return None
    else:
        for step in range(length):
            new_x, new_y = x + step * dx, y + step * dy
            # Check for out-of-bounds
            if 0 <= new_x < len(grid) and 0 <= new_y < len(grid[new_x]):
                values.append(grid[new_x][new_y])
            else:
                return []  # Return empty list if any position is out of bounds
    if type == 'list':
        return values
    elif type == 'str':
        return ''.join(values)
    else:
        return values