f90nml

import f90nml

from f90nml import Parser, Namelist

import f90nml

# Read a namelist file
nml = f90nml.read('input.nml')

# Access values like a dictionary
print(nml['config_nml']['steps'])
print(nml['config_nml']['use_biharmonic'])

# Modify values
nml['config_nml']['steps'] = 1000
nml['config_nml']['visc'] = 1.0e-5

# Write back to file
nml.write('output.nml')

# Parse namelist string directly
nml_str = '&data_nml x=1 y=2 /'
nml = f90nml.reads(nml_str)

# Create patch to modify existing file while preserving formatting
patch = {'config_nml': {'steps': 500, 'visc': 2.0e-4}}
f90nml.patch('input.nml', patch, 'patched.nml')

def read(nml_path):
    """
    Parse a Fortran namelist file and return its contents.
    
    Args:
        nml_path: str or file-like object - Path to namelist file or file object
        
    Returns:
        Namelist: Dictionary-like object containing namelist data
    """

def reads(nml_string):
    """
    Parse a Fortran namelist string and return its contents.
    
    Args:
        nml_string: str - String containing Fortran namelist data
        
    Returns:
        Namelist: Dictionary-like object containing namelist data
    """

def write(nml, nml_path, force=False, sort=False):
    """
    Save a namelist to disk using file path or file object.
    
    Args:
        nml: Namelist or dict - Namelist data to write
        nml_path: str or file-like object - Output file path or file object
        force: bool - Overwrite existing files (default: False)
        sort: bool - Sort namelist keys alphabetically (default: False)
    """

def patch(nml_path, nml_patch, out_path=None):
    """
    Create a new namelist based on input namelist and reference dict.
    
    Args:
        nml_path: str - Path to original namelist file
        nml_patch: dict - Dictionary of values to patch
        out_path: str, optional - Output file path (default: adds ~ suffix)
        
    Returns:
        Namelist: Patched namelist object
    """

class Namelist(OrderedDict):
    """Representation of Fortran namelist in Python environment."""
    
    def __init__(self, *args, default_start_index=None, **kwds): ...
    def write(self, nml_path, force=False, sort=False): ...
    def patch(self, nml_patch): ...
    def todict(self, complex_tuple=False): ...
    
    # Formatting properties
    column_width: int
    default_start_index: int
    end_comma: bool
    indent: str
    uppercase: bool
    logical_repr: dict

class Parser:
    """Fortran namelist parser with configurable options."""
    
    def __init__(self): ...
    def read(self, nml_fname, nml_patch_in=None, patch_fname=None): ...
    def reads(self, nml_string): ...
    
    # Configuration properties
    comment_tokens: str
    default_start_index: int
    global_start_index: int
    row_major: bool
    sparse_arrays: bool
    strict_logical: bool

# Type conversion functions
def pyfloat(v_str): ...
def pycomplex(v_str): ...
def pybool(v_str, strict_logical=True): ...
def pystr(v_str): ...

# Multidimensional array indexing
class FIndex:
    def __init__(self, bounds, first=None): ...
    def __next__(self): ...

# Low-level tokenization
class Tokenizer:
    def __init__(self): ...
    def parse(self, line): ...

f90nml input.nml -g group_name -v variable=value
f90nml input.nml -f json > output.json
f90nml input.nml -p patch_file.nml -o output.nml

class Namelist(OrderedDict):
    """Dictionary-like container for namelist groups and variables."""
    
    def __init__(self, *args, default_start_index=None, **kwds): ...
    def write(self, nml_path, force=False, sort=False): ...
    def patch(self, nml_patch): ...
    def todict(self, complex_tuple=False): dict

class Parser:
    """Configurable Fortran namelist parser."""
    
    def __init__(self): ...
    def read(self, nml_fname, nml_patch_in=None, patch_fname=None): Namelist
    def reads(self, nml_string): Namelist

class Cogroup(list):
    """List of Namelist groups which share a common key."""
    
    def __init__(self, nml, key, *args, **kwds): ...
    def update(self, args): ...
    keys: list

class NmlKey(str):
    """String containing internal key for duplicate key handling."""
    
    def __new__(cls, value='', *args, **kwargs): ...

class FIndex:
    """Column-major multidimensional index iterator."""
    
    def __init__(self, bounds, first=None): ...
    def __next__(self): tuple

class Tokenizer:
    """Fortran namelist tokenizer for lexical analysis."""
    
    def __init__(self): ...
    def parse(self, line): list

# Type conversion functions
pyfloat(v_str: str) -> float
pycomplex(v_str: str) -> complex
pybool(v_str: str, strict_logical: bool = True) -> bool
pystr(v_str: str) -> str