Configuration Management

class Options:
    """
    Main configuration class for PyType analysis settings.
    
    Supports initialization from command line arguments or direct parameter setting.
    Contains all options for controlling PyType's analysis behavior.
    """
    
    def __init__(self, argv_or_options, command_line=False):
        """
        Initialize Options from arguments or existing options.
        
        Parameters:
        - argv_or_options: Command line arguments list or existing Options object
        - command_line (bool): Whether arguments come from command line
        
        Raises:
        PostprocessingError: If configuration validation fails
        """
    
    @classmethod
    def create(cls, input_filename=None, **kwargs):
        """
        Create Options instance with default settings.
        
        Parameters:
        - input_filename (str, optional): Input file for configuration
        - **kwargs: Additional configuration options
        
        Returns:
        Options: New Options object with configured settings
        """

from pytype import config

# Create with defaults
options = config.Options.create()

# Set common options
options.python_version = (3, 11)
options.output = "output.pyi"
options.check = True
options.analyze_annotated = True

# Create from command line args
import sys
options = config.Options(sys.argv[1:], command_line=True)

def make_parser():
    """
    Create argument parser for PyType command line options.
    
    Returns:
    argparse.ArgumentParser: Configured parser with all PyType options
    """

from pytype import config

# Create parser and parse arguments
parser = config.make_parser()
args = parser.parse_args(['--python-version=3.11', '--check', 'file.py'])

# Create options from parsed arguments
options = config.Options(args, command_line=True)

# Python version targeting
options.python_version = (3, 11)      # Target Python version tuple
options.python_exe = "/usr/bin/python3"  # Python executable path

# Import system
options.pythonpath = ["/path/to/modules"]  # Module search paths
options.imports_map = "imports.txt"        # Custom import mappings
options.module = "mymodule"                # Module name for analysis

# Analysis behavior
options.check = True                    # Enable type checking
options.analyze_annotated = True        # Analyze annotated functions
options.quick = False                   # Quick analysis mode
options.strict_import = False           # Strict import checking

# Depth control
options.main_only = False               # Analyze only main module
options.maximum_depth = 3               # Maximum analysis depth

# Output settings
options.output = "output.pyi"           # Output file path
options.output_cfg = "cfg.txt"          # Control flow graph output
options.output_typegraph = "graph.svg"  # Type graph visualization

# Error handling
options.no_report_errors = False        # Suppress error reporting
options.return_success = False          # Always return success

# Optional features
options.protocols = True                # Enable protocol checking  
options.strict_namedtuple_checks = True # Strict namedtuple validation
options.strict_parameter_checks = False # Strict parameter checking
options.overriding_parameter_count_checks = True  # Parameter count validation

# Logging levels
LOG_LEVELS: list  # Available logging levels ['INFO', 'WARNING', 'ERROR']

# Option groups for organization
BASIC_OPTIONS: list      # Essential command-line options
FEATURE_FLAGS: list      # Optional feature toggles  
OUTPUT_OPTIONS: list     # Output control options
IMPORT_OPTIONS: list     # Import system options

# Default values
DEFAULT_PYTHON_VERSION: tuple  # Default Python version
DEFAULT_PROTOCOLS: bool        # Default protocol checking setting

from pytype import config

# Create and configure options
options = config.Options.create()

# Set target environment
options.python_version = (3, 11)
options.pythonpath = ["/my/project/src", "/my/project/lib"]

# Configure analysis behavior
options.check = True
options.analyze_annotated = True
options.strict_import = True
options.protocols = True

# Set output preferences  
options.output = "/output/stubs/"
options.no_report_errors = False

# Enable advanced features
options.strict_namedtuple_checks = True
options.overriding_parameter_count_checks = True

# Use in analysis
from pytype import io
result = io.check_py(source_code, options=options)

class PostprocessingError(Exception):
    """
    Error raised during configuration postprocessing.
    
    Occurs when configuration validation fails or incompatible
    options are specified together.
    """

class UsageError(Exception):
    """
    Error raised for invalid command-line usage.
    
    Occurs when invalid arguments or option combinations are provided.
    """

from pytype import config
import os

# Load project configuration
options = config.Options.create()
options.python_version = (3, 11)
options.pythonpath = [
    os.path.join(project_root, "src"),
    os.path.join(project_root, "lib"),
]

# Set up imports map for complex projects
options.imports_map = os.path.join(project_root, ".pytype", "imports.txt")

# Configure output structure
options.output = os.path.join(project_root, "stubs")

# Quick analysis for CI/CD
options = config.Options.create()
options.quick = True
options.maximum_depth = 1
options.main_only = True

# Thorough analysis for release
options = config.Options.create()  
options.maximum_depth = 5
options.analyze_annotated = True
options.protocols = True
options.strict_import = True