Source code for pidibble.baserecord

"""

.. module:: baserecord
   :synopsis: defines the BaseRecord class
   
.. moduleauthor: Cameron F. Abrams, <cfa22@drexel.edu>

"""
from .baseparsers import StringParser
import logging
logger = logging.getLogger(__name__)



def rstr(d, excludes, pad):
    """
    Generate a formatted string representation of a dictionary, excluding specified keys.

    Parameters
    ----------
    d : dict
        The dictionary to format.
    excludes : list
        A list of keys to exclude from the output.
    pad : int
        The padding for the keys in the output string.

    Returns
    -------
    str
        A formatted string representation of the dictionary.
    """
    retstr = ''
    kfstr = r'{:>' + str(pad) + r's}:'
    for k, v in d.items():
        if not k in excludes:
            retstr += kfstr.format(k)
            if isinstance(v, dict):
                retstr += '\n'
                retstr += rstr(v, excludes, pad + 5)
            elif hasattr(v, '__len__') and not isinstance(v, str):
                ch = ['', '']
                if hasattr(v[0], '__dict__'):
                    ch = ['[', ']']
                retstr += ' ' + ', '.join([f'{ch[0]}{str(x)}{ch[1]}' for x in v]) + '\n'
            else:
                retstr += f' {str(v)}' + '\n'
    return retstr




class BaseRecord:
    """
    A class representing a base record with fields and methods for parsing and displaying.
    """
    def __init__(self, input_dict):
        self.__dict__.update(input_dict)



    def empty(self):
        """
        Check if the record is empty, meaning all fields are empty strings.

        Returns
        -------
        bool
            True if all fields are empty strings, False otherwise.
        """
        return all(v == '' for v in self.__dict__.values())


    def __str__(self):
        """
        Generate a string representation of the BaseRecord instance.

        Returns
        -------
        str
            A string representation of the BaseRecord instance, showing its attributes and values.
        """
        return '; '.join([f'{k}: {v}' for k, v in self.__dict__.items()])



    def pstr(self, excludes=['key', 'format', 'continuation'], pad=20):
        """
        Generate a formatted string representation of the BaseRecord instance, excluding specified keys.

        Parameters
        ----------
        excludes : list, optional
            A list of keys to exclude from the output (default is ['key', 'format', 'continuation']).
        pad : int, optional
            The padding for the keys in the output string (default is 20).

        Returns
        -------
        str
            A formatted string representation of the BaseRecord instance, excluding specified keys.
        """
        retstr = f'{self.key}' + '\n'
        retstr += rstr(self.__dict__, excludes, pad)
        return retstr





class BaseRecordParser(StringParser):
    """
    A parser for fixed-width string records that generates BaseRecord instances.  Inherits from :class:`StringParser`.
    """



    def add_fields(self, fields):
        """
        Add fields to the parser's field map.

        Parameters
        ----------
        fields : dict
            A dictionary of fields to add to the parser's field map.
        """
        self.fields.update(fields)




    def parse(self, record):
        """
        Parse a fixed-width string record into a BaseRecord instance.

        Parameters
        ----------
        record : str
            The fixed-width string record to parse.

        Returns
        -------
        BaseRecord
            A BaseRecord instance containing the parsed fields.
        """
        input_dict = super().parse(record)
        return BaseRecord(input_dict)