initial checkin of depchecker

17 files changed, 1449 insertions, 0 deletions

diff --git a/depchecker.wpr b/depchecker.wpr
new file mode 100644
index 0000000..00052c5
--- /dev/null
+++ b/depchecker.wpr
@@ -0,0 +1,530 @@
+#!wing
+#!version=2.0
+##################################################################
+# Wing IDE project file                                          #
+##################################################################
+[project attributes]
+proj.file-list = [loc('cache.txt'),
+                  loc('depchecker.wpr'),
+                  loc('main.py'),
+                  loc('modules/clioptions_module.py'),
+                  loc('modules/ftp_module.py'),
+                  loc('modules/gnome_module.py'),
+                  loc('modules/gnome_output.py'),
+                  loc('modules/package_module.py'),
+                  loc('modules/portage_module.py'),
+                  loc('modules/simple_cache_module.py')]
+proj.file-type = 'normal'
+[user attributes]
+debug.err-values = {loc('main.py'): {'stack[2].globals.pkgcache': (-4,
+        4,
+        None,
+        '-0x487706cc',
+        '__builtin__',
+        8,
+        'dict',
+        1,
+        None,
+        None,
+        (),
+        0),
+                                     'stack[2].globals.vercache': (-4,
+        4,
+        None,
+        '-0x4880c314',
+        '__builtin__',
+        8,
+        'dict',
+        1,
+        None,
+        None,
+        (),
+        0),
+                                     'stack[current=2].globals.pkgcache': (-4,
+        4,
+        None,
+        '-0x487706cc',
+        '__builtin__',
+        8,
+        'dict',
+        1,
+        None,
+        None,
+        (),
+        0),
+                                     'stack[current=2].globals.vercache': (-4,
+        4,
+        None,
+        '-0x4880c314',
+        '__builtin__',
+        8,
+        'dict',
+        1,
+        None,
+        None,
+        (),
+        0)}}
+debug.shell-history = {None: ['test = "blah.tar.bz2"\n',
+                              'print string.replace(test,".tar.bz2","")\n',
+                              'blah = "2.3.4"\n',
+                              'print blah.find(".")\n',
+                              'firstdot = blah.find(".")\n',
+                              'print blah[:firstdot]\n',
+                              'blah[firstdot:].find(".")\n',
+                              'blah[firstdot+1:].find(".")\n',
+                              'blah[firstdot+1:]\n',
+                              'seconddot = blah[firstdot+1:].find(".")\n',
+                              'blah[firstdot:seconddot]\n',
+                              'firstdot\n',
+                              'seconddot\n',
+                              ' print portage.db["/home/allanon/cvs/gnome"]['\
+                              '"porttree"].dbapi.match("at-spi")\n',
+                              ' print str(portage.db["/home/allanon/cvs/gnom'\
+                              'e"]["porttree"].dbapi.match("at-spi"))\n',
+                              ' print str(portage.db["/home/allanon/cvs/gnom'\
+                              'e/"]["porttree"].dbapi.match("at-spi"))\n',
+                              ' print str(portage.db["/"]["porttree"].dbapi.'\
+                              'match("at-spi"))\n',
+                              ' list = portage.db["/home/allanon/cvs/gnome"]'\
+                              '["porttree"].dbapi.match("at-spi")\n',
+                              ' list = portage.db["\\/home\\/allanon\\/cvs\\'\
+                              '/gnome"]["porttree"].dbapi.match("at-spi")\n',
+                              'import string\n',
+                              '"2.14.1".split(".")[2]\n',
+                              '"2.14.1".split(".")[:2]\n',
+                              '"2.14.1".split(".")[:2].join()\n',
+                              '"".join("2.14.1".split(".")[:2])\n',
+                              '".".join("2.14.1".split(".")[:2])\n',
+                              'blah = ["1","2"]\n',
+                              'blah2 = ["3","4"]\n',
+                              'blah.append(blah2)\n',
+                              'blah.extend(blah2)\n',
+                              'blah\n',
+                              'import portage\n',
+                              'portage.best("gnome-2.13.0","gnome-2.14.0")\n',
+                              'portage.best(["gnome-2.13.0","gnome-2.14.0"])'\
+                              '\n',
+                              'portage.best(["gnome-2.14.0","gnome-2.13.0"])'\
+                              '\n']}
+debug.var-col-widths = [0.39139784946236561,
+                        0.60860215053763445]
+edit.file-encoding = {loc('modules/module1.py'): 'UTF-8',
+                      loc('modules/portage.py'): 'UTF-8'}
+guimgr.overall-gui-state = {'windowing-policy': 'combined-window',
+                            'windows': [{'name': 'l0J1ozQwo5PGbLuwJbbCw9THhJ'\
+        'EH8vUJ',
+        'size-state': 'maximized',
+        'type': 'dock',
+        'view': {'area': 'tall',
+                 'current_pages': [0,
+                                   0],
+                 'notebook_display': 'normal',
+                 'notebook_percent': 0.17290836653386454,
+                 'override_title': None,
+                 'pagelist': [('project',
+                               'tall',
+                               0,
+                               {'tree-state': {'tree-states': {'deep': {'col'\
+        'umn-widths': [1.0],
+        'expanded-nodes': [(0,)],
+        'selected-nodes': [(0,
+                            5)],
+        'top-node': (0,)}},
+        'tree-style': 'deep'}}),
+                              ('source-assistant',
+                               'tall',
+                               2,
+                               {'docstring-during-complete': 0,
+                                'wrap-lines': True}),
+                              ('browser',
+                               'tall',
+                               0,
+                               {'all_tree_states': {loc('../version1/gnomedep.py'): {''\
+        'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('generic attribute',
+                      loc('../version1/gnomedep.py'),
+                      'DOWNLOAD_FULL')]},
+        loc('cache.txt'): {'column-widths': [1.0],
+                           'expanded-nodes': [],
+                           'selected-nodes': [],
+                           'top-node': None},
+        loc('main.py'): {'column-widths': [1.0],
+                         'expanded-nodes': [],
+                         'selected-nodes': [],
+                         'top-node': [('generic attribute',
+                                       loc('main.py'),
+                                       'comparison_result_packages')]},
+        loc('modules/clioptions_module.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('class def',
+                      loc('modules/clioptions_module.py'),
+                      'Options')]},
+        loc('modules/ftp_module.py'): {'column-widths': [1.0],
+                                       'expanded-nodes': [],
+                                       'selected-nodes': [],
+                                       'top-node': [('generic attribute',
+        loc('modules/ftp_module.py'),
+        'DEBUG')]},
+        loc('modules/gnome_module.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('generic attribute',
+                      loc('modules/gnome_module.py'),
+                      'DEBUG')]},
+        loc('modules/gnome_output.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('class def',
+                      loc('modules/gnome_output.py'),
+                      'Output')]},
+        loc('modules/module1.py'): {'column-widths': [1.0],
+                                    'expanded-nodes': [],
+                                    'selected-nodes': [None],
+                                    'top-node': None},
+        loc('modules/package_module.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('class def',
+                      loc('modules/package_module.py'),
+                      'Package')]},
+        loc('modules/portage_module.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('function def',
+                      loc('modules/portage_module.py'),
+                      'best_version')]},
+        loc('../../../../../../../usr/lib/portage/pym/portage.py'): {'column'\
+        '-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('function def',
+                      loc('../../../../../../../usr/lib/portage/pym/portage.py'),
+                      'ExtractKernelVersion')]},
+        loc('../../../../../../../usr/lib/python2.4/sre_parse.py'): {'column'\
+        '-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('generic attribute',
+                      loc('../../../../../../../usr/lib/python2.4/sre_parse.py'),
+                      'CATEGORIES')]},
+        loc('unknown:<untitled> #10'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': None},
+        loc('unknown:<untitled> #11'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [None],
+        'top-node': None},
+        loc('unknown:<untitled> #12'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': None},
+        loc('unknown:<untitled> #13'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [None],
+        'top-node': None},
+        loc('modules/simple_cache_module.py'): {'column-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('class def',
+                      loc('modules/simple_cache_module.py'),
+                      'FileStuff')]},
+        loc('../../../../../../../usr/lib/portage/pym/portage_exec.py'): {'c'\
+        'olumn-widths': [1.0],
+        'expanded-nodes': [],
+        'selected-nodes': [],
+        'top-node': [('function def',
+                      loc('../../../../../../../usr/lib/portage/pym/portage_exec.py'),
+                      'cleanup')]}},
+                                'browse_mode': u'Current Module',
+                                'follow-selection': False,
+                                'sort_mode': 'Alphabetically',
+                                'visibility_options': {u'Derived Classes': False,
+        u'Imported': False,
+        u'Modules': True}})],
+                 'primary_view_state': {'area': 'wide',
+        'current_pages': [0,
+                          3],
+        'notebook_display': 'normal',
+        'notebook_percent': 0.33495736906211937,
+        'override_title': None,
+        'pagelist': [('debug-io',
+                      'wide',
+                      1,
+                      {'first-line': 0,
+                       'selection_end': 36,
+                       'selection_start': 36}),
+                     ('debug-probe',
+                      'wide',
+                      2,
+                      {'first-line': 0,
+                       'selection_end': 4,
+                       'selection_start': 4}),
+                     ('debug-exceptions',
+                      'wide',
+                      0,
+                      {}),
+                     ('debug-modules',
+                      'wide',
+                      1,
+                      {}),
+                     ('python-shell',
+                      'wide',
+                      2,
+                      {'first-line': 23,
+                       'selection_end': 971,
+                       'selection_start': 971}),
+                     ('search',
+                      'wide',
+                      0,
+                      {'action': 'search',
+                       'file-set': None,
+                       'mode': 'file',
+                       'options': {'AutoBackground': 1,
+                                   'AutoFind': 1,
+                                   'AutoShowBatch': 0,
+                                   'Fast': 1,
+                                   'Incremental': 1,
+                                   'InterpretBackslash': 0,
+                                   'MatchCase': 0,
+                                   'OmitBinary': 1,
+                                   'Recursive': 1,
+                                   'ReplaceOnDisk': 0,
+                                   'Reverse': 0,
+                                   'WholeWords': 0,
+                                   'Wrapping': 1},
+                       'prefix-file': 'short-file',
+                       'prefix-lineno': 1,
+                       'regex-flags': 46,
+                       'replace-entry-expanded': 0,
+                       'replace-string': '',
+                       'scope': ['current-file-batch'],
+                       'search-entry-expanded': 0,
+                       'search-string': 'bestmatch',
+                       'search-style': 'text',
+                       'starting-directory': '/home/allanon/'}),
+                     ('debug-data',
+                      'wide',
+                      0,
+                      {}),
+                     ('debug-watch',
+                      'wide',
+                      1,
+                      None)],
+        'primary_view_state': {'editor_states': {'bookmarks': ([(loc('modules/gnome_module.py'),
+        {'first-line': 93,
+         'selection_end': 115,
+         'selection_start': 115},
+        1146945054.940794),
+        (loc('modules/gnome_output.py'),
+         {'first-line': 38,
+          'selection_end': 1532,
+          'selection_start': 1532},
+         1146945919.6413469),
+        (loc('modules/clioptions_module.py'),
+         {'first-line': 0,
+          'selection_end': 322,
+          'selection_start': 322},
+         1146945953.5637929),
+        (loc('modules/gnome_output.py'),
+         {'first-line': 38,
+          'selection_end': 1752,
+          'selection_start': 1752},
+         1146945956.435168),
+        (loc('modules/gnome_module.py'),
+         {'first-line': 0,
+          'selection_end': 115,
+          'selection_start': 115},
+         1146945992.8452539),
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946000.204114),
+        [loc('modules/ftp_module.py'),
+         {'first-line': 0,
+          'selection_end': 434,
+          'selection_start': 434},
+         1146946155.70066],
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946159.013289),
+        [loc('modules/clioptions_module.py'),
+         {'first-line': 0,
+          'selection_end': 322,
+          'selection_start': 322},
+         1146946159.850426],
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946161.316349),
+        [loc('modules/simple_cache_module.py'),
+         {'first-line': 38,
+          'selection_end': 1358,
+          'selection_start': 1358},
+         1146946162.5042391],
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946167.5946791),
+        [loc('modules/portage_module.py'),
+         {'first-line': 28,
+          'selection_end': 1192,
+          'selection_start': 1192},
+         1146946168.3850601],
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946175.32775),
+        [loc('../version1/gnomedep.py'),
+         {'first-line': 764,
+          'selection_end': 32487,
+          'selection_start': 32487},
+         1146946176.6257739],
+        (loc('modules/gnome_output.py'),
+         {'first-line': 0,
+          'selection_end': 1404,
+          'selection_start': 1404},
+         1146946185.138418),
+        (loc('main.py'),
+         {'first-line': 7,
+          'selection_end': 373,
+          'selection_start': 373},
+         1146946186.188046),
+        (loc('modules/gnome_output.py'),
+         {'first-line': 66,
+          'selection_end': 3310,
+          'selection_start': 3310},
+         1146946440.8300481),
+        (loc('modules/package_module.py'),
+         {'first-line': 78,
+          'selection_end': 2569,
+          'selection_start': 2569},
+         1146947984.54403),
+        [loc('modules/portage_module.py'),
+         {'first-line': 0,
+          'selection_end': 1100,
+          'selection_start': 1100},
+         1146947986.7937419]],
+        19),
+        'current-loc': loc('modules/portage_module.py'),
+        'editor-states': {loc('main.py'): {'first-line': 7,
+        'selection_end': 373,
+        'selection_start': 373},
+                          loc('modules/gnome_module.py'): {'first-line': 0,
+        'selection_end': 115,
+        'selection_start': 115},
+                          loc('modules/gnome_output.py'): {'first-line': 66,
+        'selection_end': 3310,
+        'selection_start': 3310},
+                          loc('modules/package_module.py'): {'first-line': 78,
+        'selection_end': 2569,
+        'selection_start': 2569},
+                          loc('modules/portage_module.py'): {'first-line': 0,
+        'selection_end': 209,
+        'selection_start': 209}},
+        'has-focus': True},
+                               'open_files': [u'modules/gnome_module.py',
+        u'main.py',
+        u'modules/gnome_output.py',
+        u'modules/package_module.py',
+        u'modules/portage_module.py']},
+        'split_percents': {0: 0.46711153479504292},
+        'splits': 2,
+        'tab_location': 'top',
+        'user_data': {}},
+                 'split_percents': {0: 0.5},
+                 'splits': 2,
+                 'tab_location': 'left',
+                 'user_data': {}},
+        'window-alloc': (221,
+                         61,
+                         762,
+                         545)}]}
+guimgr.recent-documents = [loc('modules/portage_module.py'),
+                           loc('modules/package_module.py'),
+                           loc('modules/gnome_output.py'),
+                           loc('main.py'),
+                           loc('modules/gnome_module.py')]
+guimgr.visual-state = {loc('unknown:<untitled> #9'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('../version1/gnomedep.py'): {'first-line': 0,
+        'selection_end': 32487,
+        'selection_start': 32487},
+                       loc('cache.txt'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('modules/clioptions_module.py'): {'first-line': 0,
+        'selection_end': 322,
+        'selection_start': 322},
+                       loc('modules/ftp_module.py'): {'first-line': 64,
+        'selection_end': 434,
+        'selection_start': 434},
+                       loc('modules/module1.py'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('modules/portage.py'): {'first-line': 0,
+        'selection_end': 21,
+        'selection_start': 21},
+                       loc('modules/portage_module.py'): {'first-line': 0,
+        'selection_end': 1100,
+        'selection_start': 1100},
+                       loc('../../../../../../../usr/lib/portage/pym/portage.py'): {''\
+        'first-line': 3685,
+        'selection_end': 120196,
+        'selection_start': 120196},
+                       loc('../../../../../../../usr/lib/python2.4/sre_parse.py'): {''\
+        'first-line': 110,
+        'selection_end': 3769,
+        'selection_start': 3769},
+                       loc('unknown:<untitled> #14'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('unknown:<untitled> #15'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('unknown:<untitled> #16'): {'first-line': 0,
+        'selection_end': 0,
+        'selection_start': 0},
+                       loc('modules/simple_cache_module.py'): {'first-line': 0,
+        'selection_end': 1358,
+        'selection_start': 1358},
+                       loc('../../../../../../../usr/lib/portage/pym/portage_exec.py'): {''\
+        'first-line': 0,
+        'selection_end': 255,
+        'selection_start': 255},
+                       loc('../../../../../../../usr/lib/python2.4/ftplib.py'): {''\
+        'first-line': 472,
+        'selection_end': 17384,
+        'selection_start': 17384}}
+proj.env-vars = {loc('main.py'): ('project',
+                                  ['']),
+                 loc('modules/ftp_module.py'): ('project',
+        ['']),
+                 loc('modules/portage_module.py'): ('project',
+        [''])}
+search.search-history = ['bestmatch',
+                         'OVERLAY',
+                         'overlay',
+                         'db',
+                         'tar.gz',
+                         'tar',
+                         'path',
+                         'dropslashes',
+                         'ftpfind',
+                         'best',
+                         'cpv_expand',
+                         'dbapi',
+                         'dbapi()',
+                         'd',
+                         'cp_list',
+                         'dbapi=']
diff --git a/main.py b/main.py
new file mode 100755
index 0000000..e76704b
--- /dev/null
+++ b/main.py
@@ -0,0 +1,43 @@
+#! /usr/bin/python
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+import os,sys
+
+exename=os.path.basename(sys.argv[0])
+version = "0.0.2"
+sys.path = ["modules"]+sys.path
+
+if __name__ == '__main__':
+    
+    import clioptions_module
+    options = clioptions_module.Options()
+
+    # generate 2 lists.
+    # 1st list is the packages needed for a release ( from GNOME FTP )
+    # 2nd list is the latest versions of the packages w.r.t. the major/minor of
+    # the release ( from GNOME FTP )
+    import gnome_module
+    gnome = gnome_module.GNOME(options.get_arguments().nextrev)
+    release_packages, latest_packages = gnome.generate_data()
+    
+    # figure out what versions of these packages are in portage.
+    # we need a list of package names to check for, so we choose
+    # to use the release_packages list.
+    import portage_module
+    packages_in_portage = portage_module.find_packages_in_tree(release_packages)
+
+    # compare the versions in order to check if we are up to date.
+    comparison_result_packages = gnome_module.compare_packages(release_packages, \
+                                                    latest_packages, \
+                                                    packages_in_portage)
+    
+    # output these results to a nice html document
+    import gnome_output
+    gnome_output.Output(comparison_result_packages, True).generate_html()
+
+    # if we specified to generate a keywords file, generate it
+    # keep in mind this will do it for the versions in portage, which
+    # may not be the release versions if we are not up to date.
+    if True == options.get_arguments().keywords:
+        gnome_output.Output(packages_in_portage, False).generate_keywords()
diff --git a/modules/clioptions_module.py b/modules/clioptions_module.py
new file mode 100644
index 0000000..867a422
--- /dev/null
+++ b/modules/clioptions_module.py
@@ -0,0 +1,32 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# command line options module.
+from optparse import OptionParser
+
+class Options:
+    
+    def __init__(self):
+        usage = "usage: %prog [options] arg1 arg2"
+        self.parser = OptionParser(usage=usage)
+        self.setup_parser()
+        
+        self.options = self.parser.parse_args()[0]
+    
+    def setup_parser(self):
+        self.parser.add_option("-o", "--output", dest="output",
+                       help="write report to FILE", metavar="FILE")
+        self.parser.add_option("-q", "--quiet",
+                           action="store_false", dest="verbose", default=True,
+                           help="don't print status messages to stdout")
+        self.parser.add_option("-r", "--release", dest="release_number",
+                           help="release version to check for on ftp")
+        self.parser.add_option("-k", "--keywords",
+                           action="store_true", dest="keywords", default=False,
+                           help="Generate a package.keywords file for the versions found in portage.")
+        self.parser.add_option("-n", "--nextrev",
+                           action="store_true", dest="nextrev", default=False,
+                           help="Check for a minor revision newer than the given one")
+    
+    def get_arguments(self):
+        return self.options
diff --git a/modules/clioptions_module.pyc b/modules/clioptions_module.pyc
new file mode 100644
index 0000000..c33fd86
--- /dev/null
+++ b/modules/clioptions_module.pyc
diff --git a/modules/ftp_module.py b/modules/ftp_module.py
new file mode 100644
index 0000000..b712e53
--- /dev/null
+++ b/modules/ftp_module.py
@@ -0,0 +1,93 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+#ftp module
+# large amount of this taken from
+# added in debug statements
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/436211
+
+################
+# my ftp module that should be easier to understand.
+import os,ftplib
+
+DEBUG = False
+class FTPWalker:
+    def __init__(self, site, user, passwd):
+        self.ftp = ftplib.FTP(site,user,passwd)
+        if DEBUG: print "logged into ftp"
+        
+    def cd(self,path):
+        try:
+            self.ftp.cwd(path)
+            #sys.stdout.write(".")
+            if DEBUG: print "successfully changed path to " + path
+            return True
+        except:
+            print "Directory does not exist " + path
+            return False
+            
+    def pwd(self):
+        return self.ftp.pwd()
+        
+    def ls( self, cwd ):
+        lines = []
+        self.ftp.retrlines( "LIST", lines.append )
+        return map( lambda x: self.extract_info( cwd, x ), lines )
+    
+    def str2perm( self,str ):
+        return str[0] == 'd', str[0] == 'l'
+
+    def extract_info( self, cwd, line ):
+        fullmode, links, owner, group, size, rest = line.split( None, 5 )
+        isdir, islink = self.str2perm( fullmode )
+        name = rest[13:]
+        #if 0 < string.find(name,"->"):
+        if islink:
+            name, symbolic = name.split("->")
+            name = name.strip()
+            symbolic = symbolic.strip()
+        if DEBUG: print "Name of the file is: " + name
+        
+        return FileInformation(name, isdir)
+
+class FileInformation:
+    def __init__(self, name, isdirectory):
+        self.name = name
+        self.isdir = isdirectory
+        
+def pattern( p, v ): return fnmatch.fnmatch( v, p )
+
+def dropslashes( str ): 
+    i, n = 0, len( str )
+    while i < n and str[i] == '/': i += 1
+    return str[i:]
+
+def excluded( exclude_patterns, dir ):
+    for exclude_pattern in exclude_patterns:
+        if pattern( exclude_pattern, dir ):
+            return True
+    return False
+
+def listSiteGen( walker, dir, excluded_names):
+    path = walker.pwd()
+    #if not excluded( excluded_names, dir ) and walker.cd( dir ):
+    if walker.cd(dir):
+        newpath = dropslashes( os.path.join( path, dir ) )
+        lsresult = walker.ls( newpath )
+        for info in lsresult:
+            if info.isdir:
+                for rec_info in listSiteGen( walker, info.name, excluded_names):
+                    yield rec_info
+            else:
+                yield info
+    walker.cd( path )
+
+def find_files(walker, dir, excluded_names, excluded_suffixes):
+    file_listing = []
+    
+    for fileinfo in listSiteGen( walker, dir, excluded_names):
+        #if not excluded( excluded_suffixes, fileinfo):
+        if DEBUG: print "Appending: " + str(fileinfo.name)
+        file_listing.append(fileinfo.name)
+    
+    return file_listing
diff --git a/modules/ftp_module.pyc b/modules/ftp_module.pyc
new file mode 100644
index 0000000..0ef35b4
--- /dev/null
+++ b/modules/ftp_module.pyc
diff --git a/modules/gnome_module.py b/modules/gnome_module.py
new file mode 100644
index 0000000..5b5eb5b
--- /dev/null
+++ b/modules/gnome_module.py
@@ -0,0 +1,180 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# gnome module
+import ftp_module, package_module, string, simple_cache_module
+import clioptions_module
+
+DEBUG=False
+class GNOME:
+    def __init__(self, nextrev=False):
+        options = clioptions_module.Options()
+        args = options.get_arguments()
+        
+        self.nextrev = nextrev;
+        self.major_release = ".".join( args.release_number.split(".")[:2] )
+        self.full_release = args.release_number
+        self.ftpserver = "ftp.gnome.org"
+        self.release_directories = ["pub/GNOME/admin/" + self.major_release + "/" + self.full_release + "/",
+                               "pub/GNOME/platform/" + self.major_release + "/" + self.full_release + "/",
+                               "pub/GNOME/desktop/" + self.major_release + "/" + self.full_release + "/",
+                               "pub/GNOME/bindings/" + self.major_release + "/" + self.full_release + "/"]
+        
+    
+    def generate_data(self):
+        # connect to ftp and get the list of all the packages in the release directories    
+        walker = ftp_module.FTPWalker(self.ftpserver,"anonymous","test@test.com")
+        
+        files = []
+        for directory in self.release_directories:
+            f_files = ftp_module.find_files(walker, directory,"","")
+            files.extend(f_files)
+        
+        # filter out bad files
+        files = self.filter_files(files)
+        
+        # create package objects for the files
+        release_packages = [] # the packages that are required for a release
+        for package_name in files:
+            release_package = package_module.Package(package_name)
+            release_packages.append(release_package)
+            
+        # while connected, find out the latest version of the packages that we found in the
+        # release directories
+        latest_packages = [] # the latest versions of packages on the gnome ftp.
+        for package in release_packages:
+            file_list = ftp_module.find_files(walker, "pub/GNOME/sources" + "/" + package.raw_name + "/" + package.major_minor,"","")
+
+            # if maintainers release tarballs late, they will not get picked up
+            # therefore, if the tarball is 1 less than the y of the x.y you
+            # specify, lets also check to see if there are any files for
+            # the actual release number.
+            major = package.major_minor.split(".")[0]
+            minor = package.major_minor.split(".")[1]
+            options = clioptions_module.Options()
+            args = options.get_arguments()
+            release_minor = args.release_number.split(".")[1]
+
+            if int(minor) == (int(release_minor) -1):
+                file_list_future = ftp_module.find_files(walker, "pub/GNOME/sources" + "/" + package.raw_name + "/" + major + "." + str(int(minor)+1),"","")
+
+                # if there are results, replace the old list.
+                if len(file_list_future) > 0:
+                    file_list = file_list_future
+            elif self.nextrev == True:
+                # Try to find minor+1
+                file_list_future = ftp_module.find_files(walker, "pub/GNOME/sources" + "/" + package.raw_name + "/" + major + "." + str(int(minor)+1),"","")
+
+                # if there are results, replace the old list.
+                if len(file_list_future) > 0:
+                    file_list = file_list_future
+
+            # make sure we don't try to do this on directories with no files,
+            # or on directories that don't exist
+            
+            # create package objects for the files
+            if len(file_list) > 0:
+                latest = self.filter_latest_only(file_list)
+                latest_package = package_module.Package(package.name + "-" + latest)
+                latest_packages.append(latest_package)
+                
+        # disconnect from the ftp
+        
+        # cache the results
+        cache = simple_cache_module.SimpleCache()
+        for release_package in release_packages:
+            latest_package = self.findpackage(release_package.name, latest_packages)
+            if latest_package != None:
+                cache.write_to_queue(release_package.name_plus_version_plus_revision, latest_package.name_plus_version_plus_revision)
+            else:
+                print "No matching latest package!" + str(release_package.name)
+        cache.flush_queue()
+        
+        return (release_packages, latest_packages)
+    
+    def filter_files(self, files):
+        # we want to filter out all the bad files.
+        newfiles = []
+        for file in files:
+            # only keep files with .tar.bz2 ending.
+            if ( 0 < file.find(".tar.") and 0 < file.find(".bz2") ):
+                file = string.replace(file,".tar.bz2","")
+                newfiles.append(file)
+        
+        return newfiles
+    
+    # this needs to be fixed so that if a directory doesn't have LATEST-IS-, it returns an error
+    def filter_latest_only(self, lines):
+        latest_string = "LATEST-IS-"
+        latest = ""
+        for item in lines:
+            if 0 <= string.rfind(item,latest_string):
+                latest = item
+        
+        try:
+            return_latest = latest[10:]
+        except:
+            return_latest = ""
+            
+        return return_latest
+    
+    def findpackage(self, name, packages):
+        for package in packages:
+            if package.name == name:
+                return package
+        
+        return None
+
+import portage_module
+def compare_packages(release_packages, latest_packages, packages_in_portage):
+    # we care about 5 cases
+    # 1.  portage version is less than the release version. (RED)
+    # 2.  portage version is equal to the release version, but less than the latest version. (LIGHT GREEN)
+    # 3.  portage version is equal to the release version and the latest version. (GREEN)
+    # 4.  portage version is greater than the release version (GREEN)
+    # 5.  package does not exist in portage (GREY)
+    
+    # again, we choose release_packages as the enumerator for the package names
+    # since it will have ALL packages ( for example, if we used portage_packages, we
+    # might miss the packages that do not exist in portage )
+    status_packages = []
+    for package in release_packages:
+        color = None
+        release_package = package
+        latest_package = GNOME().findpackage(package.name, latest_packages)
+        portage_package = GNOME().findpackage(package.name, packages_in_portage)
+        
+        if portage_package == None:
+            status = package_module.Status.NotFound
+            # we need to create a phony package since findpackage
+            # returns None
+            portage_package = package_module.Package(package.name)
+            
+        elif portage_module.best_version_test(portage_package.name_plus_version, \
+                                     release_package.name_plus_version) == 2:
+            status = package_module.Status.NeedUpdate
+            
+        elif portage_module.best_version_test(portage_package.name_plus_version, \
+                                       latest_package.name_plus_version) == 0:
+            status = package_module.Status.Compliant
+            
+        elif portage_module.best_version_test(portage_package.name_plus_version, \
+                                       release_package.name_plus_version) == 1:
+            status = package_module.Status.Compliant
+            
+        else:
+            status = package_module.Status.NewerVersion
+
+        
+        #if portage_package != None:
+            
+        if DEBUG:
+            print "package: " + str(release_package.name) + \
+                 " | pp: " + str(portage_package.version) + \
+                 " | rp: " + str(release_package.version) + \
+                 " | lp: " + str(latest_package.version) + \
+                 " | status: " + str(status)
+
+        status_packages.append(package_module.PackageStatus(release_package.name, str(portage_package.version), str(release_package.version), str(latest_package.version), status))
+    
+    return status_packages
diff --git a/modules/gnome_module.py.bak b/modules/gnome_module.py.bak
new file mode 100644
index 0000000..994909c
--- /dev/null
+++ b/modules/gnome_module.py.bak
@@ -0,0 +1,172 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# gnome module
+import ftp_module, package_module, string, simple_cache_module
+import clioptions_module
+
+DEBUG=False
+class GNOME:
+	def __init__(self):
+		options = clioptions_module.Options()
+		args = options.get_arguments()
+		
+		self.major_release = ".".join( args.release_number.split(".")[:2] )
+		self.full_release = args.release_number
+		self.ftpserver = "ftp.gnome.org"
+		self.release_directories = ["pub/GNOME/admin/" + self.major_release + "/" + self.full_release + "/",
+							   "pub/GNOME/platform/" + self.major_release + "/" + self.full_release + "/",
+							   "pub/GNOME/desktop/" + self.major_release + "/" + self.full_release + "/",
+							   "pub/GNOME/bindings/" + self.major_release + "/" + self.full_release + "/"]
+		
+	
+	def generate_data(self):
+		# connect to ftp and get the list of all the packages in the release directories	
+		walker = ftp_module.FTPWalker(self.ftpserver,"anonymous","test@test.com")
+		
+		files = []
+		for directory in self.release_directories:
+			f_files = ftp_module.find_files(walker, directory,"","")
+			files.extend(f_files)
+		
+		# filter out bad files
+		files = self.filter_files(files)
+		
+		# create package objects for the files
+		release_packages = [] # the packages that are required for a release
+		for package_name in files:
+			release_package = package_module.Package(package_name)
+			release_packages.append(release_package)
+			
+		# while connected, find out the latest version of the packages that we found in the
+		# release directories
+		latest_packages = [] # the latest versions of packages on the gnome ftp.
+		for package in release_packages:
+			file_list = ftp_module.find_files(walker, "pub/GNOME/sources" + "/" + package.raw_name + "/" + package.major_minor,"","")
+
+            # if maintainers release tarballs late, they will not get picked up
+            # therefore, if the tarball is 1 less than the y of the x.y you
+            # specify, lets also check to see if there are any files for
+            # the actual release number.
+            major = package.major_minor.split(".")[0]
+            minor = package.major_minor.split(".")[1]
+            options = clioptions_module.Options()
+            args = options.get_arguments()
+            release_minor = args.release_number.split(".")[1]
+
+            if minor == (int(release_minor) -1):
+                file_list_future = ftp_module.find_files(walker, "pub/GNOME/sources" + "/" + package.raw_name + "/" + major + "." + str(int(minor+1)),"","")
+
+                # if there are results, replace the old list.
+                if file_list_future.count > 0:
+                    file_list = file_list_future
+
+			# make sure we don't try to do this on directories with no files,
+			# or on directories that don't exist
+			
+			# create package objects for the files
+			if file_list.count > 0:
+				latest = self.filter_latest_only(file_list)
+				latest_package = package_module.Package(package.name + "-" + latest)
+				latest_packages.append(latest_package)
+				
+		# disconnect from the ftp
+		
+		# cache the results
+		cache = simple_cache_module.SimpleCache()
+		for release_package in release_packages:
+			latest_package = self.findpackage(release_package.name, latest_packages)
+			if latest_package != None:
+				cache.write_to_queue(release_package.name_plus_version_plus_revision, latest_package.name_plus_version_plus_revision)
+			else:
+				print "No matching latest package!" + str(release_package.name)
+		cache.flush_queue()
+		
+		return (release_packages, latest_packages)
+	
+	def filter_files(self, files):
+		# we want to filter out all the bad files.
+		newfiles = []
+		for file in files:
+			# only keep files with .tar.bz2 ending.
+			if ( 0 < file.find(".tar.") and 0 < file.find(".bz2") ):
+				file = string.replace(file,".tar.bz2","")
+				newfiles.append(file)
+		
+		return newfiles
+	
+	# this needs to be fixed so that if a directory doesn't have LATEST-IS-, it returns an error
+	def filter_latest_only(self, lines):
+		latest_string = "LATEST-IS-"
+		latest = ""
+		for item in lines:
+			if 0 <= string.rfind(item,latest_string):
+				latest = item
+		
+		try:
+			return_latest = latest[10:]
+		except:
+			return_latest = ""
+			
+		return return_latest
+	
+	def findpackage(self, name, packages):
+		for package in packages:
+			if package.name == name:
+				return package
+		
+		return None
+
+import portage_module
+def compare_packages(release_packages, latest_packages, packages_in_portage):
+	# we care about 5 cases
+	# 1.  portage version is less than the release version. (RED)
+	# 2.  portage version is equal to the release version, but less than the latest version. (LIGHT GREEN)
+	# 3.  portage version is equal to the release version and the latest version. (GREEN)
+	# 4.  portage version is greater than the release version (GREEN)
+	# 5.  package does not exist in portage (GREY)
+	
+	# again, we choose release_packages as the enumerator for the package names
+	# since it will have ALL packages ( for example, if we used portage_packages, we
+	# might miss the packages that do not exist in portage )
+	status_packages = []
+	for package in release_packages:
+		color = None
+		release_package = package
+		latest_package = GNOME().findpackage(package.name, latest_packages)
+		portage_package = GNOME().findpackage(package.name, packages_in_portage)
+		
+		if portage_package == None:
+			status = package_module.Status.NotFound
+			# we need to create a phony package since findpackage
+			# returns None
+			portage_package = package_module.Package(package.name)
+			
+		elif portage_module.best_version_test(portage_package.name_plus_version, \
+									 release_package.name_plus_version) == 2:
+			status = package_module.Status.NeedUpdate
+			
+		elif portage_module.best_version_test(portage_package.name_plus_version, \
+									   latest_package.name_plus_version) == 0:
+			status = package_module.Status.Compliant
+			
+		elif portage_module.best_version_test(portage_package.name_plus_version, \
+									   release_package.name_plus_version) == 1:
+			status = package_module.Status.Compliant
+			
+		else:
+			status = package_module.Status.NewerVersion
+
+		
+		#if portage_package != None:
+			
+		if DEBUG:
+			print "package: " + str(release_package.name) + \
+				 " | pp: " + str(portage_package.version) + \
+				 " | rp: " + str(release_package.version) + \
+				 " | lp: " + str(latest_package.version) + \
+				 " | status: " + str(status)
+
+		status_packages.append(package_module.PackageStatus(release_package.name, str(portage_package.version), str(release_package.version), str(latest_package.version), status))
+	
+	return status_packages
diff --git a/modules/gnome_module.pyc b/modules/gnome_module.pyc
new file mode 100644
index 0000000..3025384
--- /dev/null
+++ b/modules/gnome_module.pyc
diff --git a/modules/gnome_output.py b/modules/gnome_output.py
new file mode 100644
index 0000000..8689183
--- /dev/null
+++ b/modules/gnome_output.py
@@ -0,0 +1,125 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+import package_module,time,clioptions_module,gnome_module
+
+class Output:
+
+    def __init__(self, packages, to_calculate):
+        self.packages = packages
+
+        if to_calculate:
+            self.calculate_stats()
+    
+    def calculate_stats(self):
+        # variables to hold for stats
+        total_packs = len(self.packages)        
+        self.update_needed = float(0)
+        self.compliant = float(0)
+        self.not_found = float(0)
+        self.newer = float(0)
+        
+        for package in self.packages:
+            if package.status == package_module.Status.Compliant:
+                self.compliant +=1
+            elif package.status == package_module.Status.NewerVersion:
+                self.newer +=1
+            elif package.status == package_module.Status.NotFound:
+                self.not_found +=1
+            elif package.status == package_module.Status.NeedUpdate:
+                self.update_needed +=1
+        
+        try:
+            self.update_percent = float(self.update_needed / total_packs) * 100
+        except ZeroDivisionError:
+            self.update_percent = 0
+        try:
+            self.compliant_percent = float(self.compliant / total_packs) * 100
+        except ZeroDivisionError:
+            self.compliant_percent = 0
+        try:
+            self.notfound_percent = float(self.not_found / total_packs) * 100
+        except ZeroDivisionError:
+            self.notfound_percent = 0
+        try:
+            self.total_percent = float( (self.update_needed + self.not_found ) / total_packs ) * 100
+        except ZeroDivisionError:
+            self.total_percent = 0
+        
+    def generate_html(self):
+        
+        # now we have all the results in the results list.
+        # just time to generate some kind of "useful" output.
+        # for now, lets just make a crappy html file. ( this should use css and the like )
+        # name, portage_version, gnome_version, status <-- is whats in the PackageUpdate object
+        current_time = str(time.asctime(time.localtime()))
+        
+        lines = []
+        
+        # header
+        lines.append("<html>")
+        lines.append("<h2>Gnome " + clioptions_module.Options().get_arguments().release_number + " Progress</h2>")
+        lines.append("contact AllanonJL if anything is not correct<br>")
+        lines.append("Generated date: " + current_time + "<br>")
+        lines.append("Directories checked ( recursively ): <br>")
+        for dir in gnome_module.GNOME().release_directories:
+            directory = "ftp://ftp.gnome.org/" + dir
+            lines.append("<a href=" + "\"" + directory + "\"" + ">" + directory + "</a>" + "<br>")
+        
+        # stats
+        lines.append("<br>")
+        lines.append("Compliant Packs: " + str('%0.2f' % self.compliant_percent)+ "%" + "  Number = " + str(self.compliant) + "<br>")
+        lines.append("Packs that need to be updated: " + str('%0.2f' % self.update_percent)+ "%" + "  Number = " + str(self.update_needed) + "<br>")
+        lines.append("New Packs that need to be added: " + str('%0.2f' % self.notfound_percent)+ "%" + "  Number = " + str(self.not_found) + "<br>")
+        
+        lines.append("<table cellpadding=\"10\">")
+        lines.append("<th>Package Name</th><th>Portage Version</th><th>Official Release Version</th><th>Latest Available Version</th>")
+        
+        # data
+        for package in self.packages:
+            if package.status == package_module.Status.NeedUpdate:
+                lines.append("<tr bgcolor=\"red\">")
+            elif package.status == package_module.Status.Compliant:
+                lines.append("<tr bgcolor=\"green\">")
+            elif package.status == package_module.Status.NotFound:
+                lines.append("<tr bgcolor=\"grey\">")    
+            elif package.status == package_module.Status.NewerVersion:
+                lines.append("<tr bgcolor=\"33CC00\">")
+            
+            lines.append("<td>" + str(package.name) + "</td>")
+            lines.append("<td>" + str(package.portage_version) + "</td>")
+            lines.append("<td>" + str(package.gnome_version) + "</td>")
+            lines.append("<td>" + str(package.latest_version) + "</td>")
+                
+            lines.append("</tr>")
+        
+        lines.append("</table>")
+        
+        # footer
+        lines.append("<br>")
+        lines.append("</html>")
+        
+        self.write_file(lines, clioptions_module.Options().get_arguments().output)
+        
+        print "Generated html output."
+
+    def generate_keywords(self):
+        lines = []
+        for package in self.packages:
+            package_string = package.category + "/" + package.name + "-" + package.version
+            # only append revision if its not -r0
+            if "r0" != package.revision:
+                package_string += "-" + package.revision
+
+            lines.append("=" + package_string)
+
+        self.write_file(lines, "package.keywords")
+
+        print "Generate package.keywords output."
+
+    def write_file(self, lines, filename):
+        file = open(filename, "w")
+        file.writelines(x +'\n' for x in lines)
+        file.flush()
+        file.close()
+        del file
diff --git a/modules/gnome_output.pyc b/modules/gnome_output.pyc
new file mode 100644
index 0000000..87d38cc
--- /dev/null
+++ b/modules/gnome_output.pyc
diff --git a/modules/package_module.py b/modules/package_module.py
new file mode 100644
index 0000000..d0fbbd0
--- /dev/null
+++ b/modules/package_module.py
@@ -0,0 +1,102 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# the package module
+import sys
+sys.path = ["modules"]+sys.path
+import portage_module
+
+class Package:
+    # special cases
+    special_cases = {    "GConf":"gconf",
+                "ORBit2":"orbit", 
+                "libidl":"libIDL",
+                "libxml++":"libxmlpp",
+                "gnome2-vfs":"gnome-vfs",
+                "gtk2":"gtk2-perl",
+                "gnome2-vfs":"gnome2-vfs-perl",
+                "pkg-config":"pkgconfig",
+                "gnome-user-docs":"gnome2-user-docs"
+                }
+
+    def __init__(self, raw_data):
+        self.raw_string = raw_data
+        
+        self.name = None
+        self.version = None
+        self.revision = None
+        self.name_plus_version = None
+        self.name_plus_version_plus_revision = None
+        self.major_minor = None
+        self.raw_name = None
+        
+        self.category = None
+        
+        self.parse_raw_string(raw_data)
+        
+        self.handle_special_cases()
+        
+    def handle_special_cases(self):
+        if self.name in self.special_cases:
+            self.name = self.special_cases[self.name]
+
+    def parse_raw_string(self, raw_string):
+        split_string = portage_module.split_package_into_parts(raw_string)
+        if None != split_string:
+            #[cat, pkgname, version, rev ]
+            self.category,self.name,self.version,self.revision = split_string
+            self.raw_name = self.name
+            self.name_plus_version = self.name + "-" + self.version
+            self.name_plus_version_plus_revision = self.name + "-" + self.version + "-" + \
+                self.revision
+            self.major_minor = self.parse_mm(self.version)
+        else:
+            print "Error, " + raw_string + " is not a valid package!"
+    
+    def parse_mm(self, version):
+        majorminor = ""
+        
+        firstdot = version.find(".")
+        if 0 < firstdot:
+            major = version[:firstdot]
+            majorminor += major
+        
+        version = version[firstdot+1:]
+        seconddot = version.find(".")
+        if 0 < seconddot:
+            minor = version[:seconddot]
+            majorminor = majorminor + "." + minor
+        elif 0 > seconddot:
+            # This means there is no second dot, something like, gtk-doc-1.4
+            majorminor = majorminor + "." + version
+        
+        return majorminor
+    
+    def print_info(self):
+        print "Name: " + str(self.name)
+        print "Version: " + str(self.package_version)
+        print "Name+Version: " + str(self.name_plus_version)
+        print "Raw: " + str(self.raw_string)
+        
+class PackageStatus:
+    def __init__(self, name, portage_version, gnome_version, latest_version, status):
+        self.name = name
+        self.portage_version = portage_version
+        self.gnome_version = gnome_version
+        self.latest_version = latest_version
+        self.status = status
+        
+class Status:
+    def Compliant(self):
+        return 0
+    def NeedUpdate(self):
+        return 1
+    def NotFound(self):
+        return -1
+    def NewerVersion(self):
+        return 2
+    
+    property(Compliant)
+    property(NeedUpdate)
+    property(NotFound)
+    property(NewerVersion)
diff --git a/modules/package_module.pyc b/modules/package_module.pyc
new file mode 100644
index 0000000..c70ddd0
--- /dev/null
+++ b/modules/package_module.pyc
diff --git a/modules/portage_module.py b/modules/portage_module.py
new file mode 100644
index 0000000..40f134b
--- /dev/null
+++ b/modules/portage_module.py
@@ -0,0 +1,87 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# the portage module.
+import os, sys, shutil
+import string,signal,re,pickle,tempfile
+import package_module
+sys.path = ["/usr/lib/portage/pym"]+sys.path
+os.environ["PORTAGE_CALLER"]="depchecker"
+
+import portage
+import portage_util
+import clioptions_module
+
+def get_dbtree():
+    return "porttree"
+
+# given a package name in the form category/packagename-version-revision
+# split it up into the different parts.
+def split_package_into_parts(package_name):
+    return portage.catpkgsplit(package_name)
+
+# given a package name, find the category in portage.
+# This will return None if you do not give it a version.
+def find_category(package_name):
+    package = portage.cpv_expand(package_name, mydb=portage.db["/"][get_dbtree()].dbapi, use_cache=1)
+    
+    # catsplit returns ['category', 'packagename']
+    package = portage.catsplit(package)
+    return package[0]
+
+# given category/packagename-version-revision, find whether it is masked or not
+def isMasked():
+    pass
+
+# compare packages to see which one is the best version
+def best_version(package_list):
+    return portage.best(package_list)
+
+# which package is the higher version?
+# returns 0 for equal
+# 1 for package1
+# 2 for package2
+def best_version_test(package1,package2):
+    best_package = portage.best([package1,package2])
+    
+    if best_package == package1 and best_package == package2:
+        return 0
+    elif best_package == package1:
+        return 1
+    else:
+        return 2
+
+# grabbing this from portageq, best to put it in here instead of
+# having the overhead of calling it each time and getting the output.
+def find_latest_package_in_tree(package_name):
+    try:
+        mylist=portage.db["/"][get_dbtree()].dbapi.match(package_name)
+        return portage.best(mylist)
+    except KeyError:
+        return None
+
+# finds the latest available version of a package using all available overlays
+def find_packages_in_tree(package_list):
+    # this value needs to be configurable from cl
+    #overlays = ["/home/allanon/cvs/gnome"]
+    
+    portage_versions = []
+    #for overlay in overlays:
+        #os.environ["PORTDIR_OVERLAY"]=overlay
+        #reload(portage)
+    for package in package_list:
+        best_package = find_latest_package_in_tree(package.name)
+            
+        # if it returns a package, hardcode to first result.
+        # cover the case where it doesn't exist in the tree.
+        if None != best_package and "" != best_package:
+            portage_versions.append(package_module.Package(best_package))
+    
+    return portage_versions    
+    
+def tests():
+    print split_package_into_parts("media-gfx/gimp-3.5.0-r3")
+    print split_package_into_parts("media-gfx/gimp-3.5")
+    print find_category("gimp")
+    print find_category("gimp-2.0")
+    print best_version(["gimp-2.0","gimp-2.0-r1","gimp-3.0"])
diff --git a/modules/portage_module.pyc b/modules/portage_module.pyc
new file mode 100644
index 0000000..53bde98
--- /dev/null
+++ b/modules/portage_module.pyc
diff --git a/modules/simple_cache_module.py b/modules/simple_cache_module.py
new file mode 100644
index 0000000..aca3453
--- /dev/null
+++ b/modules/simple_cache_module.py
@@ -0,0 +1,85 @@
+# Copyright John N. Laliberte <allanonjl@gentoo.org>
+# LICENSE - GPL2
+
+# simple cache module
+
+# This module will store information about the packages we read off of the gnome ftp.
+# This way we don't have to constantly contact the GNOME ftp during the development process
+# of this program.
+
+class SimpleCache:
+    
+    def __init__(self):
+        self.filename = "cache.txt"
+        self.write_queue = []
+    
+    def write_to_queue(self, release_version, latest_version):
+        self.write_queue.append(release_version + "," + latest_version)
+    
+    def append(self, list_of_lines):
+        try:
+            # open file stream
+            file = open(self.filename, "a")
+        except IOError:
+            print "There was an error writing to"+self.filename
+            sys.exit()
+    
+        for line in list_of_lines:
+            file.write(line+"\n")
+        
+        file.close()
+    
+    def flush_queue(self):
+        self.append(self.write_queue)
+    
+    
+class FileStuff:
+    def __init__(self, filename):
+        self.filename = filename
+        self.lines = []
+        
+    def read(self):
+        file = self.open("r")
+        # read the file in line by line, and then return it
+        for line in file.readlines():
+            # replace the newline characters
+            line = string.replace(line,'\n','')
+            # add it to the collection
+            self.lines.append(line)
+        file.close()
+        
+        return self.lines
+        
+    def write(self, list_of_lines):
+        try:
+            # open file stream
+            file = self.open("w")
+        except IOError:
+            print "There was an error writing to"+self.filename
+            sys.exit()
+    
+        for line in list_of_lines:
+            file.write(line+"\n")
+        
+        file.close()
+    
+    def append(self, list_of_lines):
+        try:
+            # open file stream
+            file = self.open("a")
+        except IOError:
+            print "There was an error writing to"+self.filename
+            sys.exit()
+    
+        for line in list_of_lines:
+            file.write(line+"\n")
+        
+        file.close()
+            
+    def open(self, type):
+        try:
+            file = open(self.filename, type)
+            return file
+        except IOError:
+            print "Error reading/writing " + type
+            sys.exit()
diff --git a/modules/simple_cache_module.pyc b/modules/simple_cache_module.pyc
new file mode 100644
index 0000000..d66f8c0
--- /dev/null
+++ b/modules/simple_cache_module.pyc