INITools
--------

.. contents::

Intro & Status
--------------

INITools is a variety of modules for manipulating ``.ini``-style
files.  This is similar to `ConfigParser
<http://python.org/doc/current/lib/module-ConfigParser.html>`_, only
easier to build on than that library.

I'm not (very) actively developing this library, though I do use it
from time to time.  Anyone interested in doing something with it
should feel free to take it in whatever direction they find
interesting.  You can contact me at ianb@colorstudy.com

Overview
--------

A whirlwind tour of the modules:

``iniparser``:
    The most basic module, this is a simple parser for ``.ini``-style
    files.  You subclass the parser and build your objects as the file
    is parsed.  See ``initools.iniparser.BasicParser`` for a minimal
    example.

``configwrapper``:
    This offers a simple ``Config`` object that takes a single
    filename as an argument, and provides a simple interface to that
    file.  The closest thing here to ``ConfigParser``, I guess.

``lazyiniparser``:
    An ini parser that keeps complete track of the files it draws
    from, including order, filename/line number, and comments.  It can
    be used for systems that support round-tripping (reading and
    writing files).

``inischema``:
    A thought experiment, mostly.  Supports a class-based schema
    definition, and reads files matching them against the definition.
    Not terribly advanced.  It would be more interesting if it used
    `FormEncode <http://formencode.org>`_ for schemas, or maybe
    something based on (or similar to) `optparse
    <http://python.org/doc/current/lib/module-optparse.html>`_.  A
    config-file compliment to ``optparse`` would be generally useful,
    but probably would be based more on ``iniparser`` or
    ``lazyiniparser``.

``nested``:
    A nested dictionary-like object.  Lets you fold several
    dictionaries into a single view, including nested dictionaries.

``lazyloader``:
    The fanciest and most complicated of the modules.  This is where
    it seemed to get out of control (especially combined as it is with
    ``nested``).  This supports loading several files, doing
    conversion with source tracking, parsing the keys and sections to
    create highly nested structures, and folding a configuration back
    onto itself (for context-sensitive configuration).

    This is complex enough that it becomes necessary to debug your
    configuration files, which sucks.

Documentation
-------------

See the `pudge generated documentation <module-index.html>`_.

Future
------

I don't have any particular plans, but if you do that's cool.  The
``optparse`` thing would be cool.

Other Options
-------------

See http://wiki.python.org/moin/ConfigParserShootout

