Configuration System

class ConfigurationParser:
    """
    Responsible for parsing configuration from files and CLI.
    
    Supports two types of configurations:
    - Run configurations: UI-related options (verbosity, debug, etc.)
    - Check configurations: File and error checking options
    """
    
    # Configuration file options
    CONFIG_FILE_OPTIONS = ('convention', 'select', 'ignore', 'add-select',
                          'add-ignore', 'match', 'match-dir')
    
    # Base error selection options (mutually exclusive) 
    BASE_ERROR_SELECTION_OPTIONS = ('ignore', 'select', 'convention')
    
    # Default patterns
    DEFAULT_MATCH_RE = '(?!test_).*\.py'     # Files to check
    DEFAULT_MATCH_DIR_RE = '[^\.].*'         # Directories to search
    DEFAULT_CONVENTION = conventions.pep257   # Default error codes
    
    # Supported config files
    PROJECT_CONFIG_FILES = ('setup.cfg', 'tox.ini', '.pep257')
    
    def __init__(self):
        """Create a configuration parser."""
    
    def parse(self):
        """
        Parse the configuration from CLI and config files.
        
        If one of BASE_ERROR_SELECTION_OPTIONS was selected, overrides all
        error codes and disregards config file error code settings.
        
        Raises:
        IllegalConfiguration: If configuration is invalid
        """
    
    def get_default_run_configuration(self):
        """
        Return a RunConfiguration object set with default values.
        
        Returns:
        RunConfiguration: Default runtime configuration
        """
    
    def get_user_run_configuration(self):
        """
        Return the user's run configuration.
        
        Returns:
        RunConfiguration: User runtime configuration
        """
    
    def get_files_to_check(self):
        """
        Generate files and error codes to check on each one.
        
        Walk directory trees under arguments and yield filenames that match
        under each directory that matches match_dir pattern. Locates 
        configuration for each file and yields (filename, [error_codes]).
        
        Returns:
        generator: tuples of (filename, list of error codes)
        
        Raises:
        IllegalConfiguration: If invalid configuration file found
        """

from pep257 import ConfigurationParser, IllegalConfiguration

# Basic configuration parsing
conf = ConfigurationParser()
try:
    conf.parse()
    run_config = conf.get_user_run_configuration()
    
    # Process files with their specific error codes
    for filename, error_codes in conf.get_files_to_check():
        print(f"Checking {filename} for codes: {error_codes}")
        
except IllegalConfiguration as e:
    print(f"Configuration error: {e}")

RunConfiguration = namedtuple('RunConfiguration',
                            ('explain', 'source', 'debug', 'verbose', 'count'))
"""
Configuration for runtime behavior.

Fields:
- explain: bool, show explanation of each error
- source: bool, show source for each error  
- debug: bool, print debug information
- verbose: bool, print status information
- count: bool, print total number of errors
"""

CheckConfiguration = namedtuple('CheckConfiguration', 
                               ('checked_codes', 'match', 'match_dir'))
"""
Configuration for error checking.

Fields:
- checked_codes: set, error codes to check for
- match: str, regex pattern for filenames to check
- match_dir: str, regex pattern for directories to search
"""

# setup.cfg example
[pep257]
ignore = D203,D213
match = .*\.py
match-dir = [^\.].*
explain = true

# tox.ini example  
[pep257]
select = D100,D101,D102
add-ignore = D105
convention = pep257

# .pep257 example
[pep257]
inherit = false
ignore = D200,D201,D202

class IllegalConfiguration(Exception):
    """An exception for illegal configurations."""
    pass

def check_initialized(method):
    """
    Decorator to check that configuration object was initialized.
    
    Parameters:
    - method: function, method to wrap
    
    Returns:
    function: Wrapped method that checks initialization
    """

class ConfigurationParser:
    """Additional internal methods for configuration processing."""
    
    def _get_config(self, node):
        """
        Get and cache the run configuration for node.
        
        Parameters:
        - node: str, file or directory path
        
        Returns:
        CheckConfiguration: Configuration for the node
        """
    
    def _read_configuration_file(self, path):
        """
        Try to read and parse path as a pep257 configuration file.
        
        Parameters:
        - path: str, configuration file path
        
        Returns:
        tuple: (options, should_inherit)
        
        Raises:
        IllegalConfiguration: If configuration is invalid
        """
    
    def _merge_configuration(self, parent_config, child_options):
        """
        Merge parent config into child options.
        
        Parameters:
        - parent_config: CheckConfiguration, parent configuration
        - child_options: options object, child configuration
        
        Returns:
        CheckConfiguration: Merged configuration
        """
    
    def _validate_options(self, options):
        """
        Validate mutually exclusive options.
        
        Parameters:
        - options: options object to validate
        
        Returns:
        bool: True if options are valid
        """
    
    def _has_exclusive_option(self, options):
        """
        Return True if one or more exclusive options were selected.
        
        Parameters:
        - options: options object to check
        
        Returns:
        bool: True if exclusive options present
        """
    
    def _get_exclusive_error_codes(self, options):
        """
        Extract error codes from selected exclusive option.
        
        Parameters:
        - options: options object
        
        Returns:
        set: Error codes to check
        """
    
    def _set_add_options(self, checked_codes, options):
        """
        Set checked_codes by add_ignore or add_select options.
        
        Parameters:
        - checked_codes: set, error codes to modify in place
        - options: options object with add selections
        """
    
    def _create_run_config(self, options):
        """
        Create a RunConfiguration object from options.
        
        Parameters:
        - options: options object
        
        Returns:
        RunConfiguration: Runtime configuration
        """
    
    def _create_check_config(self, options, use_defaults=True):
        """
        Create a CheckConfiguration object from options.
        
        Parameters:
        - options: options object
        - use_defaults: bool, whether to use default values
        
        Returns:
        CheckConfiguration: Check configuration
        """

class ConfigurationParser:
    """Command-line option parser creation."""
    
    def _create_option_parser(self):
        """
        Return an option parser to parse command line arguments.
        
        Returns:
        OptionParser: Configured option parser
        """

class AttrDict(dict):
    """Dictionary subclass with attribute access."""
    
    def __getattr__(self, item):
        """
        Get dictionary item as attribute.
        
        Parameters:
        - item: str, key name
        
        Returns:
        Any: Dictionary value
        """

conventions = AttrDict({
    'pep257': set  # Set of all error codes except D203
})