7 files changed, 806 insertions, 0 deletions

diff --git a/dodai/config/__init__.py b/dodai/config/__init__.py
new file mode 100644
index 0000000..aac9be7
--- /dev/null
+++ b/dodai/config/__init__.py
@@ -0,0 +1,64 @@
+# 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
+
+    def set(self, key, val):
+        if not hasattr(self, 'vars'):
+            self.vars = {}
+        self.vars[key] = val
+
+    def options(self):
+        if not hasattr(self, '_options'):
+            from dodai.config.option import ConfigOption
+            self._options = ConfigOption()
+        return self._options
+
+    def files(self):
+        if not hasattr(self, '_files'):
+            from dodai.config.file import ConfigFile
+            self._files = ConfigFile()
+        return self._files
+
+    def logs(self):
+        if not hasattr(self, '_logs'):
+            from dodai.config.log import ConfigLog
+            self._logs = ConfigLog()
+        return self._logs
+
+    def dbs(self):
+        if not hasattr(self, '_dbs'):
+            from dodai.config.db import ConfigDb
+            self._dbs = ConfigDb()
+        return self._dbs
+
+
+    
+
+
+
+class ConfigResults(object):
+    pass
diff --git a/dodai/config/db/__init__.py b/dodai/config/db/__init__.py
new file mode 100644
index 0000000..fa510ac
--- /dev/null
+++ b/dodai/config/db/__init__.py
@@ -0,0 +1,179 @@
+# 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 ConfigDb(object):
+
+    def __init__(self):
+        self.connections = {}
+        self._handlers = {}
+        from dodai.config.db.sa import Sa
+        self.register_handler('sa', Sa)
+
+    def register_handler(self, name, obj):
+        self._handlers[name] = [obj, None]
+
+    def add_config(self, config_parser=None):
+        if config_parser:
+            if hasattr(config_parser, 'sections') and \
+                    hasattr(config_parser, 'options'):
+                config_obj = ConfigDbFile(config_parser)
+                self._add_connections(config_obj)
+            else:
+                raise NotConfigParserObject()
+
+    def _add_connections(self, config_obj):
+        connections = config_obj()
+        for name, obj in connections.items():
+            self.connections[name] = obj
+
+    def load(self, name):
+        if name in self.connections:
+            connection = self.connections[name]
+            if connection.db_obj:
+                return connection.db_obj
+            else:
+                handler = self._load_handler(connection.handler)
+                db_obj = handler.load(connection)
+                self.connections[name].db_obj = db_obj
+                return db_obj
+
+    def _load_handler(self, name):
+        if name in self._handlers:
+            handler = self._handlers[name]
+            cls = handler[0]
+            obj = handler[1]
+            if not obj:
+                obj = cls()
+                self._handlers[name] = [cls, obj]
+            return obj
+        raise UnknownHandlerException(name)
+
+
+
+class ConfigDbFile(object):
+
+    OPTIONS_REQUIRED = [
+        ['protocol', 'hostname', 'port', 'username', 'password','database'],
+        ['protocol', 'filename']
+    ]
+    OPTIONS_EXTRA = ['protocol_extra', 'handler']
+    DEFAULT_HANDLER = 'sa'
+
+    def __init__(self, config_parser):
+        self.parser = config_parser
+        self._options = self._all_options()
+        self.connections = {}
+
+    def __call__(self):
+        if not self.connections:
+            for section in self.parser.sections():
+                if self._is_valid(section):
+                    obj = self._build_connection(section)
+                    self.connections[obj.name] = obj
+        return self.connections
+
+    def _all_options(self):
+        out = []
+        for option_group in self.OPTIONS_REQUIRED:
+            for option in option_group:
+                if option not in out:
+                    out.append(option)
+        for option in self.OPTIONS_EXTRA:
+            if option not in out:
+                out.append(option)
+        return out
+
+    def _is_valid(self, section):
+        for option_group in self.OPTIONS_REQUIRED:
+            total = len(option_group)
+            count = 0
+            for option in option_group:
+                if option in self.parser.options(section):
+                    value = self.parser.get(section, option)
+                    if value:
+                        count += 1
+            if count >= total:
+                return True
+        return False
+
+    def _build_connection(self, section):
+        obj = ConfigDbConnection()
+        for option in self._options:
+            obj.name = section
+            if self.parser.has_option(section, option):
+                value = self.parser.get(section, option)
+                setattr(obj, option, value)
+            if not hasattr(obj, 'handler') or not obj.handler:
+                obj.handler = self.DEFAULT_HANDLER
+        return obj
+
+
+class BaseConfigDb(object):
+
+    PROTOCOLS = ['postgresql', 'mysql', 'sqlite', 'mssql', 'oracle']
+
+    def _clean(self, obj):
+        obj.protocol = self._clean_protocol(obj.protocol)
+        if hasattr(obj, 'port'):
+            obj.port = self._clean_port(obj.port)
+
+    def _clean_protocol(self, data):
+        data = data.lower()
+        if data in ('postgres', 'postgre'):
+            data = 'postgresql'
+        if data not in self.PROTOCOLS:
+            raise InvalidProtocolException(data)
+        else:
+            return data
+
+    def _clean_port(self, data):
+        try:
+            data = int(data)
+        except ValueError:
+            data = None
+        except TypeError:
+            data = None
+        if data:
+            if data <1 or data > 65535:
+                raise InvalidPortException(data)
+        return data
+
+
+class ConfigDbConnection(object):
+
+    def __init__(self):
+        self.db_obj = None
+
+
+class NotConfigParserObject(Exception):
+    pass
+
+
+class InvalidProtocolException(Exception):
+    pass
+
+
+class InvalidPortException(Exception):
+    pass
+
+
+class UnknownHandlerException(Exception):
+    pass
+
+
+class UnknownConnectionException(Exception):
+    pass
diff --git a/dodai/config/db/sa.py b/dodai/config/db/sa.py
new file mode 100644
index 0000000..06adf9c
--- /dev/null
+++ b/dodai/config/db/sa.py
@@ -0,0 +1,64 @@
+# 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.config.db import BaseConfigDb
+from dodai.db import Db
+
+class Sa(BaseConfigDb):
+
+
+    def load(self, obj):
+        from sqlalchemy.orm import sessionmaker
+        self._clean(obj)
+        db = Db()
+        db.engine = self._build_engine(obj)
+        Session = sessionmaker(bind=db.engine)
+        db.session = Session()
+        db.name = obj.name
+        db.protocol = obj.protocol
+        if hasattr(obj, 'filename') and obj.filename:
+            db.filename = obj.filename
+        else:
+            db.hostname = obj.hostname
+            if hasattr(obj, 'port') and obj.port:
+                db.port = obj.port
+            db.database = obj.database
+        return db
+
+    def _build_connection_string(self, obj):
+        out = []
+        out.append('{db.protocol}')
+        if hasattr(obj, 'protocol_extra') and obj.protocol_extra:
+            out.append('+{db.protocol_extra}')
+        out.append('://')
+        if hasattr(obj, 'filename') and obj.filename:
+            out.append('{db.filename}')
+        else:
+            out.append('{db.username}:{db.password}@')
+            out.append('{db.hostname}')
+            if hasattr(obj, 'port') and obj.port:
+                out.append(':{db.port}')
+            out.append('/{db.database}')
+        out = ''.join(out)
+        out = out.format(db=obj)
+        return out
+
+    def _build_engine(self, obj):
+        from sqlalchemy import create_engine
+        connection_string = self._build_connection_string(obj)
+        db_obj = create_engine(connection_string)
+        return db_obj
diff --git a/dodai/config/file.py b/dodai/config/file.py
new file mode 100644
index 0000000..5cab6f8
--- /dev/null
+++ b/dodai/config/file.py
@@ -0,0 +1,116 @@
+# 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
+
+class ConfigFile(object):
+
+    def __init__(self):
+        self._files = []
+        self._parser = None
+        self.files_loaded = []
+        self._dir = None
+
+    def set_directory(self, path):
+        """ Sets the direcory where files will be looked for
+            raises: InvalidDirectoryException or DirectoryDoesNotExistException
+        """
+        if os.path.isdir(path):
+            self._dir = path
+        else:
+            if os.path.isfile(path):
+                raise InvalidDirectoryException(path)
+            else:
+                raise DirectoryDoesNotExistException(path)
+
+    def get_directory(self):
+        """ Returns the directory where files will be looked for
+        """
+        return self._dir
+
+    def add_file(self, path):
+        """ Adds a full file path with the given path (list or string)
+            raises: FileDoesNotExistException
+        """
+        if isinstance(path, list):
+            for file_ in path:
+                self._add_file(file_)
+        else:
+            if path not in self._files:
+                self._add_file(path)
+
+    def _add_file(self, path):
+        """ Adds the given file path file to the object if the filepath
+            doesn't already exist
+        """
+        if os.path.isfile(path):
+            if path not in self._files:
+                self._files.append(path)
+        else:
+            raise FileDoesNotExistException(path)
+
+    def get_files(self):
+        """ Returns a list of files that were added to this object
+        """
+        return self._files
+
+    def parser(self):
+        """ Returns a ConfigParser.ConfigParser object with files loaded
+            raises: NoFilesToLoadException
+        """
+        self._reset_parser()
+        if not self._parser:
+            if not self._files:
+                raise NoFilesToLoadException()
+            self._parser = ConfigParser.ConfigParser()
+            self.files_loaded = self._parser.read(self._files)
+        return self._parser
+
+    def load(self, name):
+        """ Takes the given name and merges it with the object's directory
+            then adds the path to the object
+        """
+        if not self._dir:
+            raise DirectoryNotSetException()
+        else:
+            path = os.path.join(self._dir, name)
+            self.add_file(path)
+
+    def _reset_parser(self):
+        """ Resets the _parser property if the files_loaded does not equal
+            the files assigned to this object
+        """
+        if self._parser:
+            if self.files_loaded != self._files:
+                self._parser = None
+
+class NoFilesToLoadException(Exception):
+    pass
+
+class DirectoryNotSetException(Exception):
+    pass
+
+class InvalidDirectoryException(Exception):
+    pass
+
+class DirectoryDoesNotExistException(Exception):
+    pass
+
+class FileDoesNotExistException(Exception):
+    pass
diff --git a/dodai/config/log.py b/dodai/config/log.py
new file mode 100644
index 0000000..fdb5c93
--- /dev/null
+++ b/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/dodai/config/option.py b/dodai/config/option.py
new file mode 100644
index 0000000..0561881
--- /dev/null
+++ b/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/dodai/config/sections.py b/dodai/config/sections.py
new file mode 100644
index 0000000..feb59be
--- /dev/null
+++ b/dodai/config/sections.py
@@ -0,0 +1,172 @@
+# 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 unicodedata
+
+class ConfigSections(object):
+    """
+    An iterable object that contains ConfigSection objects
+
+    """
+
+    def __init__(self, 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.
+
+        """
+        self._string_object = string_object or None
+        self._sections = {}
+
+    def __call__(self, parser):
+        """
+        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)
+
+    def _build_sections(self, parser):
+        # Builds ConfigSection objects from the parser object
+
+        for section_name in parser.sections():
+            section = self.get_section(section_name)
+            self._build_options(parser, section_name, section)
+
+    def _build_options(self, parser, section_name, section):
+        # Adds the options to the section object
+
+        for key in parser.options(section_name):
+            key = unicode(self._build_string_object(key))
+            value = self._build_string_object(parser.get(section_name, key))
+            setattr(section, key, value)
+
+    def _build_string_object(self, data):
+        if self._string_object:
+            return self._string_object(data)
+        else:
+            return data
+
+    def get_section(self, section_name):
+        """
+        Returns a ConfigSection 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 = unicode(self._build_string_object(section_name))
+        if section_name in self._sections:
+            return self._sections[section_name]
+        else:
+            section = ConfigSection(section_name)
+            self._sections[section_name] = section
+            return section
+
+    def __getitem__(self, key):
+        key = normalize_key(key)
+        return self._sections[key]
+
+    def __getattr__(self, key):
+        key = normalize_key(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)
+
+class ConfigSection(object):
+    """
+    A generic object to hold keys and values primarily from a config file
+
+    """
+    def __init__(self, title):
+        """
+        Holds keys and values primarily from a section of a config file
+
+        title:      The title of the section of the config file
+
+        """
+        self.___title___ = title
+        self.___options___ = {}
+
+
+    def get_title(self):
+        """
+        Returns the title of the section
+
+        """
+        return self.___title___
+
+
+    def __setattr__(self, key, value):
+        if key.startswith('___') and key.endswith('___'):
+            object.__setattr__(self, key, value)
+        else:
+            key = normalize_key(key)
+            if self.___options___.has_key(key):
+                self.___options___[key] = value
+            else:
+                dict.__setitem__(self.___options___, key, value)
+
+    def __getattr__(self, key):
+        if key.startswith('___') and key.endswith('___'):
+            return self.__dict__[key]
+        else:
+            key = normalize_key(key)
+            try:
+                out = self.___options___[key]
+            except KeyError:
+                return getattr(self.___options___, key)
+            else:
+                return out
+
+    def __getitem__(self, key):
+        key = normalize_key(key)
+        return self.___options___[key]
+
+    def __iter__(self, *args, **kargs):
+        return self.___options___.__iter__(*args, **kargs)
+
+
+def normalize_key(key):
+    key = unicode(key)
+    key = unicodedata.normalize('NFC', key)
+    return key