7 files changed, 885 insertions, 0 deletions

diff --git a/lib/dodai/config/__init__.py b/lib/dodai/config/__init__.py
new file mode 100644
index 0000000..e849f8e
--- /dev/null
+++ b/lib/dodai/config/__init__.py
@@ -0,0 +1,76 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+
+class Config(object):
+
+    def __call__(self):
+        obj = ConfigResults()
+        if hasattr(self, 'vars'):
+            for key, val in self.vars.items():
+                setattr(obj, key, val)
+        return obj
+
+    @property
+    def files(self):
+        if not hasattr(self, '_files'):
+            from dodai.config.files import ConfigFiles
+            from dodai.tools.odict import OrderedDict
+            from dodai.tools import Section
+            from dodai.tools.himo import String2Himo
+            from ConfigParser import ConfigParser
+            s2h = String2Himo()
+            self._files = ConfigFiles(OrderedDict, Section, s2h)
+            self._files.register_parser_object(ConfigParser)
+        return self._files
+
+    @property
+    def options(self):
+        if not hasattr(self, '_options'):
+            from dodai.config.option import ConfigOption
+            self._options = ConfigOption()
+        return self._options
+
+    @property
+    def logs(self):
+        if not hasattr(self, '_logs'):
+            from dodai.config.log import ConfigLog
+            self._logs = ConfigLog()
+        return self._logs
+
+    @property
+    def databases(self):
+        if not hasattr(self, '_databases'):
+            # Wire up the sqlalchemy objects to use in the sa object
+            # which will be used as the default database handler
+            from dodai.config.databases import ConfigDatabases
+            from dodai.config.databases.sa import Sa
+            from sqlalchemy.orm import sessionmaker
+            from sqlalchemy import create_engine
+            from dodai.db import Db
+            sa = Sa(create_engine, sessionmaker, Db)
+            self._databases = ConfigDatabases(sa, 'sa')
+        return self._databases
+
+    def set(self, key, val):
+        if not hasattr(self, 'vars'):
+            self.vars = {}
+        self.vars[key] = val
+
+
+class ConfigResults(object):
+    pass
diff --git a/lib/dodai/config/databases/__init__.py b/lib/dodai/config/databases/__init__.py
new file mode 100644
index 0000000..c91e77f
--- /dev/null
+++ b/lib/dodai/config/databases/__init__.py
@@ -0,0 +1,285 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+
+from dodai.exception import DatabaseEmptyOptionException
+from dodai.exception import DatabasePortException
+from dodai.exception import DatabaseHostnameException
+from dodai.exception import DatabaseProtocolException
+from dodai.exception import DatabaseConnectionException
+from dodai.exception import UnknownDatabaseConnectionException
+from dodai.tools import list_to_english
+
+class ConfigDatabases(object):
+    """An object that is used for creating database connection objects
+
+    """
+    def __init__(self, default_handler, default_name):
+        self.connections = {}
+        self._handlers = {}
+        DatabaseConnection.DEFAULT_HANDLER = default_name
+        self.add_handler(default_name, default_handler)
+
+    def add(self, sections):
+        """Adds a dictionary of sections to this object that could
+        be used for creating database connection objects.  The dictionary
+        should be formatted as follows:
+
+            sections[name] = {option: value, option: value, ....}
+
+        The 'name' is the section name.  It is an identifier that is used
+        to load the database:
+
+        The options and values can have the following:
+
+              protocol: The database engine (postgresql, mysql, sqlite,
+                        oracle, mssql etc..)
+
+              hostname: The hostname or ip address of the database server
+
+                  port: The port that should be used to connect to the
+                        database server should be a number between 1
+                        and 65535
+
+              username: The username used to connect to the database server
+
+              password: The password used to connect to the database server
+
+              database: The database to connect to once connected to the
+                        server
+
+                schema: The schema that will be used.  This option does
+                        not do anything but will exist in the db object
+                        for use
+
+              filename: The file path to the database file (sqlite)
+
+        protocol_extra: Used to tell the handler which python db engine
+                        to use.  For example one might want to tell
+                        the sqlalchemy handler to use the psycopg2
+                        python object.
+
+               handler: The handler used to build the orm object. Dodai
+                        only works with sqlalchemy so the default 'sa'
+                        is used.
+
+        """
+        for name, section in sections.items():
+            self.connections[name] = DatabaseConnection(section, name,
+                                                        self._handlers)
+
+    def load(self, section_name):
+        """Returns a database connection object of the given section_name.
+        Throws Exceptions for any type of configuration errors or missing
+        configuration data
+
+        """
+        if section_name in self.connections:
+            return self.connections[section_name].load()
+        else:
+            raise UnknownDatabaseConnectionException(section_name)
+
+    def add_handler(self, name, handler):
+        """Adds the given handler and name to this objects handlers
+
+        """
+        self._handlers[name] = handler
+
+class DatabaseConnection(object):
+
+    DEFAULT_HANDLER = None
+
+    def __init__(self, section, name, handlers):
+        self.section = section
+        self.name = name
+        self.handlers = handlers
+        self.validate = DatabaseConnectionValidator.load(section, name)
+        self.obj = None
+
+    def load(self):
+        if not self.obj:
+            self.validate()
+            handler = self._get_handler()
+            self.obj = handler(self.section, self.name)
+        return self.obj
+
+    def _get_handler(self):
+        if self.section.has_key('handler'):
+            name = self.section['handler']
+            if name in self.handlers:
+                return self.handlers[name]
+        return self.handlers[self.DEFAULT_HANDLER]
+
+
+class DatabaseConnectionValidator(object):
+
+    def __init__(self, section, name, validators=[]):
+        self.section = section
+        self.name = name
+        self.validators = validators
+
+    def __call__(self):
+        return self.validate()
+
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
+
+        """
+        raise NotImplementedError()
+
+    def _validate_option(self, name):
+        try:
+            value = self.section[name]
+        except KeyError:
+            value = None
+
+        if not value:
+            raise DatabaseEmptyOptionException(self.name, name)
+        return True
+
+    def _validate_protocol(self):
+
+        self._validate_option('protocol')
+
+        if self.section['protocol'] not in self.PROTOCOLS:
+            raise DatabaseProtocolException(self.name,
+                        self.section['protocol'], self.DB_TYPE,
+                        self.PROTOCOLS)
+        return True
+
+    @staticmethod
+    def load(section, name):
+        """Static method (factory) that loads the correct database
+        validation class.
+
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
+
+        """
+        action = None
+        validators = [DatabaseConnectionValidatorServer,
+                      DatabaseConnectionValidatorFile]
+
+        for validator in validators:
+            obj = validator.load(section, name)
+            if obj:
+                return obj
+
+        return DatabaseConnectionValidatorUnknown(section, name, validators)
+
+class DatabaseConnectionValidatorServer(DatabaseConnectionValidator):
+
+    DB_TYPE = 'server'
+    REQUIRED = ['protocol', 'hostname', 'port', 'username', 'password',
+                'database']
+    PROTOCOLS = ['postgresql', 'mysql', 'mssql', 'oracle']
+
+    def _validate_port(self):
+        self._validate_option('port')
+
+        try:
+            port = int(self.section['port'])
+        except ValueError:
+            port = self.section['port']
+        else:
+            if port >=1 and port <=65535:
+                return True
+        raise DatabasePortException(self.name, port)
+
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
+
+        """
+        self._validate_protocol()
+        self._validate_port()
+        self._validate_option('hostname')
+        self._validate_option('username')
+        self._validate_option('password')
+        self._validate_option('database')
+        return True
+
+    @classmethod
+    def load(cls, section, name):
+        """Return this validation class if it is possible that the
+        given connection information contains enough data to make
+        a database server connection.
+
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
+
+        """
+        if section.has_key('protocol'):
+            if section['protocol'] in cls.PROTOCOLS:
+                return cls(section, name)
+        keys = section.keys()
+        for key in keys:
+            if key in ['hostname', 'port']:
+                return cls(section, name)
+
+
+class DatabaseConnectionValidatorFile(DatabaseConnectionValidator):
+
+    DB_TYPE = 'file'
+    REQUIRED = ['protocol', 'filename']
+    PROTOCOLS = ['sqlite']
+
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
+
+        """
+        self._validate_protocol()
+        self._validate_option('filename')
+        return True
+
+    @classmethod
+    def load(cls, section, name):
+        """Return this validation class if it is possible that the
+        given connection information contains enough data to make
+        a database file connection.
+
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
+
+        """
+        if section.has_key('protocol'):
+            if section['protocol'] in cls.PROTOCOLS:
+                return cls(section, name)
+        keys = section.keys()
+        for key in keys:
+            if key in ['filename']:
+                return cls(section, name)
+
+
+class DatabaseConnectionValidatorUnknown(DatabaseConnectionValidator):
+
+    DB_TYPE = 'unkonwn'
+    REQUIRED = []
+    PROTOCOLS = []
+
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
+
+        """
+
+        raise DatabaseConnectionException(self.name, self.validators)
diff --git a/lib/dodai/config/databases/sa.py b/lib/dodai/config/databases/sa.py
new file mode 100644
index 0000000..eaf35ea
--- /dev/null
+++ b/lib/dodai/config/databases/sa.py
@@ -0,0 +1,90 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+class Sa(object):
+    """Callable object that will wire up sqlalchemy engine and
+    session objects
+
+    Attributes:
+        create_engine:  The sqlalchemy create_engine object
+        session_maker:  The sqlalchemy session_maker object
+        result_object:  The object that will be populated with
+                        all the connection information along with
+                        the sqlalchemy objects
+
+    """
+    def __init__(self, create_engine, session_maker, result_object):
+        self._create_engine = create_engine
+        self._session_maker = session_maker
+        self._result_object = result_object
+
+    def __call__(self, section, name):
+        db = self._result_object()
+        db.name = name
+        db.protocol = section['protocol']
+
+        if section.has_key('protocol_extra') and section['protocol_extra']:
+            db.protocol_extra = section['protocol_extra']
+
+        if section.has_key('filename') and section['filename']:
+            db.filename = section['filename']
+
+        if section.has_key('port') and section['port']:
+            db.port = int(section['port'])
+
+        if section.has_key('database') and section['database']:
+            db.database = section['database']
+
+        if section.has_key('schema') and section['schema']:
+            db.schema = section['schema']
+
+        if section.has_key('username') and section['username']:
+            db.username = section['username']
+
+        if section.has_key('hostname') and section['hostname']:
+            db.hostname = section['hostname']
+
+        db.engine = self._build_engine(section)
+        db.session = self._build_session(db.engine)
+        return db
+
+    def _build_session(self, engine):
+        session = self._session_maker(bind=engine)
+        return session()
+
+    def _build_connection_string(self, section):
+        out = []
+        out.append('{section[protocol]}')
+        if section.has_key('protocol_extra') and section['protocol_extra']:
+            out.append('+{section[protocol_extra]}')
+        out.append('://')
+        if section.has_key('filename') and section['filename']:
+            out.append('/{section[filename]}')
+        else:
+            out.append('{section[username]}:{section[password]}@')
+            out.append('{section[hostname]}')
+            if section.has_key('port') and section['port']:
+                out.append(':{section[port]}')
+            out.append('/{section[database]}')
+        out = ''.join(out)
+        out = out.format(section=section)
+        return out
+
+    def _build_engine(self, section):
+        connection_string = self._build_connection_string(section)
+        db_obj = self._create_engine(connection_string)
+        return db_obj
diff --git a/lib/dodai/config/files.py b/lib/dodai/config/files.py
new file mode 100644
index 0000000..a27e4a2
--- /dev/null
+++ b/lib/dodai/config/files.py
@@ -0,0 +1,106 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import ConfigParser
+from dodai.config.sections import ConfigSections
+from dodai.exception import InvalidConfigParser
+from dodai.exception import FileDoesNotExist
+from dodai.exception import FileIsDirectory
+
+class ConfigFiles(object):
+
+    REQUIRED_METHODS = ['read', 'sections', 'options', 'get']
+
+    def __init__(self, ordered_dict_object, section_object, string_object):
+
+        self._ordered_dict_object = ordered_dict_object
+        self._section_object = section_object
+        self._string_object = string_object
+        self.parser_objects = []
+        self.files = self._ordered_dict_object()
+        self.files_read = []
+
+    def register_parser_object(self, parser_object):
+        """Registers a config file parser with this object.  Raises
+        InvalidConfigParser error if the parser does not have the 'read',
+        'sections', 'options' and 'get' methods.
+
+        """
+        if self.check_parser_object(parser_object):
+            self.parser_objects.append(parser_object)
+
+    def check_parser_object(self, parser_object):
+        """Checks the given parser object to insure it has all of the required
+        methods needed to parse files.
+
+        """
+        for name in self.REQUIRED_METHODS:
+            if not hasattr(parser_object, name):
+                raise InvalidConfigParser(self.REQUIRED_METHODS,
+                                          parser_object.__name__)
+        return True
+
+    def add(self, filename, encoding=None):
+        """Adds the given filename to this object to be parsed.
+
+        """
+        if os.path.exists(filename):
+            if os.path.isdir(filename):
+                raise FileIsDirectory(filename)
+            else:
+                filename = os.path.realpath(filename)
+                self.files[filename] = encoding
+        else:
+            raise FileDoesNotExist(filename)
+
+    def _read(self):
+        self.files_read = []
+        out = self._ordered_dict_object()
+        for filename, encoding in self.files.items():
+            error = False
+            for parser_obj in self.parser_objects:
+                try:
+                    parser = parser_obj()
+                    parser.read(filename)
+                except Exception, e:
+                    error = True
+                else:
+                    out[filename] = self._ordered_dict_object()
+                    out[filename]['encoding'] = encoding
+                    out[filename]['parser'] = parser
+                    self.files_read.append(filename)
+                    error = False
+                    break
+            if error:
+                raise e
+        return out
+
+
+    def load(self):
+        """Returns a ConfigSections object, which acts like a dictionary,
+        that contains all parsed data.
+
+        """
+        files = self._read()
+        sections = ConfigSections(self._ordered_dict_object,
+                                  self._section_object, self._string_object)
+        for filename, data in files.items():
+            encoding = data['encoding']
+            parser = data['parser']
+            sections(parser, encoding)
+        return sections
diff --git a/lib/dodai/config/log.py b/lib/dodai/config/log.py
new file mode 100644
index 0000000..fdb5c93
--- /dev/null
+++ b/lib/dodai/config/log.py
@@ -0,0 +1,150 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import logging
+import logging.handlers
+import os
+
+class ConfigLog(object):
+
+    LEVELS = {
+        logging.CRITICAL: [
+            'critical',
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(message)s"],
+        logging.ERROR: [
+            'error',
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(message)s"],
+        logging.WARNING: [
+            'warning',
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(message)s"],
+        logging.INFO: [
+            'info',
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(message)s"],
+        logging.DEBUG: [
+            'debug',
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(message)s"]
+    }
+
+    MAX_BYTES = 10485760
+    BACKUP_COUNT = 5
+    FILE_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    STDOUT_FORMAT = "%(message)s"
+
+    def __init__(self):
+        self.log_level = logging.CRITICAL
+        self.directory = None
+        self._levels = {}
+
+    def set_log_level(self, level):
+        try:
+            level = self._fetch_log_level(level)
+        except InvalidLevelException:
+            pass
+        else:
+            self.log_level = level
+
+    def set_directory(self, directory):
+        if os.path.isdir(directory):
+            self.directory = directory
+        else:
+            raise NoDirectoryExistException(directory)
+
+    def get_file_message_format(self, level):
+        if not self._levels:
+            self._levels = self.LEVELS
+        level = self._fetch_log_level(level)
+        return self._levels[level][1]
+
+    def get_screen_message_format(self, level):
+        if not self._levels:
+            self._levels = self.LEVELS
+        level = self._fetch_log_level(level)
+        return self._levels[level][2]
+
+    def _fetch_log_level(self, level):
+        out = None
+        if isinstance(level, str):
+            level = level.strip().lower()
+        if level in self.LEVELS:
+            out = level
+        else:
+            for key, items in self.LEVELS.items():
+                if level == items[0]:
+                    out = key
+        if not out:
+            raise InvalidLevelException(level)
+        else:
+            return out
+
+    def _build_filepath(self, data):
+        data = os.path.normpath(data)
+        if data.startswith(os.path.sep):
+            dir = os.path.dirname(data)
+            if not os.path.isdir(dir):
+                raise NoDirectoryExistException(dir)
+        else:
+            if not self.directory:
+                raise DirectoryNotSetException()
+            else:
+                data = os.path.join(self.directory, data)
+        return data
+
+    def load(self, name):
+        log =logging.getLogger(name)
+        log.setLevel(self.log_level)
+        return log
+
+    def attach_file_handler(self, log, filename):
+        filepath = self._build_filepath(filename)
+        handler = logging.handlers.RotatingFileHandler(
+                filepath, maxBytes = self.MAX_BYTES,
+                backupCount=self.BACKUP_COUNT)
+        file_format = self.get_file_message_format(self.log_level)
+        format_obj = logging.Formatter(file_format)
+        handler.setFormatter(format_obj)
+        handler.setLevel(self.log_level)
+        log.addHandler(handler)
+
+    def attach_screen_handler(self, log, level=None):
+        if level:
+            level = self._fetch_log_level(level)
+        else:
+            level = self.log_level
+        message_format = self.get_screen_message_format(level)
+        handler = logging.StreamHandler()
+        handler.setLevel(level)
+        format_obj = logging.Formatter(message_format)
+        handler.setFormatter(format_obj)
+        log.addHandler(handler)
+
+
+class NoDirectoryExistException(Exception):
+    pass
+
+
+class DirectoryNotSetException(Exception):
+    pass
+
+
+class InvalidLevelException(Exception):
+    pass
diff --git a/lib/dodai/config/option.py b/lib/dodai/config/option.py
new file mode 100644
index 0000000..0561881
--- /dev/null
+++ b/lib/dodai/config/option.py
@@ -0,0 +1,61 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+
+from optparse import OptionParser
+
+class ConfigOption(object):
+
+    def __init__(self):
+
+        self.parser = OptionParser()
+        self._options = None
+        self._args = []
+
+    def get_args(self):
+        self._parse_args()
+        return self._args
+
+    def get_options(self):
+        self._parse_args()
+        return self._options
+
+    def _parse_args(self):
+        options, args = self.parser.parse_args()
+        self._options = options
+        self._args = args
+
+    def add_quiet(self):
+
+        self.parser.add_option("-q", "--quiet", dest="verbose", default=True,
+                action="store_false",
+                help="Don't print status messages to the screen")
+
+    def add_verbose(self):
+        self.parser.add_option("-v", "--verbose", dest="verbose",
+                action="store_true",
+                default=False, help="Print status messages to the screen")
+
+    def add_log_level(self, default='critical'):
+        self.parser.add_option("-l", "--log-level", dest="log_level",
+                default=default, help="Sets the log level")
+
+    def add_setup(self):
+        self.parser.add_option('', "--setup", dest="setup",
+                               action="store_true", default=False,
+                               help="run the setup which builds the config "\
+                                    "files.")
diff --git a/lib/dodai/config/sections.py b/lib/dodai/config/sections.py
new file mode 100644
index 0000000..d789a24
--- /dev/null
+++ b/lib/dodai/config/sections.py
@@ -0,0 +1,117 @@
+# Copyright (C) 2010  Leonard Thomas
+#
+# This file is part of Dodai.
+#
+# Dodai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Dodai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
+
+
+class ConfigSections(object):
+    """
+    An iterable object that contains ConfigSection objects
+
+    """
+
+    def __init__(self, ordered_dict_object, section_object,
+                 string_object = None,):
+        """
+        Iterable object that handles the conversion of a config
+        parser object to a list of section objects.
+
+
+        string_object:  This is an object (non instantiated or
+                        callable) that the results of the config's
+                        sections, and options will be stored in.
+                        This enables you to store your values as a
+                        custom object.  A good object to use is the
+                        dodai.tools.himo Himo object.  If the
+                        string_object is not given the default python
+                        str() object will be used. The callable of
+                        this object must also allow for encoding
+                        to be passed in string_object(data, 'UTF-8')
+
+
+        """
+        self._string_object = string_object or ''
+        self._ordered_dict_object = ordered_dict_object
+        self._section_object = section_object
+        self._sections = self._ordered_dict_object()
+
+    def __call__(self, parser, encoding=None):
+        """
+        Parses the given parser object into this object's sections.
+
+        parser:         The actual parser object that is used to
+                        get the sections.  This object must have
+                        the sections(), options() and get()
+                        methods.  A good object to use is the native
+                        ConfigParse object.  However, you can create
+                        your own
+
+        """
+        self._build_sections(parser, encoding)
+
+    def _build_sections(self, parser, encoding):
+        # Builds ConfigSection objects from the parser object
+
+        for section_name in parser.sections():
+            section = self.get_section(section_name, encoding)
+            self._build_options(parser, section_name, section, encoding)
+
+    def _build_options(self, parser, section_name, section, encoding):
+        # Adds the options to the section object
+
+        for key in parser.options(section_name):
+            value = self._build_string_object(parser.get(section_name, key),
+                                              encoding)
+            key = self._build_string_object(key, encoding)
+            section[key] = value
+
+    def _build_string_object(self, data, encoding=None):
+        if self._string_object:
+            return self._string_object(data, encoding)
+        else:
+            return data
+
+    def get_section(self, section_name, encoding=None):
+        """
+        Returns a Section (aka dict) object from this object's section
+        dictionary or creates a new ConfigSection object, which is
+        stored int this object's section dictionary then is returned
+
+        """
+        section_name = self._build_string_object(section_name, encoding)
+        if section_name in self._sections:
+            return self._sections[section_name]
+        else:
+            section = self._section_object(section_name)
+            self._sections[section_name] = section
+            return section
+
+    def __getitem__(self, key):
+        return self._sections[key]
+
+    def __getattr__(self, key):
+        try:
+            out = self._sections[key]
+        except KeyError:
+            return getattr(self._sections, key)
+        else:
+            return out
+
+    def __iter__(self, *args, **kargs):
+        return self._sections.__iter__(*args, **kargs)
+
+
+    def __len__(self):
+        return len(self._sections)