Interface manager seems to be working; need some interface working now

mitter

@@ -53,21 +53,20 @@ def main():
             metavar='INTERFACE',
             help='Interface to be used.')
 
-    # Ask networks to add their options
+    logging.basicConfig(level=logging.DEBUG)
 
+    # Start the network manager (which will add the network options)
     connection = Networks(options)
 
-    # Ask interfaces to add their options
+    # Start the interface manager and make interfaces add their options to the
-
+    # command line
-    interfaces = Interfaces()
+    interfaces = Interfaces(options)
-    interfaces.options(options)
+    interfaces.options()
 
     # Parse the command line options and the config file
-
     options()
 
     # start the logging service
-
     if options['General']['debug']:
         logging.basicConfig(level=logging.DEBUG)
     else:
@@ -87,14 +86,13 @@ def main():
         preferred_interface = options.conflicts['interface']
         log.debug('Command line interface: %s', preferred_interface)
 
-    interface = interfaces(preferred_interface)
+    # load the module with the selected interface (or pick one for the user if
-
+    # they don't chose anything.)
-    if interface is None:
+    display = interface.load(connection, preferred_interface)
+    if display is None:
         log.error('Sorry, no interface could be found for your system')
         return
 
-    display = interface.Interface(connection, options)
-
     # display the interface (the interface should take care of updating
     # itself)
     display()

mitterlib/__init__.py

@@ -57,16 +57,14 @@ def module_search(source, ignore):
     base_dir = os.path.dirname(source)
 
     modules = glob.glob(os.path.join(base_dir, '*.py'))
+    # TODO: What if they only have the installed/compiled modules (*.pyc)?
+    # Shouldn't we add those to the glob list?
     for module in modules:
         module_name = os.path.basename(module)
         if module_name in ignore:
             # not a usable module
             continue
 
-        try:
+        # TODO: Maybe this is a good place to test if the module is
-            module_name = _import_name(module_name)
+        # "importable"
         yield module_name
-        except ImportError, exc:
-            _log.debug('Module %s is not "importable"', module_name)
-            _log.debug(str(exc))
-            pass

mitterlib/network/__init__.py

@@ -18,6 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
+import os.path
 
 from mitterlib.network.networkbase import NetworkData
 from mitterlib import module_search
@@ -91,7 +92,8 @@ class Networks(object):
             return self._networks
 
         for module_name in module_search(__file__, SKIPPABLES):
-            module = __import__(module_name, fromlist=[module_name])
+            import_name = _import_name(module_name)
+            module = __import__(import_name, fromlist=[import_name])
             connection = module.Connection(self._options)
             self._networks[connection.SHORTCUT] = connection
 

mitterlib/ui/__init__.py

@@ -1,8 +1,8 @@
-#!/usr/bin/python
+#!/usr/bin/python2.5
 # -*- coding: utf-8 -*-
 
-# Mitter, a Maemo client for Twitter.
+# Mitter, a simple client for Twitter
-# Copyright (C) 2007, 2008  Julio Biason
+# Copyright (C) 2007, 2008  The Mitter Contributors
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,64 +18,67 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
+import os.path
 
-_log = logging.getLogger('ui.__init__')
+from mitterlib import module_search
 
-interfaces = [
+_log = logging.getLogger('mitterlib.ui.Interfaces')
-        'pygtk',
-        'cmd',
-        'mh',
-        'tty']
 
+# List of files that are not networks
+SKIPPABLES = ('__init__.py')
 
-def _import_name(interface):
+#--------------------------------------------------------------------
-    """Return the name of the module for that interface."""
+# Helper functions
-    return 'mitterlib.ui.ui_%s' % (interface)
+#--------------------------------------------------------------------
 
 
-def _interface_list(prefer=None):
+def _import_name(module):
-    """Return a list of UI modules."""
+    """Based on the name of the module, return the proper "import"
-    if prefer:
+    statement."""
-        if prefer in interfaces:
+    (name, _) = os.path.splitext(module)
-            yield _import_name(prefer)
+    return 'mitterlib.ui.%s' % (name)
 
-    for interface in interfaces:
-        module_name = _import_name(interface)
-        _log.debug('Module %s' % (module_name))
-        yield module_name
 
+class Interfaces(object):
+    """Interface transparency layer: Check which interfaces are available and
+    tries to load the interface requested by the user."""
 
-def interface(prefer):
+    def __init__(self, options):
-    """Try to find an interface that works in the current user system."""
+        self._interfaces = []
-    _log.debug('Preferred interface: %s' % (prefer))
+        self._options = options
-    interface = None
+        self.options()
-    for module_name in _interface_list(prefer):
+        return
-        # try to import each using __import__
-        try:
-            _log.debug('Trying to import %s' % (module_name))
-            interface = __import__(module_name, fromlist=[module_name])
-            break
-        except ImportError, exc:
-            _log.debug('Failed')
-            _log.debug(str(exc))
-            pass
-
-    return interface
-
 
-def interface_options(options):
+    def options(self):
-    """Add options in the command line OptParser object for every
+        """Request all networks to add their options."""
-    interface (yes, every interface, even the ones the user doesn't care)."""
+        for module_name in module_search(__file__, SKIPPABLES):
+            import_name = _import_name(module_name)
 
-    available_interfaces = []
-    for module in _interface_list():
             try:
-            _log.debug('Importing %s for options' % (module))
+                _log.debug('Importing module %s', import_name)
-            interface = __import__(module, fromlist=[module])
+                module = __import__(import_name, fromlist=[import_name])
-
+                interface_name = module.Interface.NAMESPACE
-            interface.options(options)
+                module.Interface.options(self._options)
-            available_interfaces.append(module.split('_')[-1])
+                self._interfaces.append(interface_name)
-        except ImportError:
+            except ImportError, exc:
-            pass    # so we don't care
+                _log.debug('Cannot import module %s', import_name)
+                _log.debug(str(exc))
 
         return
+
+    def load(self, connection, prefer=None):
+        """Start the interface, using the prefered one."""
+        if not self._interfaces:
+            return None
+
+        if prefer and prefer in self._interfaces:
+            import_name = prefer
+        else:
+            # So we pick the one in the top of the list ('cause we know it's
+            # importable and the user didn't chose anything.)
+            # [we could be mean and use random.choice(self._interfaces)]
+            import_name = self._interfaces[0]
+
+        module_name = _import_name(import_name)
+        module = __import__(module_name, fromlist[module_name])
+        return module.Interface(connection, self._options)