Merge lp:~jderose/dmedia/filestore-ui into lp:dmedia

[Jason Gerard DeRose]

This mostly deletes a bunch of stale Python2 files that weren't being used anymore.

It also fixes setup.py so that doctests and unittests are run for every module (this was changed temporarily quite a while ago during the big refactor).

Last, this real change in this merge is to revamp how dmedia-service uses UDisks. We now do an initial scan of all mounted partitions to find out about any existing FileStore... this fixes the problem of dmedia only properly detected removable drives if you inserted the drive *after* dmedia started.

[David Jordan (dmj726)]

The UDisks change looks really good, and we need to be dunning tests. This looks good.

review: Approve

=== modified file 'dmedia-service'
--- dmedia-service	2012-03-25 22:39:44 +0000
+++ dmedia-service	2012-04-05 13:22:39 +0000
@@ -41,7 +41,7 @@
 
 import dmedia
 from dmedia.core import Core, start_file_server
-from dmedia.service.dbus import UDisks
+from dmedia.service.udisks import UDisks
 from dmedia.service.avahi import Avahi
 
 
@@ -75,8 +75,6 @@
         if self.env_s is None:
             self.usercouch = usercouch.UserCouch(dmedia.get_dmedia_dir())
             env = self.usercouch.bootstrap()
-            interval = 5 * 60 * 1000  # Autocompact every 5 minutes
-            self._timeout_id = GObject.timeout_add(interval, self._autocompact)
         else:
             env = json.loads(self.env_s)
         self.udisks = UDisks()
@@ -86,8 +84,9 @@
             self.core.add_filestore('/home')
         self.udisks.connect('store_added', self.on_store_added)
         self.udisks.connect('store_removed', self.on_store_removed)
-        self.udisks.monitor()
- 
+        self.udisks.connect('card_added', self.on_card_added)
+        self.udisks.connect('card_removed', self.on_card_removed)
+
     def start_httpd(self):
         (self.httpd, self.port) = start_file_server(self.core.env)
         self.avahi = Avahi(self.core.env, self.port)
@@ -95,8 +94,15 @@
 
     def run(self):
         self.start_core()
+        GObject.timeout_add(500, self.on_idle)
+        self.mainloop.run()
+        
+    def on_idle(self):
+        self.udisks.monitor()
         self.start_httpd()
-        self.mainloop.run()
+        interval = 5 * 60 * 1000  # Autocompact every 5 minutes
+        self._timeout_id = GObject.timeout_add(interval, self._autocompact)
+        return False  # Don't repeat idle call
 
     def _autocompact(self):
         log.info('UserCouch.autocompact()...')
@@ -117,20 +123,32 @@
             self.httpd.join()
         self.mainloop.quit()
 
-    def on_store_added(self, udisks, obj, parentdir, partition, drive):
-        log.info('UDisks store_added: %r', parentdir)
+    def on_store_added(self, udisks, obj, parentdir, store_id):
         try:
             self.AddFileStore(parentdir)
         except Exception:
             log.exception('Could not add FileStore %r', parentdir)
 
-    def on_store_removed(self, udisks, obj, parentdir):
-        log.info('UDisks store_removed: %r', parentdir)
+    def on_store_removed(self, udisks, obj, parentdir, store_id):
         try:
             self.RemoveFileStore(parentdir)
         except Exception:
             log.exception('Could not remove FileStore %r', parentdir)
 
+    def on_card_added(self, udisks, obj, mount):
+        self.CardAdded(obj, mount)
+
+    def on_card_removed(self, udisks, obj, mount):
+        self.CardRemoved(obj, mount)
+   
+    @dbus.service.signal(IFACE, signature='ss')
+    def CardAdded(self, obj, mount):
+        pass
+
+    @dbus.service.signal(IFACE, signature='ss')
+    def CardRemoved(self, obj, mount):
+        pass
+
     @dbus.service.method(IFACE, in_signature='', out_signature='s')
     def Version(self):
         """
@@ -151,6 +169,7 @@
         """
         Return dmedia env as JSON string.
         """
+        log.info('GetEnv')
         return self.env_s
 
     @dbus.service.method(IFACE, in_signature='', out_signature='s')

=== removed directory 'dmedia/backends'
=== removed file 'dmedia/backends/__init__.py'
--- dmedia/backends/__init__.py	2011-04-25 09:03:19 +0000
+++ dmedia/backends/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Plugins for transfer backends for uploading and downloading files.
-"""
-
-try:
-    from . import s3
-except ImportError:
-    pass
-
-try:
-    from . import torrent
-except ImportError:
-    pass

=== removed file 'dmedia/backends/s3.py'
--- dmedia/backends/s3.py	2011-09-04 04:04:17 +0000
+++ dmedia/backends/s3.py	1970-01-01 00:00:00 +0000
@@ -1,184 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Upload to and download from Amazon S3 using ``boto``.
-
-For documentation on ``boto``, see:
-
-    http://code.google.com/p/boto/
-"""
-
-import os
-import logging
-
-# FIXME: how do you use gnomekeyring from PyGI?
-#import gnomekeyring
-gnomekeyring = None
-from boto.s3.connection import S3Connection
-from boto.s3.bucket import Bucket
-from boto.s3.key import Key
-
-from dmedia.constants import LEAF_SIZE
-from dmedia import transfers
-
-
-log = logging.getLogger()
-
-
-def keyring_name(bucket):
-    """
-    Keyring name (description) in which to store S3 credentials.
-
-    For example:
-
-    >>> keyring_name('novacut')
-    'dmedia/s3/novacut'
-
-    """
-    return 'dmedia/s3/' + bucket
-
-
-def keyring_attrs(bucket):
-    """
-    Keyring attributes for item storing S3 credentials.
-
-    For example:
-
-    >>> keyring_attrs('novacut')
-    {'bucket': 'novacut', 'dmedia': 's3'}
-
-    """
-    return {
-        'dmedia': 's3',
-        'bucket': bucket,
-    }
-
-
-def save_credentials(bucket, keyid, secret, keyring=gnomekeyring):
-    keyring.item_create_sync(
-        None,
-        gnomekeyring.ITEM_GENERIC_SECRET,
-        keyring_name(bucket),
-        keyring_attrs(bucket),
-        ':'.join([keyid, secret]),
-        True,
-    )
-
-
-def load_credentials(bucket, keyring=gnomekeyring):
-    raise KeyError  # FIXME gnomekeyring
-    try:
-        items = keyring.find_items_sync(
-            gnomekeyring.ITEM_GENERIC_SECRET,
-            keyring_attrs(bucket),
-        )
-        (keyid, secret) =  items[0].secret.split(':')
-        return (keyid, secret)
-    except gnomekeyring.NoMatchError:
-        raise KeyError
-
-
-class S3Backend(transfers.TransferBackend):
-    """
-    Backend for uploading to and downloading from Amazon S3 using ``boto``.
-    """
-    def setup(self):
-        self.bucketname = self.store['bucket']
-        try:
-            (self.keyid, self.secret) = load_credentials(self.bucketname)
-        except KeyError:
-            pass
-        self._bucket = None
-
-    @property
-    def bucket(self):
-        """
-        Lazily create the ``boto.s3.bucket.Bucket`` instance.
-        """
-        if self._bucket is None:
-            conn = S3Connection(self.keyid, self.secret)
-            self._bucket = conn.get_bucket(self.bucketname)
-        return self._bucket
-
-    def boto_callback(self, completed, total):
-        self.progress(completed)
-
-    def upload(self, doc, leaves, fs):
-        """
-        Upload the file with *doc* metadata from the filestore *fs*.
-
-        :param doc: the CouchDB document of file to upload (a ``dict``)
-        :param fs: a `FileStore` instance from which the file will be read
-        """
-        chash = doc['_id']
-        ext = doc.get('ext')
-        key = self.key(chash, ext)
-        log.info('Uploading %r to S3 bucket %r...', key, self.bucketname)
-
-        k = Key(self.bucket)
-        k.key = key
-        headers = {}
-        if doc.get('content_type'):
-            headers['Content-Type'] = doc['content_type']
-        if doc.get('name'):
-            headers['Content-Disposition'] = (
-                'attachment; filename="{}"'.format(doc['name'])
-            )
-
-        if doc.get('content_type') in ('video/ogg', 'audio/ogg'):
-            dur = doc.get('meta', {}).get('duration')
-            if isinstance(dur, int) and dur >= 0:
-                headers['x-amz-meta-content-duration'] = str(dur)
-        fp = fs.open(chash, ext)
-        k.set_contents_from_file(fp,
-            headers=headers,
-            cb=self.boto_callback,
-            num_cb=max(5, doc['bytes'] / LEAF_SIZE),
-            policy='public-read',
-        )
-        log.info('Uploaded %r to S3 bucket %r', key, self.bucketname)
-        return {'copies': self.copies, 'policy': 'public-read'}
-
-    def download(self, doc, leaves, fs):
-        """
-        Download the file with *doc* metadata into the filestore *fs*.
-
-        :param doc: the CouchDB document of file to download (a ``dict``)
-        :param fs: a `FileStore` instance into which the file will be written
-        """
-        chash = doc['_id']
-        ext = doc.get('ext')
-        key = self.key(chash, ext)
-        log.info('Downloading %r from S3 bucket %r...', key, self.bucketname)
-
-        k = self.bucket.get_key(self.key(chash, ext))
-        tmp_fp = fs.allocate_for_transfer(doc['bytes'], chash, ext)
-        k.get_file(tmp_fp,
-            cb=self.boto_callback,
-            num_cb=max(5, doc['bytes'] / LEAF_SIZE),
-        )
-        tmp_fp.close()
-        log.info('Downloaded %r from S3 bucket %r', key, self.bucketname)
-
-
-transfers.register_uploader('s3', S3Backend)
-transfers.register_downloader('s3', S3Backend)

=== removed directory 'dmedia/backends/tests'
=== removed file 'dmedia/backends/tests/__init__.py'
--- dmedia/backends/tests/__init__.py	2011-04-23 07:29:32 +0000
+++ dmedia/backends/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for the `dmedia.backends` package.
-"""

=== removed file 'dmedia/backends/tests/test_s3.py'
--- dmedia/backends/tests/test_s3.py	2011-09-04 04:04:17 +0000
+++ dmedia/backends/tests/test_s3.py	1970-01-01 00:00:00 +0000
@@ -1,103 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for the `dmedia.backends.s3` module.
-"""
-
-from unittest import TestCase
-
-# FIXME: how do you use gnomekeyring from PyGI?
-#import gnomekeyring 
-
-from dmedia.backends import s3
-
-
-class DummyItem:
-    secret = 'bar:baz'
-
-
-class DummyKeyring(object):
-    def item_create_sync(self, *args):
-        self._create = args
-
-    def find_items_sync(self, *args):
-        self._find = args
-        return [DummyItem()]
-
-
-class TestFunctions(TestCase):
-    def test_keyring_name(self):
-        f = s3.keyring_name
-        self.assertEqual(f('whatever'), 'dmedia/s3/whatever')
-
-    def test_keyring_attrs(self):
-        f = s3.keyring_attrs
-        self.assertEqual(f('whatever'), {'bucket': 'whatever', 'dmedia': 's3'})
-
-    def test_save_credentials(self):
-        self.skipTest('gnomekeyring')
-        f = s3.save_credentials
-        k = DummyKeyring()
-        self.assertIsNone(f('foo', 'bar', 'baz', k))
-        self.assertEqual(
-            k._create,
-            (
-                None,
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                'dmedia/s3/foo',
-                {'bucket': 'foo', 'dmedia': 's3'},
-                'bar:baz',
-                True,
-            )
-        )
-
-    def test_load_credentials(self):
-        self.skipTest('gnomekeyring')
-        f = s3.load_credentials
-        k = DummyKeyring()
-        self.assertEqual(f('foo', k), ('bar', 'baz'))
-        self.assertEqual(
-            k._find,
-            (
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'bucket': 'foo', 'dmedia': 's3'},
-            )
-        )
-
-
-
-class TestS3Backend(TestCase):
-    klass = s3.S3Backend
-
-    def test_init(self):
-        inst = self.klass({'_id': 'foo', 'bucket': 'bar'})
-        self.assertEqual(inst.bucketname, 'bar')
-        self.assertEqual(inst._bucket, None)
-
-    def test_repr(self):
-        inst = self.klass({'_id': 'foo', 'bucket': 'bar'})
-        self.assertEqual(repr(inst), "S3Backend('foo')")
-
-    def test_bucket(self):
-        inst = self.klass({'_id': 'foo', 'bucket': 'bar'})
-        inst._bucket = 'whatever'
-        self.assertEqual(inst.bucket, 'whatever')

=== removed file 'dmedia/backends/tests/test_torrent.py'
--- dmedia/backends/tests/test_torrent.py	2011-04-25 09:03:19 +0000
+++ dmedia/backends/tests/test_torrent.py	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for the `dmedia.backends.torrent` module.
-"""
-
-from unittest import TestCase
-import httplib
-
-from dmedia.backends import torrent
-
-
-class TestTorrentBackend(TestCase):
-    klass = torrent.TorrentBackend
-
-    def test_init(self):
-        url = 'https://foo.s3.amazonaws.com/'
-        inst = self.klass({'url': url})
-        self.assertEqual(inst.url, url)
-        self.assertEqual(inst.basepath, '/')
-        self.assertEqual(
-            inst.t,
-            ('https', 'foo.s3.amazonaws.com', '/', '', '', '')
-        )
-        self.assertIsInstance(inst.conn, httplib.HTTPSConnection)
-
-        url = 'http://example.com/bar'
-        inst = self.klass({'url': url})
-        self.assertEqual(inst.url, url)
-        self.assertEqual(inst.basepath, '/bar/')
-        self.assertEqual(
-            inst.t,
-            ('http', 'example.com', '/bar', '', '', '')
-        )
-        self.assertIsInstance(inst.conn, httplib.HTTPConnection)
-        self.assertNotIsInstance(inst.conn, httplib.HTTPSConnection)
-
-        with self.assertRaises(ValueError) as cm:
-            inst = self.klass({'url': 'ftp://example.com/'})
-        self.assertEqual(
-            str(cm.exception),
-            "url scheme must be http or https; got 'ftp://example.com/'"
-        )
-
-        with self.assertRaises(ValueError) as cm:
-            inst = self.klass({'url': 'http:example.com/bar'})
-        self.assertEqual(
-            str(cm.exception),
-            "bad url: 'http:example.com/bar'"
-        )

=== removed file 'dmedia/backends/torrent.py'
--- dmedia/backends/torrent.py	2011-04-25 09:03:19 +0000
+++ dmedia/backends/torrent.py	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Download with BitTorrent.
-"""
-
-import logging
-import time
-from os import path
-
-import libtorrent
-
-from dmedia.constants import LEAF_SIZE
-from dmedia.transfers import HTTPBaseBackend, register_downloader, http_conn
-
-
-log = logging.getLogger()
-
-
-class TorrentBackend(HTTPBaseBackend):
-    """
-    Backend for BitTorrent downloads using `libtorrent`.
-    """
-
-    def download(self, doc, leaves, fs):
-        chash = doc['_id']
-        ext = doc.get('ext')
-        url = self.basepath + self.key(chash, ext) + '?torrent'
-        data = self.get(url)
-
-        tmp = fs.tmp(chash, ext, create=True)
-        session = libtorrent.session()
-        session.listen_on(6881, 6891)
-
-        info = libtorrent.torrent_info(libtorrent.bdecode(data))
-
-        torrent = session.add_torrent({
-            'ti': info,
-            'save_path': path.dirname(tmp),
-        })
-
-        while not torrent.is_seed():
-            s = torrent.status()
-            self.progress(s.total_payload_download)
-            time.sleep(2)
-
-        session.remove_torrent(torrent)
-        time.sleep(2)
-
-
-register_downloader('torrent', TorrentBackend)

=== modified file 'dmedia/core.py'
--- dmedia/core.py	2012-01-23 17:56:15 +0000
+++ dmedia/core.py	2012-04-05 13:22:39 +0000
@@ -98,7 +98,6 @@
 class Base:
     def __init__(self, env):
         self.env = env
-        self.db = Database(schema.DB_NAME, env)
         self.logdb = Database('dmedia_log', env)
 
     def log(self, doc):
@@ -107,9 +106,10 @@
         return self.logdb.post(doc, batch='ok')
 
 
-class Core(Base):
+class Core:
     def __init__(self, env, get_parentdir_info=None, bootstrap=True):
-        super().__init__(env)
+        self.env = env
+        self.db = Database(schema.DB_NAME, env)
         self.stores = LocalStores()
         self._get_parentdir_info = get_parentdir_info
         if bootstrap:
@@ -117,7 +117,6 @@
 
     def _bootstrap(self):
         self.db.ensure()
-        self.logdb.ensure()
         init_views(self.db)
         self._init_local()
         self._init_stores()
@@ -169,8 +168,8 @@
         doc['connected'] = time.time()
         doc['connected_to'] = self.machine_id
         doc['statvfs'] = fs.statvfs()._asdict()
-        if callable(self._get_parentdir_info):
-            doc.update(self._get_parentdir_info(parentdir))
+        #if callable(self._get_parentdir_info):
+        #    doc.update(self._get_parentdir_info(parentdir))
         self.db.save(doc)
         log.info('FileStore %r at %r', fs.id, fs.parentdir)
         return fs

=== removed directory 'dmedia/gst'
=== removed file 'dmedia/gst/__init__.py'
--- dmedia/gst/__init__.py	2011-09-16 03:22:56 +0000
+++ dmedia/gst/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-GStreamer PyGI backend components.
-"""
-

=== removed directory 'dmedia/gst/tests'
=== removed file 'dmedia/gst/tests/__init__.py'
--- dmedia/gst/tests/__init__.py	2011-09-16 03:22:56 +0000
+++ dmedia/gst/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for the `dmedia.gst` subpackage.
-"""

=== removed file 'dmedia/gst/tests/test_transcoder.py'
--- dmedia/gst/tests/test_transcoder.py	2011-09-16 03:22:56 +0000
+++ dmedia/gst/tests/test_transcoder.py	1970-01-01 00:00:00 +0000
@@ -1,294 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `dmedia.transcoder` module.
-"""
-
-from unittest import TestCase
-
-from gi.repository import Gst
-
-from dmedia import transcoder
-from dmedia.constants import TYPE_ERROR
-from dmedia.filestore import FileStore
-from .helpers import sample_mov, mov_hash, TempDir, raises
-
-
-class test_functions(TestCase):
-    def test_caps_string(self):
-        f = transcoder.caps_string
-        self.assertEqual(
-            f('audio/x-raw-float', {}),
-            'audio/x-raw-float'
-        )
-        self.assertEqual(
-            f('audio/x-raw-float', {'rate': 44100}),
-            'audio/x-raw-float, rate=44100'
-        )
-        self.assertEqual(
-            f('audio/x-raw-float', {'rate': 44100, 'channels': 1}),
-            'audio/x-raw-float, channels=1, rate=44100'
-        )
-
-
-class test_TranscodBin(TestCase):
-    klass = transcoder.TranscodeBin
-
-    def test_init(self):
-        d = {
-            'enc': 'vorbisenc',
-            'props': {
-                'quality': 0.5,
-            },
-        }
-        inst = self.klass(d)
-        self.assertTrue(inst._d is d)
-
-        self.assertTrue(inst._q1.get_parent() is inst)
-        self.assertTrue(isinstance(inst._q1, Gst.Element))
-        self.assertEqual(inst._q1.get_factory().get_name(), 'queue')
-
-        self.assertTrue(inst._enc.get_parent() is inst)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'vorbisenc')
-        self.assertEqual(inst._enc.get_property('quality'), 0.5)
-
-        self.assertTrue(inst._q2.get_parent() is inst)
-        self.assertTrue(isinstance(inst._q2, Gst.Element))
-        self.assertEqual(inst._q2.get_factory().get_name(), 'queue')
-
-        d = {'enc': 'vorbisenc'}
-        inst = self.klass(d)
-        self.assertTrue(inst._d is d)
-
-        self.assertTrue(inst._q1.get_parent() is inst)
-        self.assertTrue(isinstance(inst._q1, Gst.Element))
-        self.assertEqual(inst._q1.get_factory().get_name(), 'queue')
-
-        self.assertTrue(inst._enc.get_parent() is inst)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'vorbisenc')
-        self.assertNotEqual(inst._enc.get_property('quality'), 0.5)
-
-        self.assertTrue(inst._q2.get_parent() is inst)
-        self.assertTrue(isinstance(inst._q2, Gst.Element))
-        self.assertEqual(inst._q2.get_factory().get_name(), 'queue')
-
-    def test_repr(self):
-        d = {
-            'enc': 'vorbisenc',
-            'props': {
-                'quality': 0.5,
-            },
-        }
-
-        inst = self.klass(d)
-        self.assertEqual(
-            repr(inst),
-            'TranscodeBin(%r)' % (d,)
-        )
-
-        class FooBar(self.klass):
-            pass
-        inst = FooBar(d)
-        self.assertEqual(
-            repr(inst),
-            'FooBar(%r)' % (d,)
-        )
-
-    def test_make(self):
-        d = {'enc': 'vorbisenc'}
-        inst = self.klass(d)
-
-        enc = inst._make('theoraenc')
-        self.assertTrue(enc.get_parent() is inst)
-        self.assertTrue(isinstance(enc, Gst.Element))
-        self.assertEqual(enc.get_factory().get_name(), 'theoraenc')
-        self.assertEqual(enc.get_property('quality'), 48)
-        self.assertEqual(enc.get_property('keyframe-force'), 64)
-
-        enc = inst._make('theoraenc', {'quality': 50, 'keyframe-force': 32})
-        self.assertTrue(enc.get_parent() is inst)
-        self.assertTrue(isinstance(enc, Gst.Element))
-        self.assertEqual(enc.get_factory().get_name(), 'theoraenc')
-        self.assertEqual(enc.get_property('quality'), 50)
-        self.assertEqual(enc.get_property('keyframe-force'), 32)
-
-
-class test_AudioTranscoder(TestCase):
-    klass = transcoder.AudioTranscoder
-
-    def test_init(self):
-        d = {
-            'enc': 'vorbisenc',
-            'props': {
-                'quality': 0.5,
-            },
-        }
-        inst = self.klass(d)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'vorbisenc')
-        self.assertEqual(inst._enc.get_property('quality'), 0.5)
-
-        d = {
-            'enc': 'vorbisenc',
-            'caps': {'rate': 44100},
-            'props': {'quality': 0.25},
-        }
-        inst = self.klass(d)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'vorbisenc')
-        self.assertEqual(inst._enc.get_property('quality'), 0.25)
-
-
-class test_VideoTranscoder(TestCase):
-    klass = transcoder.VideoTranscoder
-
-    def test_init(self):
-        d = {
-            'enc': 'theoraenc',
-            'props': {
-                'quality': 50,
-                'keyframe-force': 32,
-            },
-        }
-        inst = self.klass(d)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'theoraenc')
-        self.assertEqual(inst._enc.get_property('quality'), 50)
-
-        d = {
-            'enc': 'theoraenc',
-            'caps': {'width': 800, 'height': 450},
-            'props': {
-                'quality': 50,
-                'keyframe-force': 32,
-            },
-        }
-        inst = self.klass(d)
-        self.assertTrue(isinstance(inst._enc, Gst.Element))
-        self.assertEqual(inst._enc.get_factory().get_name(), 'theoraenc')
-        self.assertEqual(inst._enc.get_property('quality'), 50)
-
-
-class test_Transcoder(TestCase):
-    klass = transcoder.Transcoder
-
-    def setUp(self):
-        self.tmp = TempDir()
-        self.fs = FileStore(self.tmp.path)
-        self.fs.import_file(open(sample_mov, 'rb'), 'mov')
-
-    def test_init(self):
-        job = {
-            'src': {'id': mov_hash, 'ext': 'mov'},
-            'mux': 'oggmux',
-            'ext': 'ogv',
-        }
-
-        e = raises(TypeError, self.klass, 17, self.fs)
-        self.assertEqual(
-            str(e),
-            TYPE_ERROR % ('job', dict, int, 17)
-        )
-        e = raises(TypeError, self.klass, job, 18)
-        self.assertEqual(
-            str(e),
-            TYPE_ERROR % ('fs', FileStore, int, 18)
-        )
-
-        inst = self.klass(job, self.fs)
-        self.assertTrue(inst.job is job)
-        self.assertTrue(inst.fs is self.fs)
-
-        self.assertTrue(isinstance(inst.dst_fp, file))
-        self.assertEqual(inst.dst_fp.mode, 'r+b')
-        self.assertTrue(
-            inst.dst_fp.name.startswith(self.tmp.join('.dmedia', 'writes'))
-        )
-        self.assertTrue(inst.dst_fp.name.endswith('.ogv'))
-
-        self.assertTrue(isinstance(inst.src, Gst.Element))
-        self.assertTrue(inst.src.get_parent() is inst.pipeline)
-        self.assertEqual(inst.src.get_factory().get_name(), 'filesrc')
-        self.assertEqual(
-            inst.src.get_property('location'),
-            self.fs.path(mov_hash, 'mov')
-        )
-
-        self.assertTrue(isinstance(inst.dec, Gst.Element))
-        self.assertTrue(inst.dec.get_parent() is inst.pipeline)
-        self.assertEqual(inst.dec.get_factory().get_name(), 'decodebin2')
-
-        self.assertTrue(isinstance(inst.mux, Gst.Element))
-        self.assertTrue(inst.mux.get_parent() is inst.pipeline)
-        self.assertEqual(inst.mux.get_factory().get_name(), 'oggmux')
-
-        self.assertTrue(isinstance(inst.sink, Gst.Element))
-        self.assertTrue(inst.sink.get_parent() is inst.pipeline)
-        self.assertEqual(inst.sink.get_factory().get_name(), 'fdsink')
-        self.assertEqual(inst.sink.get_property('fd'), inst.dst_fp.fileno())
-
-    def test_theora450(self):
-        self.skipTest('fix me gi.repository.Gst')
-        job = {
-            'src': {'id': mov_hash, 'ext': 'mov'},
-            'mux': 'oggmux',
-            'video': {
-                'enc': 'theoraenc',
-                'caps': {'width': 800, 'height': 450},
-            },
-        }
-        inst = self.klass(job, self.fs)
-        inst.run()
-
-    def test_flac(self):
-        self.skipTest('fix me gi.repository.Gst')
-        job = {
-            'src': {'id': mov_hash, 'ext': 'mov'},
-            'mux': 'oggmux',
-            'audio': {
-                'enc': 'flacenc',
-                'caps': {'rate': 44100},
-            },
-        }
-        inst = self.klass(job, self.fs)
-        inst.run()
-
-    def test_theora360_vorbis(self):
-        self.skipTest('fix me gi.repository.Gst')
-        job = {
-            'src': {'id': mov_hash, 'ext': 'mov'},
-            'mux': 'oggmux',
-            'video': {
-                'enc': 'theoraenc',
-                'props': {'quality': 40},
-                'caps': {'width': 800, 'height': 450},
-            },
-            'audio': {
-                'enc': 'vorbisenc',
-                'props': {'quality': 0.4},
-                'caps': {'rate': 44100},
-            },
-        }
-        inst = self.klass(job, self.fs)
-        inst.run()

=== removed file 'dmedia/gst/transcoder.py'
--- dmedia/gst/transcoder.py	2011-09-16 03:22:56 +0000
+++ dmedia/gst/transcoder.py	1970-01-01 00:00:00 +0000
@@ -1,238 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-GStreamer-based transcoder.
-"""
-
-import logging
-
-from gi.repository import GObject, Gst
-
-from .constants import TYPE_ERROR
-from .filestore import FileStore
-
-
-log = logging.getLogger()
-GObject.threads_init()
-Gst.init(None)
-
-
-def caps_string(mime, caps):
-    """
-    Build a GStreamer caps string.
-
-    For example:
-
-    >>> caps_string('video/x-raw-yuv', {'width': 800, 'height': 450})
-    'video/x-raw-yuv, height=450, width=800'
-    """
-    accum = [mime]
-    for key in sorted(caps):
-        accum.append('%s=%s' % (key, caps[key]))
-    return ', '.join(accum)
-
-
-
-class TranscodeBin(Gst.Bin):
-    """
-    Base class for `AudioTranscoder` and `VideoTranscoder`.
-    """
-    def __init__(self, d):
-        super(TranscodeBin, self).__init__()
-        self._d = d
-        self._q1 = self._make('queue')
-        self._enc = self._make(d['enc'], d.get('props'))
-        self._q2 = self._make('queue')
-        self._enc.link(self._q2)
-        self.add_pad(
-            Gst.GhostPad.new('sink', self._q1.get_pad('sink'))
-        )
-        self.add_pad(
-            Gst.GhostPad.new('src', self._q2.get_pad('src'))
-        )
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self._d)
-
-    def _make(self, name, props=None):
-        """
-        Create gst element, set properties, and add to this bin.
-        """
-        element = Gst.ElementFactory.make(name, None)
-        if props:
-            for (key, value) in props.iteritems():
-                element.set_property(key, value)
-        self.add(element)
-        return element
-
-
-class AudioTranscoder(TranscodeBin):
-    def __init__(self, d):
-        super(AudioTranscoder, self).__init__(d)
-
-        # Create processing elements:
-        self._conv = self._make('audioconvert')
-        self._rsp = self._make('audioresample', {'quality': 10})
-        self._rate = self._make('audiorate')
-
-        # Link elements:
-        self._q1.link(self._conv)
-        self._conv.link(self._rsp)
-        if d.get('caps'):
-            # FIXME: There is probably a better way to do this, but the caps API
-            # has always been a bit of a mystery to me.  --jderose
-            if d['enc'] == 'vorbisenc':
-                mime = 'audio/x-raw-float'
-            else:
-                mime = 'audio/x-raw-int'
-            caps = Gst.caps_from_string(
-                caps_string(mime, d['caps'])
-            )
-            self._rsp.link_filtered(self._rate, caps)
-        else:
-            self._rsp.link(self._rate)
-        self._rate.link(self._enc)
-
-
-class VideoTranscoder(TranscodeBin):
-    def __init__(self, d):
-        super(VideoTranscoder, self).__init__(d)
-
-        # Create processing elements:
-        self._scale = self._make('ffvideoscale', {'method': 10})
-        self._q = self._make('queue')
-
-        # Link elements:
-        self._q1.link(self._scale)
-        if d.get('caps'):
-            caps = Gst.caps_from_string(
-                caps_string('video/x-raw-yuv', d['caps'])
-            )
-            self._scale.link_filtered(self._q, caps)
-        else:
-            self._scale.link(self._q)
-        self._q.link(self._enc)
-
-
-class Transcoder(object):
-    def __init__(self, job, fs):
-        """
-        Initialize.
-
-        :param job: a ``dict`` describing the transcode to perform.
-        :param fs: a `FileStore` instance in which to store transcoded file
-        """
-        if not isinstance(job, dict):
-            raise TypeError(
-                TYPE_ERROR % ('job', dict, type(job), job)
-            )
-        if not isinstance(fs, FileStore):
-            raise TypeError(
-                TYPE_ERROR % ('fs', FileStore, type(fs), fs)
-            )
-        self.job = job
-        self.fs = fs
-
-        src = job['src']
-        src_filename = self.fs.path(src['id'], src.get('ext'))
-        self.dst_fp = self.fs.allocate_for_write(job.get('ext'))
-
-        self.mainloop = GObject.MainLoop()
-        self.pipeline = Gst.Pipeline()
-
-        # Create bus and connect several handlers
-        self.bus = self.pipeline.get_bus()
-        self.bus.add_signal_watch()
-        self.bus.connect('message::eos', self.on_eos)
-        self.bus.connect('message::error', self.on_error)
-
-        # Create elements
-        self.src = Gst.ElementFactory.make('filesrc', None)
-        self.dec = Gst.ElementFactory.make('decodebin2', None)
-        self.mux = Gst.ElementFactory.make(job['mux'], None)
-        self.sink = Gst.ElementFactory.make('fdsink', None)
-
-        # Set properties
-        self.src.set_property('location', src_filename)
-        self.sink.set_property('fd', self.dst_fp.fileno())
-
-        # Connect handler for 'new-decoded-pad' signal
-        self.dec.connect('new-decoded-pad', self.on_new_decoded_pad)
-
-        # Add elements to pipeline
-        for el in (self.src, self.dec, self.mux, self.sink):
-            self.pipeline.add(el)
-
-        # Link *some* elements
-        # This is completed in self.on_new_decoded_pad()
-        self.src.link(self.dec)
-        self.mux.link(self.sink)
-
-        self.audio = None
-        self.video = None
-        self.tup = None
-
-    def run(self):
-        self.pipeline.set_state(Gst.State.PLAYING)
-        self.mainloop.run()
-        return self.tup
-
-    def kill(self):
-        self.pipeline.set_state(Gst.State.NULL)
-        self.pipeline.get_state()
-        self.mainloop.quit()
-
-    def link_pad(self, pad, name, key):
-        if key in self.job:
-            klass = {'audio': AudioTranscoder, 'video': VideoTranscoder}[key]
-            el = klass(self.job[key])
-        else:
-            el = Gst.ElementFactory.make('fakesink', None)
-        self.pipeline.add(el)
-        log.info('Linking pad %r with %r', name, el)
-        pad.link(el.get_pad('sink'))
-        if key in self.job:
-            el.link(self.mux)
-        el.set_state(Gst.State.PLAYING)
-        return el
-
-    def on_new_decoded_pad(self, element, pad, last):
-        name = pad.get_caps().to_string()
-        log.debug('new decoded pad: %r', name)
-        if name.startswith('audio/'):
-            assert self.audio is None
-            self.audio = self.link_pad(pad, name, 'audio')
-        elif name.startswith('video/'):
-            assert self.video is None
-            self.video = self.link_pad(pad, name, 'video')
-
-    def on_eos(self, bus, msg):
-        log.info('eos')
-        self.kill()
-        self.dst_fp.close()
-        fp = open(self.dst_fp.name, 'rb')
-        self.tup = self.fs.tmp_hash_move(fp, self.job.get('ext'))
-
-    def on_error(self, bus, msg):
-        error = msg.parse_error()[1]
-        log.error(error)
-        self.kill()

=== removed file 'dmedia/gtk/client.py'
--- dmedia/gtk/client.py	2011-04-10 09:55:27 +0000
+++ dmedia/gtk/client.py	1970-01-01 00:00:00 +0000
@@ -1,238 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Convenience wrapper for Python applications talking to dmedia dbus service.
-"""
-
-import dbus
-import dbus.mainloop.glib
-from gi.repository import GObject
-from gi.repository.GObject import TYPE_PYOBJECT
-from dmedia.constants import IMPORT_BUS, IMPORT_IFACE, EXTENSIONS
-
-
-# We need mainloop integration to test signals:
-dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-
-
-class Client(GObject.GObject):
-    """
-    Simple and Pythonic way to control dmedia dbus service.
-
-    For Python applications, this client provides several advantages over
-    strait dbus because it:
-
-      1. Lazily starts the dmedia service the first time you call a dbus method
-         or connect a signal handler
-
-      2. More Pythonic API, including default argument values where they make
-         sense
-
-      3. Can use convenient GObject signals
-
-    Controlling import operations
-    =============================
-
-    The dmedia service can have multiple import operations running at once.
-    Import jobs are identified by the path of the directory being imported.
-
-    For example, use `Client.list_imports()` to get the list of currently running
-    imports:
-
-    >>> from dmedia.gtkui.client import Client
-    >>> client = Client()  #doctest: +SKIP
-    >>> client.list_imports()  #doctest: +SKIP
-    []
-
-    Start an import operation using `Client.start_import()`, after which you
-    will see it in the list of running imports:
-
-    >>> client.start_import('/media/EOS_DIGITAL')  #doctest: +SKIP
-    'started'
-    >>> client.list_imports()  #doctest: +SKIP
-    ['/media/EOS_DIGITAL']
-
-    If you try to import a path for which an import operation is already in
-    progress, `Client.start_import()` will return the status string
-    ``'already_running'``:
-
-    >>> client.start_import('/media/EOS_DIGITAL')  #doctest: +SKIP
-    'already_running'
-
-    Stop an import operation using `Client.stop_import()`, after which there
-    will be no running imports:
-
-    >>> client.stop_import('/media/EOS_DIGITAL')  #doctest: +SKIP
-    'stopped'
-    >>> client.list_imports()  #doctest: +SKIP
-    []
-
-    If you try to stop an import operation that doesn't exist,
-    `Client.stop_import()` will return the status string ``'not_running'``:
-
-    >>> client.stop_import('/media/EOS_DIGITAL')  #doctest: +SKIP
-    'not_running'
-
-    Finally, you can shutdown the dmedia service with `Client.kill()`:
-
-    >>> client.kill()  #doctest: +SKIP
-
-    """
-
-    __gsignals__ = {
-        'batch_started': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT]
-        ),
-        'batch_finished': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT, TYPE_PYOBJECT]
-        ),
-        'import_started': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT, TYPE_PYOBJECT]
-        ),
-        'import_count': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT]
-        ),
-        'import_progress': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT,
-            TYPE_PYOBJECT]
-        ),
-        'import_finished': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT]
-        ),
-    }
-
-    def __init__(self, bus=None):
-        super(Client, self).__init__()
-        self._bus = (IMPORT_BUS if bus is None else bus)
-        self._conn = dbus.SessionBus()
-        self._proxy = None
-
-    @property
-    def proxy(self):
-        """
-        Lazily create proxy object so dmedia service starts only when needed.
-        """
-        if self._proxy is None:
-            self._proxy = self._conn.get_object(self._bus, '/')
-            self._connect_signals()
-        return self._proxy
-
-    def _call(self, name, *args):
-        method = self.proxy.get_dbus_method(name, dbus_interface=IMPORT_IFACE)
-        return method(*args)
-
-    def _connect_signals(self):
-        self.proxy.connect_to_signal(
-            'BatchStarted', self._on_BatchStarted, IMPORT_IFACE
-        )
-        self.proxy.connect_to_signal(
-            'BatchFinished', self._on_BatchFinished, IMPORT_IFACE
-        )
-        self.proxy.connect_to_signal(
-            'ImportStarted', self._on_ImportStarted, IMPORT_IFACE
-        )
-        self.proxy.connect_to_signal(
-            'ImportCount', self._on_ImportCount, IMPORT_IFACE
-        )
-        self.proxy.connect_to_signal(
-            'ImportProgress', self._on_ImportProgress, IMPORT_IFACE
-        )
-        self.proxy.connect_to_signal(
-            'ImportFinished', self._on_ImportFinished, IMPORT_IFACE
-        )
-
-    def _on_BatchStarted(self, batch_id):
-        self.emit('batch_started', batch_id)
-
-    def _on_BatchFinished(self, batch_id, stats):
-        self.emit('batch_finished', batch_id, stats)
-
-    def _on_ImportStarted(self, base, import_id):
-        self.emit('import_started', base, import_id)
-
-    def _on_ImportCount(self, base, import_id, total):
-        self.emit('import_count', base, import_id, total)
-
-    def _on_ImportProgress(self, base, import_id, completed, total, info):
-        self.emit('import_progress', base, import_id, completed, total, info)
-
-    def _on_ImportFinished(self, base, import_id, stats):
-        self.emit('import_finished', base, import_id, stats)
-
-    def connect(self, *args, **kw):
-        super(Client, self).connect(*args, **kw)
-        if self._proxy is None:
-            self.proxy
-
-    def kill(self):
-        """
-        Shutdown the dmedia daemon.
-        """
-        self._call('Kill')
-        self._proxy = None
-
-    def version(self):
-        """
-        Return version number of running dmedia daemon.
-        """
-        return self._call('Version')
-
-    def get_extensions(self, types):
-        """
-        Get a list of extensions based on broad categories in *types*.
-
-        Currently recognized categories include ``'video'``, ``'audio'``,
-        ``'images'``, and ``'all'``.  You can safely include categories that
-        don't yet exist.
-
-        :param types: A list of general categories, e.g. ``['video', 'audio']``
-        """
-        return self._call('GetExtensions', types)
-
-    def start_import(self, base, extract=True):
-        """
-        Start import of card mounted at *base*.
-
-        If *extract* is ``True`` (the default), metadata will be extracted and
-        thumbnails generated.
-
-        :param base: File-system path from which to import, e.g.
-            ``'/media/EOS_DIGITAL'``
-        :param extract: If ``True``, perform metadata extraction, thumbnail
-            generation; default is ``True``.
-        """
-        return self._call('StartImport', base, extract)
-
-    def stop_import(self, base):
-        """
-        Start import of card mounted at *base*.
-
-        :param base: File-system path from which to import, e.g.
-            ``'/media/EOS_DIGITAL'``
-        """
-        return self._call('StopImport', base)
-
-    def list_imports(self):
-        """
-        Return list of currently running imports.
-        """
-        return self._call('ListImports')

=== removed file 'dmedia/gtk/firstrun.py'
--- dmedia/gtk/firstrun.py	2011-03-28 11:25:27 +0000
+++ dmedia/gtk/firstrun.py	1970-01-01 00:00:00 +0000
@@ -1,279 +0,0 @@
-#!/usr/bin/env python
-
-# Authors:
-#   David Green <[e-mail]>
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-import os
-from os import path
-from xml.sax import saxutils
-from gettext import gettext as _
-
-from gi.repository import Gtk, Pango, GConf
-
-
-NO_DIALOG = '/apps/dmedia/dont-show-import-firstrun'
-conf = GConf.Client.get_default()
-
-
-TITLE = _('DMedia Importer')
-
-ICON_SIZE = Gtk.IconSize.LARGE_TOOLBAR
-PADDING = 5
-
-
-class EasyBox(object):
-    """
-    A more convenient box borrowed from TymeLapse.
-    """
-    def _pack(self, widget, expand=False, padding=PADDING, end=False):
-        method = (self.pack_start if not end else self.pack_end)
-        method(widget, expand, expand, padding)
-        return widget
-
-
-class VBox(Gtk.VBox, EasyBox):
-    pass
-
-
-class HBox(Gtk.HBox, EasyBox):
-    pass
-
-
-class Label(Gtk.Label):
-    """
-    A more convenient label borrowed from TymeLapse.
-    """
-    def __init__(self, text, *tags):
-        super(Label, self).__init__()
-        self.set_alignment(0, 0.5)
-        self.set_padding(5, 5)
-        self._text = text
-        self._tags = set(tags)
-        self._update()
-        #self.set_selectable(True)
-
-    def _add_tags(self, *tags):
-        self._tags.update(tags)
-        self._update()
-
-    def _remove_tags(self, *tags):
-        for tag in tags:
-            if tag in self._tags:
-                self._tags.remove(tag)
-        self._update()
-
-    def _set_text(self, text):
-        self._text = text
-        self._update()
-
-    def _update(self):
-        text = ('' if self._text is None else self._text)
-        if text and self._tags:
-            m = saxutils.escape(text)
-            for tag in self._tags:
-                m = '<%(tag)s>%(m)s</%(tag)s>' % dict(tag=tag, m=m)
-            self.set_markup(m)
-        else:
-            self.set_text(text)
-
-
-class Button(Gtk.Button):
-    def __init__(self, stock=None, text=None):
-        super(Button, self).__init__()
-        hbox = HBox()
-        self.add(hbox)
-        self._image = Gtk.Image()
-        self._label = Label(None)
-        hbox._pack(self._image)
-        hbox._pack(self._label, expand=True)
-        if stock is not None:
-            self._set_stock(stock)
-        if text is not None:
-            self._set_text(text)
-
-    def _set_stock(self, stock, size=ICON_SIZE):
-        self._image.set_from_stock(stock, size)
-
-    def _set_text(self, text):
-        self._label.set_text(text)
-
-
-class FolderChooser(Button):
-    def __init__(self):
-        super(FolderChooser, self).__init__(stock=Gtk.STOCK_OPEN)
-        self._label.set_ellipsize(Pango.EllipsizeMode.START)
-        self._title = _('Choose folder to import...')
-        self.connect('clicked', self._on_clicked)
-        self._set_value(os.environ['HOME'])
-
-    def _set_value(self, value):
-        self._value = path.abspath(value)
-        self._label._set_text(self._value)
-
-    def _on_clicked(self, button):
-        dialog = Gtk.FileChooserDialog(
-            title=self._title,
-            action=Gtk.FileChooserAction.SELECT_FOLDER,
-            buttons=(
-                Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
-                Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
-            ),
-        )
-        dialog.set_current_folder(self._value)
-        response = dialog.run()
-        if response == Gtk.ResponseType.OK:
-            self._set_value(dialog.get_filename())
-        dialog.destroy()
-
-
-def okay_button():
-    return Button(Gtk.STOCK_OK, _('OK, Import Files'))
-
-
-class ImportDialog(Gtk.Window):
-    def __init__(self):
-        super(ImportDialog, self).__init__()
-        self.set_default_size(425, 200)
-        self.set_title(TITLE)
-        try:
-            self.set_icon_from_file('/usr/share/pixmaps/dmedia.svg')
-        except:
-            pass
-        self.connect('destroy', Gtk.main_quit)
-
-        self._value = None
-
-        hbox = HBox()
-        self.add(hbox)
-
-        vbox = VBox()
-        hbox._pack(vbox, expand=True)
-
-        vbox._pack(Label(_('Choose Folder:'), 'b'))
-        self._folder = FolderChooser()
-        vbox._pack(self._folder)
-
-        self._button = okay_button()
-        vbox._pack(self._button, end=True)
-        self._button.connect('clicked', self._on_clicked)
-
-        self.show_all()
-
-    def run(self):
-        Gtk.main()
-        return self._value
-
-    def _on_clicked(self, button):
-        self._value = self._folder._value
-        Gtk.main_quit()
-
-
-class FirstRunGUI(Gtk.Window):
-    """
-    Promt use first time dmedia importer is run.
-
-    For example:
-
-    >>> from dmedia.gtkui.firstrun import FirstRunGUI
-    >>> run = FirstRunGUI.run_if_first_run('/media/EOS_DIGITAL')  #doctest: +SKIP
-    """
-
-    def __init__(self):
-        super(FirstRunGUI, self).__init__()
-        self.set_default_size(425, 200)
-
-        self.set_title(TITLE)
-        try:
-            self.set_icon_from_file('/usr/share/pixmaps/dmedia.svg')
-        except:
-            pass
-
-        self.ok_was_pressed = False
-
-        self.add_content()
-
-        self.connect_signals()
-
-    def add_content(self):
-        vbox = VBox()
-        self.add(vbox)
-
-        label1 = Label(_('Welcome to the dmedia importer!'), 'big')
-        label1.set_alignment(0.5, 0.5)
-        vbox._pack(label1)
-
-        label2 = Label(_('It will import all files in the following folder:'))
-        vbox._pack(label2)
-
-        self.folder = Label(None, 'b')
-        self.folder.set_ellipsize(Pango.EllipsizeMode.START)
-        vbox._pack(self.folder)
-
-        self.dont_show_again = Gtk.CheckButton(label=_("Don't show this again"))
-        self.dont_show_again.set_active(True)
-
-        self.ok = okay_button()
-
-        hbox = HBox()
-        hbox._pack(self.ok, expand=True)
-        hbox._pack(self.dont_show_again)
-
-        vbox._pack(hbox, end=True)
-
-
-    def connect_signals(self):
-        self.connect("delete_event", self.delete_event)
-        self.connect("destroy", self.destroy)
-        self.ok.connect("clicked", self.on_ok)
-
-
-    def destroy(self, widget, data=None):
-        Gtk.main_quit()
-
-
-    def delete_event(self, widget, event, data=None):
-        return False
-
-
-    def on_ok(self, widget):
-        dont_show_again = self.dont_show_again.get_active()
-        val = 0
-        if dont_show_again:
-            val = 1
-        conf.set_bool(NO_DIALOG, val)
-        self.ok_was_pressed = True
-        self.destroy(widget)
-
-    def go(self, folder):
-        self.folder._set_text(folder)
-        self.show_all()
-        Gtk.main()
-        return self.ok_was_pressed
-
-    @classmethod
-    def run_if_first_run(cls, base, unset=False):
-        if unset:
-            conf.unset(NO_DIALOG)
-        if conf.get_bool(NO_DIALOG):
-            return True
-        app = cls()
-        return app.go(base)

=== removed file 'dmedia/gtk/menu.py'
--- dmedia/gtk/menu.py	2011-04-17 03:10:38 +0000
+++ dmedia/gtk/menu.py	1970-01-01 00:00:00 +0000
@@ -1,408 +0,0 @@
-# Authors:
-#   David Green <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-#TODO: separators, keyboard acceleration
-
-"""
-Menu declaration.
-"""
-
-
-from gi.repository import Gtk
-
-ACTIONS = {
-    "close" : Gtk.main_quit
-}
-
-
-#this could potentially be put into a .json file
-MENU = [
-    {
-        "label" : "_File",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    }
-]
-
-#A menu for testing and demonstration
-TEST_MENU = [
-{
-        "label" : "_File",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    },
-    {
-        "label" : "_Edit",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    },
-    {
-        "label" : "_View",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    },
-    {
-        "label" : "_Tools",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    },
-    {
-        "label" : "Et_c",
-        "type" : "menu",
-        "items" : [
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "menu",
-                "items" : [{
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            },
-            {
-                "type" : "custom",
-                "widget" : Gtk.SeparatorMenuItem()
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }]
-            },
-            {
-                "label" : "_Close",
-                "type" : "action",
-                "action" : "close"
-            }
-        ]
-    }
-]

=== removed file 'dmedia/gtk/service.py'
--- dmedia/gtk/service.py	2011-09-04 00:53:41 +0000
+++ dmedia/gtk/service.py	1970-01-01 00:00:00 +0000
@@ -1,302 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#   Manish SInha <[e-mail]>
-#   David Green <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-D-Bus service implementing Pro File Import UX.
-
-For details, please see:
-
-  https://wiki.ubuntu.com/AyatanaDmediaLovefest
-"""
-
-from os import path
-from gettext import gettext as _
-import logging
-from subprocess import check_call
-
-import dbus
-import dbus.service
-import dbus.mainloop.glib
-
-from dmedia import __version__
-from dmedia.constants import IMPORT_BUS, IMPORT_IFACE, EXT_MAP
-from dmedia.importer import ImportManager
-
-from .util import NotifyManager, Timer, import_started, batch_finished
-
-
-try:
-    from gi.repository import Notify
-    Notify.init('dmedia')
-except ImportError:
-    Notify = None
-
-try:
-    from gi.repository import AppIndicator3
-    from gi.repository import Gtk
-except ImportError:
-    AppIndicator3 = None
-
-log = logging.getLogger()
-
-
-ICON = 'indicator-rendermenu'
-ICON_ATT = 'indicator-rendermenu-att'
-
-
-class DMedia(dbus.service.Object):
-    __signals = frozenset([
-        'BatchStarted',
-        'BatchFinished',
-        'ImportStarted',
-        'ImportCount',
-        'ImportProgress',
-        'ImportFinished',
-    ])
-
-    def __init__(self, env, bus, killfunc):
-        assert callable(killfunc)
-        self._env = env
-        self._bus = bus
-        self._killfunc = killfunc
-        self._bus = bus
-        self._no_gui = env.get('no_gui', False)
-        log.info('Starting service on %r', self._bus)
-        self._conn = dbus.SessionBus()
-        super(DMedia, self).__init__(self._conn, object_path='/')
-        self._busname = dbus.service.BusName(self._bus, self._conn)
-
-        if self._no_gui or Notify is None:
-            self._notify = None
-        else:
-            log.info('Using `Notify`')
-            self._notify = NotifyManager()
-
-        if self._no_gui or AppIndicator3 is None:
-            self._indicator = None
-        else:
-            log.info('Using `AppIndicator3`')
-            self._indicator = AppIndicator3.Indicator.new('rendermenu', ICON,
-                AppIndicator3.IndicatorCategory.APPLICATION_STATUS
-            )
-            self._timer = Timer(2, self._on_timer)
-            self._indicator.set_attention_icon(ICON_ATT)
-            self._menu = Gtk.Menu()
-
-            self._current = Gtk.MenuItem()
-            self._menu.append(self._current)
-
-            sep = Gtk.SeparatorMenuItem()
-            self._menu.append(sep)
-
-            futon = Gtk.MenuItem()
-            futon.set_label(_('Browse DB in Futon'))
-            futon.connect('activate', self._on_futon)
-            self._menu.append(futon)
-
-            quit = Gtk.MenuItem()
-            quit.set_label(_('Shutdown dmedia'))
-            quit.connect('activate', self._on_quit)
-            self._menu.append(quit)
-
-            self._menu.show_all()
-            self._current.hide()
-            self._indicator.set_menu(self._menu)
-            self._indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
-
-        self._manager = None
-
-    @property
-    def manager(self):
-        if self._manager is None:
-            self._manager = ImportManager(self._env, self._on_signal)
-        return self._manager
-
-    def _on_signal(self, signal, args):
-        if signal in self.__signals:
-            method = getattr(self, signal)
-            method(*args)
-
-    def _on_timer(self):
-        if self._manager is None:
-            return
-        text = _('File {completed} of {total}').format(
-            **self._manager.get_batch_progress()
-        )
-        self._current.set_label(text)
-#        self._indicator.set_menu(self._menu)
-
-    def _on_quit(self, menuitem):
-        self.Kill()
-
-    def _on_futon(self, menuitem):
-        log.info('Opening dmedia database in Futon..')
-        try:
-            uri = self.metastore.get_auth_uri() + '/_utils'
-            check_call(['/usr/bin/xdg-open', uri])
-            log.info('Opened Futon')
-        except Exception:
-            log.exception('Could not open dmedia database in Futon')
-
-    @dbus.service.signal(IMPORT_IFACE, signature='s')
-    def BatchStarted(self, batch_id):
-        """
-        Fired at transition from idle to at least one active import.
-
-        For pro file import UX, the RenderMenu should be set to STATUS_ATTENTION
-        when this signal is received.
-        """
-        if self._notify:
-            self._batch = []
-        if self._indicator:
-            self._indicator.set_status(AppIndicator3.IndicatorStatus.ATTENTION)
-            self._current.show()
-            self._current.set_label(_('Searching for files...'))
-            self._indicator.set_menu(self._menu)
-            self._timer.start()
-
-    @dbus.service.signal(IMPORT_IFACE, signature='sa{sx}')
-    def BatchFinished(self, batch_id, stats):
-        """
-        Fired at transition from at least one active import to idle.
-
-        *stats* will be the combined stats of all imports in this batch.
-
-        For pro file import UX, the RenderMenu should be set back to
-        STATUS_ACTIVE, and the NotifyOSD with the aggregate import stats should
-        be displayed when this signal is received.
-        """
-        if self._indicator:
-            self._indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
-        if self._notify is None:
-            return
-        (summary, body) = batch_finished(stats)
-        self._notify.replace(summary, body, 'notification-device-eject')
-        self._timer.stop()
-        self._current.hide()
-
-    @dbus.service.signal(IMPORT_IFACE, signature='ss')
-    def ImportStarted(self, base, import_id):
-        """
-        Fired when card is inserted.
-
-        For pro file import UX, the "Searching for new files" NotifyOSD should
-        be displayed when this signal is received.  If a previous notification
-        is still visible, the two should be merge and the summary conspicuously
-        changed to be very clear that both cards were detected.
-        """
-        if self._notify is None:
-            return
-        self._batch.append(base)
-        (summary, body) = import_started(self._batch)
-        # FIXME: use correct icon depending on whether card reader is corrected
-        # via FireWire or USB
-        self._notify.replace(summary, body, 'notification-device-usb')
-
-    @dbus.service.signal(IMPORT_IFACE, signature='ssx')
-    def ImportCount(self, base, import_id, total):
-        pass
-
-    @dbus.service.signal(IMPORT_IFACE, signature='ssiia{ss}')
-    def ImportProgress(self, base, import_id, completed, total, info):
-        pass
-
-    @dbus.service.signal(IMPORT_IFACE, signature='ssa{sx}')
-    def ImportFinished(self, base, import_id, stats):
-        pass
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='', out_signature='')
-    def Kill(self):
-        """
-        Kill the dmedia service process.
-        """
-        log.info('Killing service...')
-        if self._manager is not None:
-            self._manager.kill()
-        if callable(self._killfunc):
-            log.info('Calling killfunc()')
-            self._killfunc()
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='', out_signature='s')
-    def Version(self):
-        """
-        Return dmedia version.
-        """
-        return __version__
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='as', out_signature='as')
-    def GetExtensions(self, types):
-        """
-        Get a list of extensions based on broad categories in *types*.
-
-        Currently recognized categories include ``'video'``, ``'audio'``,
-        ``'images'``, and ``'all'``.  You can safely include categories that
-        don't yet exist.
-
-        :param types: A list of general categories, e.g. ``['video', 'audio']``
-        """
-        extensions = set()
-        for key in types:
-            if key in EXT_MAP:
-                extensions.update(EXT_MAP[key])
-        return sorted(extensions)
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='sb', out_signature='s')
-    def StartImport(self, base, extract):
-        """
-        Start import of card mounted at *base*.
-
-        If *extract* is ``True``, metadata will be extracted and thumbnails
-        generated.
-
-        :param base: File-system path from which to import, e.g.
-            ``'/media/EOS_DIGITAL'``
-        :param extract: If ``True``, perform metadata extraction, thumbnail
-            generation
-        """
-        base = unicode(base)
-        if path.abspath(base) != base:
-            return 'not_abspath'
-        if not path.isdir(base):
-            return 'not_a_dir'
-        if self.manager.start_import(base, extract):
-            return 'started'
-        return 'already_running'
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='s', out_signature='s')
-    def StopImport(self, base):
-        """
-        In running, stop the import of directory or file at *base*.
-        """
-        if self.manager.kill_job(base):
-            return 'stopped'
-        return 'not_running'
-
-    @dbus.service.method(IMPORT_IFACE, in_signature='', out_signature='as')
-    def ListImports(self):
-        """
-        Return list of currently running imports.
-        """
-        if self._manager is None:
-            return []
-        return self.manager.list_jobs()

=== removed file 'dmedia/gtk/tests/test_client.py'
--- dmedia/gtk/tests/test_client.py	2011-09-06 19:38:32 +0000
+++ dmedia/gtk/tests/test_client.py	1970-01-01 00:00:00 +0000
@@ -1,284 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `dmedia.client` module.
-"""
-
-import os
-from os import path
-from subprocess import Popen
-import time
-import json
-
-import dbus
-from dbus.proxies import ProxyObject
-from gi.repository import GObject
-
-import dmedia
-from dmedia.constants import VIDEO, AUDIO, IMAGE, EXTENSIONS
-from dmedia.gtkui import client, service
-
-from dmedia.tests.helpers import TempDir, random_bus, prep_import_source
-from dmedia.tests.helpers import sample_mov, sample_thm
-from dmedia.tests.helpers import mov_hash, thm_hash
-from dmedia.tests.couch import CouchCase
-
-
-tree = path.dirname(path.dirname(path.abspath(dmedia.__file__)))
-assert path.isfile(path.join(tree, 'setup.py'))
-script = path.join(tree, 'dmedia-importer-service')
-assert path.isfile(script)
-
-
-class CaptureCallback(object):
-    def __init__(self, signal, messages):
-        self.signal = signal
-        self.messages = messages
-        self.callback = None
-
-    def __call__(self, *args):
-        self.messages.append(
-            (self.signal,) + args
-        )
-        if callable(self.callback):
-            self.callback()
-
-
-class SignalCapture(object):
-    def __init__(self, obj, *signals):
-        self.obj = obj
-        self.messages = []
-        self.handlers = {}
-        for name in signals:
-            callback = CaptureCallback(name, self.messages)
-            obj.connect(name, callback)
-            self.handlers[name] = callback
-
-
-class TestClient(CouchCase):
-    klass = client.Client
-
-    def setUp(self):
-        """
-        Launch dmedia dbus service using a random bus name.
-
-        This will launch dmedia-service with a random bus name like this:
-
-            dmedia-service --bus org.test3ISHAWZVSWVN5I5S.DMedia
-
-        How do people usually unit test dbus services?  This works, but not sure
-        if there is a better idiom in common use.  --jderose
-        """
-        self.skipTest('intermittent DBus failure')
-        super(TestClient, self).setUp()
-        self.bus = random_bus()
-        cmd = [script, '--no-gui',
-            '--bus', self.bus,
-            '--env', json.dumps(self.env),
-        ]
-        self.service = Popen(cmd)
-        time.sleep(1)  # Give dmedia-service time to start
-
-    def tearDown(self):
-        super(TestClient, self).tearDown()
-        try:
-            self.service.terminate()
-            self.service.wait()
-        except OSError:
-            pass
-        finally:
-            self.service = None
-
-    def new(self):
-        return self.klass(bus=self.bus)
-
-    def test_init(self):
-        # Test with no bus
-        inst = self.klass()
-        self.assertEqual(inst._bus, 'org.freedesktop.DMediaImporter')
-        self.assertTrue(isinstance(inst._conn, dbus.SessionBus))
-        self.assertTrue(inst._proxy is None)
-
-        # Test with random bus
-        inst = self.new()
-        self.assertEqual(inst._bus, self.bus)
-        self.assertTrue(isinstance(inst._conn, dbus.SessionBus))
-        self.assertTrue(inst._proxy is None)
-
-        # Test the proxy property
-        p = inst.proxy
-        self.assertTrue(isinstance(p, ProxyObject))
-        self.assertTrue(p is inst._proxy)
-        self.assertTrue(p is inst.proxy)
-
-        # Test version()
-        self.assertEqual(inst.version(), dmedia.__version__)
-
-        # Test get_extensions()
-        self.assertEqual(inst.get_extensions(['video']), sorted(VIDEO))
-        self.assertEqual(inst.get_extensions(['audio']), sorted(AUDIO))
-        self.assertEqual(inst.get_extensions(['image']), sorted(IMAGE))
-        self.assertEqual(inst.get_extensions(['all']), sorted(EXTENSIONS))
-        self.assertEqual(
-            inst.get_extensions(['video', 'audio']),
-            sorted(VIDEO + AUDIO)
-        )
-        self.assertEqual(
-            inst.get_extensions(['video', 'image']),
-            sorted(VIDEO + IMAGE)
-        )
-        self.assertEqual(
-            inst.get_extensions(['audio', 'image']),
-            sorted(AUDIO + IMAGE)
-        )
-        self.assertEqual(
-            inst.get_extensions(['video', 'audio', 'image']),
-            sorted(EXTENSIONS)
-        )
-        self.assertEqual(
-            inst.get_extensions(['video', 'audio', 'image', 'all']),
-            sorted(EXTENSIONS)
-        )
-        self.assertEqual(inst.get_extensions(['foo', 'bar']), [])
-
-    def test_connect(self):
-        def callback(*args):
-            pass
-
-        inst = self.new()
-        self.assertEqual(inst._proxy, None)
-        inst.connect('import_started', callback)
-        self.assertTrue(isinstance(inst._proxy, ProxyObject))
-        self.assertTrue(inst._proxy is inst.proxy)
-
-    def test_kill(self):
-        inst = self.new()
-        self.assertEqual(self.service.poll(), None)
-        inst.kill()
-        self.assertTrue(inst._proxy is None)
-        time.sleep(1)  # Give dmedia-service time to shutdown
-        self.assertEqual(self.service.poll(), 0)
-
-    def test_import(self):
-        inst = self.new()
-        signals = SignalCapture(inst,
-            'batch_started',
-            'import_started',
-            'import_count',
-            'import_progress',
-            'import_finished',
-            'batch_finished',
-        )
-        mainloop = GObject.MainLoop()
-        signals.handlers['batch_finished'].callback = mainloop.quit
-
-        tmp = TempDir()
-        base = tmp.path
-
-        # Test with relative path
-        self.assertEqual(
-            inst.start_import('some/relative/path'),
-            'not_abspath'
-        )
-        self.assertEqual(
-            inst.start_import('/media/EOS_DIGITAL/../../etc/ssh'),
-            'not_abspath'
-        )
-
-        # Test with non-dir
-        nope = tmp.join('memory_card')
-        self.assertEqual(inst.start_import(nope), 'not_a_dir')
-        nope = tmp.touch('memory_card')
-        self.assertEqual(inst.start_import(nope), 'not_a_dir')
-        os.unlink(nope)
-
-        # Test a real import
-        (src1, src2, dup1) = prep_import_source(tmp)
-        mov_size = path.getsize(sample_mov)
-        thm_size = path.getsize(sample_thm)
-        self.assertEqual(inst.list_imports(), [])
-        self.assertEqual(inst.stop_import(base), 'not_running')
-        self.assertEqual(inst.start_import(base), 'started')
-        self.assertEqual(inst.start_import(base), 'already_running')
-        self.assertEqual(inst.list_imports(), [base])
-
-        # mainloop.quit() gets called at 'batch_finished' signal
-        mainloop.run()
-
-        self.assertEqual(inst.list_imports(), [])
-        self.assertEqual(inst.stop_import(base), 'not_running')
-
-        self.assertEqual(len(signals.messages), 8)
-        batch_id = signals.messages[0][2]
-        self.assertEqual(
-            signals.messages[0],
-            ('batch_started', inst, batch_id)
-        )
-        import_id = signals.messages[1][3]
-        self.assertEqual(
-            signals.messages[1],
-            ('import_started', inst, base, import_id)
-        )
-        self.assertEqual(
-            signals.messages[2],
-            ('import_count', inst, base, import_id, 3)
-        )
-        self.assertEqual(
-            signals.messages[3],
-            ('import_progress', inst, base, import_id, 1, 3,
-                dict(action='imported', src=src1)
-            )
-        )
-        self.assertEqual(
-            signals.messages[4],
-            ('import_progress', inst, base, import_id, 2, 3,
-                dict(action='imported', src=src2)
-            )
-        )
-        self.assertEqual(
-            signals.messages[5],
-            ('import_progress', inst, base, import_id, 3, 3,
-                dict(action='skipped', src=dup1)
-            )
-        )
-        self.assertEqual(
-            signals.messages[6],
-            ('import_finished', inst, base, import_id,
-                dict(
-                    imported=2,
-                    imported_bytes=(mov_size + thm_size),
-                    skipped=1,
-                    skipped_bytes=mov_size,
-                )
-            )
-        )
-        self.assertEqual(
-            signals.messages[7],
-            ('batch_finished', inst, batch_id,
-                dict(
-                    imported=2,
-                    imported_bytes=(mov_size + thm_size),
-                    skipped=1,
-                    skipped_bytes=mov_size,
-                )
-            )
-        )

=== removed file 'dmedia/gtk/tests/test_firstrun.py'
--- dmedia/gtk/tests/test_firstrun.py	2011-03-27 08:01:30 +0000
+++ dmedia/gtk/tests/test_firstrun.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `dmedia.firstrun` module.
-"""
-
-from unittest import TestCase
-
-from dmedia.gtkui import firstrun
-
-
-class test_FirstRunGUI(TestCase):
-    klass = firstrun.FirstRunGUI
-
-    def test_init(self):
-        inst = self.klass()

=== removed file 'dmedia/gtk/tests/test_widgets.py'
--- dmedia/gtk/tests/test_widgets.py	2011-08-31 18:17:37 +0000
+++ dmedia/gtk/tests/test_widgets.py	1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `dmedia.gtkui.widgets` module.
-"""
-
-from unittest import TestCase
-
-
-from dmedia.schema import random_id
-from dmedia.gtkui import widgets
-
-
-# Test oauth tokens - don't relpace with tokens you actually use!
-# Also, don't actually use these!
-tokens = {
-    'consumer_key': 'cVMqVGDNkC',
-    'consumer_secret': 'lhpRuaFaeI',
-    'token': 'NBGPaRrdXK',
-    'token_secret': 'SGtppOobin'
-}
-
-
-class DummyRequest(object):
-    def __init__(self, uri):
-        self._uri = uri
-
-    def get_uri(self):
-        return self._uri
-
-
-class DummyPolicy(object):
-    def __init__(self):
-        self._calls = []
-
-    def ignore(self):
-        self._calls.append('ignore')
-
-    def use(self):
-        self._calls.append('use')
-
-    def download(self):
-        self._calls.append('download')
-
-
-class SignalCollector(object):
-    def __init__(self, couchview):
-        self._couchview = couchview
-        couchview.connect('play', self.on_play)
-        couchview.connect('open', self.on_open)
-        self._sigs = []
-
-    def on_play(self, cv, *args):
-        assert cv is self._couchview
-        self._sigs.append(('play',) + args)
-
-    def on_open(self, cv, *args):
-        assert cv is self._couchview
-        self._sigs.append(('open',) + args)
-
-
-class TestCouchView(TestCase):
-    klass = widgets.CouchView
-
-    def test_init(self):
-        url = 'http://localhost:40705/dmedia/'
-        netloc = 'localhost:40705'
-
-        # Test with no oauth tokens provided:
-        inst = self.klass(url)
-        self.assertEqual(inst._couch_url, url)
-        self.assertEqual(inst._couch_netloc, netloc)
-        self.assertIsNone(inst._oauth)
-
-        # Test with oauth tokens:
-        inst = self.klass(url, oauth_tokens=tokens)
-        self.assertEqual(inst._couch_url, url)
-        self.assertEqual(inst._couch_netloc, netloc)
-        self.assertIs(inst._oauth, tokens)
-
-    def test_on_nav_policy_decision(self):
-        # Method signature:
-        # CouchView_on_nav_policy_decision(view, frame, request, nav, policy)
-
-        url = 'http://localhost:40705/dmedia/'
-        inst = self.klass(url)
-        s = SignalCollector(inst)
-        p = DummyPolicy()
-
-        # Test a requset to desktopcouch
-        r = DummyRequest('http://localhost:40705/foo/bar/baz')
-        self.assertFalse(
-            inst._on_nav_policy_decision(None, None, r, None, p)
-        )
-        self.assertEqual(p._calls, [])
-        self.assertEqual(s._sigs, [])
-
-        # Test a play:foo URI
-        play = 'play:' + random_id() + '?start=17&end=69'
-        r = DummyRequest(play)
-        self.assertTrue(
-            inst._on_nav_policy_decision(None, None, r, None, p)
-        )
-        self.assertEqual(p._calls, ['ignore'])
-        self.assertEqual(s._sigs, [('play', play)])
-
-        # Test opening an external URL
-        lp = 'https://launchpad.net/dmedia'
-        r = DummyRequest(lp)
-        self.assertTrue(
-            inst._on_nav_policy_decision(None, None, r, None, p)
-        )
-        self.assertEqual(p._calls, ['ignore', 'ignore'])
-        self.assertEqual(s._sigs, [('play', play), ('open', lp)])
-
-        # Test a URI that will just be ignored, not emit a signal
-        nope = 'ftp://example.com'
-        r = DummyRequest(nope)
-        self.assertTrue(
-            inst._on_nav_policy_decision(None, None, r, None, p)
-        )
-        self.assertEqual(p._calls, ['ignore', 'ignore', 'ignore'])
-        self.assertEqual(s._sigs, [('play', play), ('open', lp)])

=== removed file 'dmedia/gtk/widgets.py'
--- dmedia/gtk/widgets.py	2011-08-31 18:17:37 +0000
+++ dmedia/gtk/widgets.py	1970-01-01 00:00:00 +0000
@@ -1,225 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#   David Green <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Custom dmedia GTK widgets, currently just `CouchView` and `BrowserMenu`.
-"""
-
-from urlparse import urlparse, parse_qsl
-
-from microfiber import _oauth_header
-from gi.repository import GObject, WebKit, Gtk
-
-from .menu import MENU, ACTIONS
-from gettext import gettext as _
-
-
-class CouchView(WebKit.WebView):
-    """
-    Transparently sign desktopcouch requests with OAuth.
-
-    desktopcouch uses OAuth to authenticate HTTP requests to CouchDB.  Well,
-    technically it can also use basic auth, but if you do this, Stuart Langridge
-    will be very cross with you!
-
-    This class wraps a ``gi.repository.WebKit.WebView`` so that you can have a
-    single web app that:
-
-        1. Can run in a browser and talk to a remote CouchDB over HTTPS with
-           basic auth
-
-        2. Can also run in embedded WebKit and talk to the local desktopcouch
-           over HTTP with OAuth
-
-    Being able to do this sort of thing transparently is a big reason why dmedia
-    and Novacut are designed the way they are.
-
-    For some background, see:
-
-        https://bugs.launchpad.net/dmedia/+bug/677697
-
-        http://oauth.net/
-
-    Special thanks to Stuart Langridge for the example code that helped get this
-    working.
-    """
-
-    __gsignals__ = {
-        'play': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [GObject.TYPE_PYOBJECT]
-        ),
-        'open': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
-            [GObject.TYPE_PYOBJECT]
-        ),
-    }
-
-    def __init__(self, couch_url, oauth_tokens=None):
-        super(CouchView, self).__init__()
-        self._couch_url = couch_url
-        self._couch_netloc = urlparse(couch_url).netloc
-        self.connect('resource-request-starting', self._on_resource_request)
-        self.connect('navigation-policy-decision-requested',
-            self._on_nav_policy_decision
-        )
-        self._oauth = oauth_tokens
-
-    def _on_nav_policy_decision(self, view, frame, request, nav, policy):
-        """
-        Handle user trying to Navigate away from current page.
-
-        Note that this will be called before `CouchView._on_resource_request()`.
-
-        The *policy* arg is a ``WebPolicyDecision`` instance.  To handle the
-        decision, call one of:
-
-            * ``WebPolicyDecision.ignore()``
-            * ``WebPolicyDecision.use()``
-            * ``WebPolicyDecision.download()``
-
-        And then return ``True``.
-
-        Otherwise, return ``False`` or ``None`` to have the WebKit default
-        behavior apply.
-        """
-        uri = request.get_uri()
-        u = urlparse(uri)
-        if u.netloc == self._couch_netloc and u.scheme in ('http', 'https'):
-            return False
-        if uri.startswith('play:'):
-            self.emit('play', uri)
-        elif u.netloc != self._couch_netloc and u.scheme in ('http', 'https'):
-            self.emit('open', uri)
-        policy.ignore()
-        return True
-
-    def _on_resource_request(self, view, frame, resource, request, response):
-        """
-        When appropriate, OAuth-sign the request prior to it being sent.
-
-        This will only sign requests on the same host and port in the URL passed
-        to `CouchView.__init__()`.
-        """
-        uri = request.get_uri()
-        u = urlparse(uri)
-        if u.scheme not in ('http', 'https'):  # Ignore data:foo requests
-            return
-        if u.netloc != self._couch_netloc:  # Dont sign requests to broader net!
-            return
-        if not self._oauth:  # OAuth info wasn't provided
-            return
-        query = dict(parse_qsl(u.query))
-        # Handle bloody CouchDB having foo.html?dbname URLs, that is
-        # a querystring which isn't of the form foo=bar
-        if u.query and not query:
-            query = {u.query: ''}
-        baseurl = ''.join([u.scheme, '://', u.netloc, u.path])
-        method = request.props.message.props.method
-        h = _oauth_header(self._oauth, method, baseurl, query)
-        for key in h:
-            request.props.message.props.request_headers.append(k, h[k])
-        
-
-class BrowserMenu(Gtk.MenuBar):
-    """
-    The BrowserMenu class creates a menubar for dmedia-gtk, the dmedia
-    media browser.
-
-    The menu argument specifies the layout of the menu as a list of menubar
-    items. Each item is a dictionary. There are 2 main types of item: action and
-    menu.
-
-    Actions are menu items that do something when clicked. The dictionary
-    for an action looks like this:
-        {
-            "label" : "text to display",
-            "type" : "action",
-            "action" : "action id"
-        }
-    The label is the text to display (eg. "Close"). The type tells BrowserMenu
-    that this item is an action not a menu. The action is a string that is looked
-    up in the actions dictionary and refers to a callback function that is executed
-    when this menu item is clicked.
-
-    Menus are submenus of the menubar. These can hold other menus and actions.
-    The dictionary for a menu looks like this:
-        {
-            "label" : "text to display",
-            "type" : "menu",
-            "items" : [item_1, item_2 ... item_n]
-        }
-    The label is the text to display (eg. "File"). The type tells BrowserMenu
-    that this item is a menu not an action. "items" is a list of other items
-    that appear in this menu.
-
-    The actions argument is a dictionary of action IDs (strings) and callback
-    functions.
-        {
-            "action1" : lambda *a: ... ,
-            "action2" : my_object.method,
-            "action3" : some_function
-        }
-
-    If menu or actions are not specified the default will be MENU and
-    ACTIONS repectively which are defined in menu.py.
-
-    In addition to the main 2 types of menu item, there is a "custom"
-    item that allows for any gtk widget to be put in the menu as long
-    as gtk itself allows for this.
-
-    The dictionary for a custom item looks like this:
-        {
-            "type" : "custom",
-            "widget" : gtk_widget
-        }
-    """
-    def __init__(self, menu=MENU, actions=ACTIONS):
-        super(BrowserMenu, self).__init__()
-        self.show()
-        self.menu = menu
-        self.actions = actions
-        self.add_items_to_menu(self, *self.make_menu(self.menu))
-
-    def add_items_to_menu(self, menu, *items):
-        for item in items:
-            menu.append(item)
-
-    def make_menu(self, menu):
-        items = []
-        for i in menu:
-            if i["type"] == "custom":
-                items.append(i["widget"]) #allows for custom widgets, eg. separators
-            else:
-                item = Gtk.MenuItem()
-                item.show()
-                item.set_property("use-underline", True) #allow keyboard nav
-                item.set_label(_(i["label"]))
-                if i["type"] == "menu":
-                    submenu = Gtk.Menu()
-                    submenu.show()
-                    self.add_items_to_menu(submenu, *self.make_menu(i["items"]))
-                    item.set_submenu(submenu)
-                elif i["type"] == "action":
-                    item.connect("activate", self.actions[i["action"]])
-                items.append(item)
-        return items
-
-

=== removed file 'dmedia/service/tests/test_api.py'
--- dmedia/service/tests/test_api.py	2011-09-16 03:35:25 +0000
+++ dmedia/service/tests/test_api.py	1970-01-01 00:00:00 +0000
@@ -1,110 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `dmedia.api` module.
-"""
-
-import os
-from os import path
-from subprocess import Popen
-import json
-import time
-
-from microfiber import NotFound
-
-import dmedia
-from dmedia.abstractcouch import get_db
-from dmedia import api
-
-from .couch import CouchCase
-from .helpers import random_bus
-
-
-tree = path.dirname(path.dirname(path.abspath(dmedia.__file__)))
-assert path.isfile(path.join(tree, 'setup.py'))
-script = path.join(tree, 'dmedia-service')
-assert path.isfile(script)
-
-
-class TestDMedia(CouchCase):
-    klass = api.DMedia
-
-    def setUp(self):
-        """
-        Launch dmedia dbus service using a random bus name.
-
-        This will launch dmedia-service with a random bus name like this:
-
-            dmedia-service --bus org.test3ISHAWZVSWVN5I5S.DMedia
-
-        How do people usually unit test dbus services?  This works, but not sure
-        if there is a better idiom in common use.  --jderose
-        """
-        super(TestDMedia, self).setUp()
-        self.bus = random_bus()
-        cmd = [script,
-            '--bus', self.bus,
-            '--env', json.dumps(self.env),
-        ]
-        self.service = Popen(cmd)
-        time.sleep(1)  # Give dmedia-service time to start
-
-    def tearDown(self):
-        super(TestDMedia, self).tearDown()
-        try:
-            self.service.terminate()
-            self.service.wait()
-        except OSError:
-            pass
-        finally:
-            self.service = None
-
-    def test_all(self):
-        inst = self.klass(self.bus)
-
-        # DMedia.Version()
-        self.assertEqual(inst.version(), dmedia.__version__)
-
-        # DMedia.GetEnv()
-        env = inst.get_env()
-        self.assertEqual(env['oauth'], self.env['oauth'])
-        self.assertEqual(env['url'], self.env['url'])
-        self.assertEqual(env['dbname'], self.env['dbname'])
-
-        # DMedia.HasApp()
-        db = get_db(self.env)
-        with self.assertRaises(NotFound) as cm:
-            db.get('app')
-        self.assertTrue(inst.has_app())
-        self.assertTrue(db.get('app')['_rev'].startswith('1-'))
-        self.assertTrue(inst.has_app())
-        self.assertTrue(db.get('app')['_rev'].startswith('1-'))
-
-        # DMedia.ListTransfers()
-        self.assertEqual(inst.list_transfers(), [])
-
-        # DMedia.Kill()
-        self.assertIsNone(self.service.poll(), None)
-        inst.kill()
-        self.assertTrue(inst._proxy is None)
-        time.sleep(1)  # Give dmedia-service time to shutdown
-        self.assertEqual(self.service.poll(), 0)

=== added file 'dmedia/service/tests/test_udisks.py'
--- dmedia/service/tests/test_udisks.py	1970-01-01 00:00:00 +0000
+++ dmedia/service/tests/test_udisks.py	2012-04-05 13:22:39 +0000
@@ -0,0 +1,183 @@
+# dmedia: dmedia hashing protocol and file layout
+# Copyright (C) 2012 Novacut Inc
+#
+# This file is part of `dmedia`.
+#
+# `dmedia` is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# `dmedia` 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 Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+"""
+Unit tests for `dmedia.service.udisks`.
+"""
+
+from unittest import TestCase
+import os
+from os import path
+import json
+
+from microfiber import random_id
+
+from dmedia.tests.base import TempDir
+from dmedia.service import udisks
+
+
+class TestFunctions(TestCase):
+    def test_major_minor(self):
+        tmp = TempDir()
+        st_dev = os.stat(tmp.dir).st_dev
+        major = os.major(st_dev)
+        minor = os.minor(st_dev)
+
+        # Test on the tmp dir:
+        self.assertEqual(udisks.major_minor(tmp.dir), (major, minor))
+
+        # Test on a subdir
+        subdir = tmp.makedirs('subdir')
+        self.assertEqual(udisks.major_minor(subdir), (major, minor))
+
+        # Test on a file
+        some_file = tmp.touch('some_file')
+        self.assertEqual(udisks.major_minor(some_file), (major, minor))
+
+        # Test on a non-existant path
+        nope = tmp.join('nope')
+        with self.assertRaises(OSError) as cm:
+            udisks.major_minor(nope)
+        self.assertEqual(cm.exception.errno, 2)
+
+    def test_usable_mount(self):
+        self.assertEqual(udisks.usable_mount(['/media/foo']), '/media/foo')
+        self.assertEqual(udisks.usable_mount(['/srv/bar']), '/srv/bar')
+
+        self.assertIsNone(udisks.usable_mount(['/media']))
+        self.assertIsNone(udisks.usable_mount(['/srv']))
+        self.assertIsNone(udisks.usable_mount(['/srv', '/media']))
+
+        self.assertEqual(
+            udisks.usable_mount(['/media/foo', '/srv/bar']),
+            '/media/foo'
+        )
+        self.assertEqual(
+            udisks.usable_mount(['/srv/bar', '/media/foo']),
+            '/srv/bar'
+        )
+        self.assertEqual(
+            udisks.usable_mount(['/', '/home', '/home/user', '/tmp', '/media/foo']),
+            '/media/foo'
+        )
+
+    def test_partition_info(self):
+        d = {
+            'DeviceSize': 16130244608, 
+            'IdType': 'vfat', 
+            'IdVersion': 'FAT32', 
+            'IdLabel': 'H4N_SD', 
+            'PartitionNumber': 1, 
+            'IdUuid': '89E3-CE4D',
+        }
+        self.assertEqual(udisks.partition_info(d),
+            {
+                'mount': None,
+                'info': {
+                    'bytes': 16130244608, 
+                    'filesystem': 'vfat', 
+                    'filesystem_version': 'FAT32', 
+                    'label': 'H4N_SD', 
+                    'number': 1, 
+                    'size': '16.1 GB', 
+                    'uuid': '89E3-CE4D'
+                },
+            }
+        ) 
+        self.assertEqual(udisks.partition_info(d, '/media/foo'),
+            {
+                'mount': '/media/foo',
+                'info': {
+                    'bytes': 16130244608, 
+                    'filesystem': 'vfat', 
+                    'filesystem_version': 'FAT32', 
+                    'label': 'H4N_SD', 
+                    'number': 1, 
+                    'size': '16.1 GB', 
+                    'uuid': '89E3-CE4D'
+                },
+            }
+        )
+
+    def test_drive_info(self):
+        d = {
+            'DeviceSize': 16134438912, 
+            'DriveConnectionInterface': 'usb', 
+            'DriveModel': 'CFUDMASD', 
+            'DeviceIsSystemInternal': False, 
+            'DriveSerial': 'AA0000000009019', 
+        }
+        self.assertEqual(udisks.drive_info(d),
+            {
+                'partitions': {},
+                'info': {
+                    'bytes': 16134438912, 
+                    'connection': 'usb', 
+                    'model': 'CFUDMASD', 
+                    'removable': True, 
+                    'serial': 'AA0000000009019', 
+                    'size': '16.1 GB', 
+                    'text': '16.1 GB Removable Drive',
+                },
+            }
+        )
+
+        d['DeviceIsSystemInternal'] = True 
+        self.assertEqual(udisks.drive_info(d),
+            {
+                'partitions': {},
+                'info': {
+                    'bytes': 16134438912, 
+                    'connection': 'usb', 
+                    'model': 'CFUDMASD', 
+                    'removable': False, 
+                    'serial': 'AA0000000009019', 
+                    'size': '16.1 GB', 
+                    'text': '16.1 GB Drive',
+                },
+            }
+        )
+
+    def test_get_filestore_id(self):
+        tmp = TempDir()
+
+        # Test when file and directory are missing
+        self.assertIsNone(udisks.get_filestore_id(tmp.dir))         
+
+        # Test when control dir exists, file missing
+        basedir = tmp.makedirs('.dmedia')
+        self.assertTrue(path.isdir(basedir))
+        self.assertIsNone(udisks.get_filestore_id(tmp.dir))
+
+        # Test when file is empty
+        store = tmp.touch('.dmedia', 'store.json')
+        self.assertTrue(path.isfile(store))
+        self.assertIsNone(udisks.get_filestore_id(tmp.dir))
+
+        # Test when correct
+        _id = random_id()
+        json.dump({'_id': _id}, open(store, 'w'))
+        self.assertEqual(udisks.get_filestore_id(tmp.dir), _id)
+
+        # Test when '_id' is missed from dict:
+        json.dump({'id': _id}, open(store, 'w'))
+        self.assertIsNone(udisks.get_filestore_id(tmp.dir)) 
+

=== added file 'dmedia/service/udisks.py'
--- dmedia/service/udisks.py	1970-01-01 00:00:00 +0000
+++ dmedia/service/udisks.py	2012-04-05 13:22:39 +0000
@@ -0,0 +1,299 @@
+# dmedia: distributed media library
+# Copyright (C) 2012 Novacut Inc
+#
+# This file is part of `dmedia`.
+#
+# `dmedia` is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# `dmedia` 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 Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+"""
+Attempts to tame the UDisks beast.
+"""
+
+import json
+import os
+from os import path
+from gettext import gettext as _
+import logging
+
+from gi.repository import GObject
+from filestore import DOTNAME
+
+from dmedia.units import bytes10
+from dmedia.service.dbus import system
+
+
+log = logging.getLogger()
+TYPE_PYOBJECT = GObject.TYPE_PYOBJECT
+
+
+def major_minor(parentdir):
+    st_dev = os.stat(parentdir).st_dev
+    return (os.major(st_dev), os.minor(st_dev))
+
+
+def usable_mount(mounts):
+    """
+    Return mount point at which Dmedia will look for file-stores.
+
+    For example:
+    
+    >>> usable_mount(['/', '/tmp']) is None
+    True
+    >>> usable_mount(['/', '/tmp', '/media/foo'])
+    '/media/foo'
+
+    """
+    for mount in mounts:
+        if mount.startswith('/media/') or mount.startswith('/srv/'):
+            return mount
+
+
+def partition_info(d, mount=None):
+    return {
+        'mount': mount,
+        'info': {
+            'label': d['IdLabel'],
+            'uuid': d['IdUuid'],
+            'bytes': d['DeviceSize'],
+            'size': bytes10(d['DeviceSize']),
+            'filesystem': d['IdType'],
+            'filesystem_version': d['IdVersion'],
+            'number': d['PartitionNumber'],
+        },
+    }
+
+
+def drive_text(d):
+    if d['DeviceIsSystemInternal']:
+        template = _('{size} Drive')
+    else:
+        template = _('{size} Removable Drive')
+    return template.format(size=bytes10(d['DeviceSize']))
+
+
+def drive_info(d):
+    return {
+        'partitions': {},
+        'info': {
+            'serial': d['DriveSerial'],
+            'bytes': d['DeviceSize'],
+            'size': bytes10(d['DeviceSize']),
+            'model': d['DriveModel'],
+            'removable': not d['DeviceIsSystemInternal'],
+            'connection': d['DriveConnectionInterface'],
+            'text': drive_text(d),
+        }
+    }
+
+
+def get_filestore_id(parentdir):
+    store = path.join(parentdir, DOTNAME, 'store.json') 
+    try:
+        return json.load(open(store, 'r'))['_id']
+    except Exception:
+        pass
+
+
+
+class Device:
+    __slots__ = ('obj', 'proxy', 'cache', 'ispartition', 'drive')
+
+    def __init__(self, obj):
+        self.obj = obj
+        self.proxy = system.get(
+            'org.freedesktop.UDisks',
+            obj,
+            'org.freedesktop.DBus.Properties'
+        )
+        self.cache = {}
+        self.ispartition = self['DeviceIsPartition']
+        if self.ispartition:
+            self.drive = self['PartitionSlave']
+        else:
+            self.drive = None
+
+    def __repr__(self):
+        return '{}({!r})'.format(self.__class__.__name__, self.obj)
+
+    def __getitem__(self, key):
+        try:
+            return self.cache[key]
+        except KeyError:
+            value = self.proxy.Get('(ss)', 'org.freedesktop.UDisks.Device', key)
+            self.cache[key] = value
+            return value
+
+    @property
+    def ismounted(self):
+        return self['DeviceIsMounted']
+
+    def get_all(self):
+        return self.proxy.GetAll('(s)', 'org.freedesktop.UDisks.Device')
+
+    def reset(self):
+        self.cache.clear()
+
+
+class UDisks(GObject.GObject):
+    __gsignals__ = {
+        'card_added': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+            [TYPE_PYOBJECT, TYPE_PYOBJECT]
+        ),
+        'card_removed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+            [TYPE_PYOBJECT, TYPE_PYOBJECT]
+        ),
+        'store_removed': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+            [TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT]
+        ),
+        'store_added': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+            [TYPE_PYOBJECT, TYPE_PYOBJECT, TYPE_PYOBJECT]
+        ),
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.devices = {}
+        self.drives = {}
+        self.cards = {}
+        self.stores = {}
+        self.proxy = system.get(
+            'org.freedesktop.UDisks',
+            '/org/freedesktop/UDisks'
+        )
+
+    def monitor(self):
+        user = path.abspath(os.environ['HOME'])
+        home = path.dirname(user)
+
+        home_p = self.find(home)
+        try:
+            user_p = self.find(user)
+        except Exception:
+            user_p = home_p
+        self.special = {
+            home: home_p,
+            user: user_p,
+        }
+        self.proxy.connect('g-signal', self.on_g_signal)
+        for obj in self.proxy.EnumerateDevices():
+            self.change_device(obj)
+
+    def find(self, parentdir):
+        """
+        Return DBus object path of partition containing *parentdir*.
+        """
+        (major, minor) = major_minor(parentdir)
+        return self.proxy.FindDeviceByMajorMinor('(xx)', major, minor)
+
+    def on_g_signal(self, proxy, sender, signal, params):
+        if signal == 'DeviceChanged':
+            self.change_device(params.unpack()[0])
+        elif signal == 'DeviceRemoved':
+            self.remove_device(params.unpack()[0])
+
+    def get_device(self, obj):
+        if obj not in self.devices:
+            self.devices[obj] = Device(obj)
+        return self.devices[obj]
+
+    def get_drive(self, obj):
+        if obj not in self.drives:
+            d = self.get_device(obj)
+            self.drives[obj] = drive_info(d)
+        return self.drives[obj]
+
+    def change_device(self, obj):
+        d = self.get_device(obj)
+        if not d.ispartition:
+            return
+        d.reset()
+        if d.ismounted:
+            mount = usable_mount(d['DeviceMountPaths'])
+            if mount is None:
+                return
+            part = partition_info(d, mount)
+            drive = self.get_drive(d.drive)
+            drive['partitions'][obj] = part
+            store_id = get_filestore_id(mount)
+            if store_id:
+                self.add_store(obj, mount, store_id)
+            elif drive['info']['removable']:
+                self.add_card(obj, mount)
+        else:
+            try:
+                del self.drives[d.drive]['partitions'][obj]
+                if not self.drives[d.drive]['partitions']:
+                    del self.drives[d.drive]
+            except KeyError:
+                pass
+            self.remove_store(obj)
+            self.remove_card(obj)
+
+    def add_card(self, obj, mount):
+        if obj in self.cards:
+            return
+        self.cards[obj] = mount
+        log.info('card_added %r %r', obj, mount)
+        self.emit('card_added', obj, mount)
+
+    def remove_card(self, obj):
+        try:
+            mount = self.cards.pop(obj)
+            log.info('card_removed %r %r', obj, mount)
+            self.emit('card_removed', obj, mount)
+        except KeyError:
+            pass
+
+    def add_store(self, obj, mount, store_id):
+        if obj in self.stores:
+            return
+        self.stores[obj] = {'parentdir': mount, 'id': store_id}
+        log.info('store_added %r %r %r', obj, mount, store_id)
+        self.emit('store_added', obj, mount, store_id)
+
+    def remove_store(self, obj):
+        try:
+            d = self.stores.pop(obj)
+            log.info('store_removed %r %r %r', obj, d['parentdir'], d['id'])
+            self.emit('store_removed', obj, d['parentdir'], d['id'])
+        except KeyError:
+            pass
+
+    def remove_device(self, obj):
+        try:
+            del self.devices[obj]
+        except KeyError:
+            pass
+
+    def get_parentdir_info(self, parentdir):
+        obj = self.find(parentdir)
+        d = self.get_device(obj)
+        return {
+            'parentdir': parentdir,
+            'partition': partition_info(d)['info'],
+            'drive': self.get_drive(d.drive)['info'],
+        }
+  
+    def json(self):
+        d = {
+            'drives': self.drives,
+            'stores': self.stores,
+            'cards': self.cards,
+            'special': self.special,
+        }
+        return json.dumps(d, sort_keys=True, indent=4)
+

=== removed directory 'dmedia/webui'
=== removed file 'dmedia/webui/__init__.py'
--- dmedia/webui/__init__.py	2011-03-28 21:55:42 +0000
+++ dmedia/webui/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Core HTML5 UI components.
-
-This is used both when running a web-accesible dmedia server, and when running
-an HTML5 UI in embedded WebKit.
-"""

=== removed file 'dmedia/webui/js.py'
--- dmedia/webui/js.py	2011-04-17 23:00:44 +0000
+++ dmedia/webui/js.py	1970-01-01 00:00:00 +0000
@@ -1,552 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Allow ``unittest.TestCase`` assert methods to be called from JavaScript.
-
-
-Example
-=======
-
-On the Python side, you will need a `JSTestCase` subclass with one or more
-test methods, something like this:
-
->>> class TestFoo(JSTestCase):
-...     js_files = (
-...         '/abs/path/to/script/foo.js',
-...         '/abs/path/to/script/test_foo.js',
-...     )
-...
-...     def test_bar(self):
-...         # 1. Optionally do something cool like initialize a Couch DB
-...         self.run_js()  # 2. Call test_bar() JavaScript function
-...         # 3. Optionally do something cool like verify changes in a Couch DB
-
-
-Your foo.js file (containing the ``bar()`` function) would look something like
-this:
-
-    ::
-
-        function bar() {
-            return 'My JS unit testing is awesome';
-        }
-
-
-And your test_foo.js file (containing the ``test_bar()`` function) would look
-something like this:
-
-    ::
-
-        py.TestFoo = {
-            test_bar: function() {
-                py.assertEqual(bar(), 'My JS unit testing is awesome');
-                py.assertNotEqual(bar(), 'My JS unit testing is lame');
-            },
-        }
-
-
-When you call, say, ``py.assertEqual()`` from your JavaScript test, the test
-harness will ``JSON.stringify()`` the arguments and forward the call to the test
-server using a synchronous XMLHttpRequest.  When the main process receives this
-request from the `ResultsApp`, the actual test is performed using
-``TestCase.assertEqual()``.
-
-All the reporting is handled by the Python unit test framework, and you get an
-overall pass/fail for the combined Python and JavaScript tests when you run:
-
-    ::
-
-        ./setup.py test
-
-
-Oh, and the tests run headless in embedded WebKit making this viable for
-automatic tests run with, say, Tarmac:
-
-    https://launchpad.net/tarmac
-
-
-Why this is Awesome
-===================
-
-You might be thinking, "Why reinvent the wheel, why not just use an existing
-JavaScript unit testing framework?"
-
-Fair enough, but the entire client side piece for this test framework is just 39
-lines of JavaScript plus a bit of JSON data that gets written automatically.
-Yet those 39 lines of JavaScript give you access to all these rich test methods:
-
-    - ``TestCase.assertTrue()``
-    - ``TestCase.assertFalse()``
-    - ``TestCase.assertEqual()``
-    - ``TestCase.assertNotEqual()``
-    - ``TestCase.assertAlmostEqual()``
-    - ``TestCase.assertNotAlmostEqual()``
-    - ``TestCase.assertGreater()``
-    - ``TestCase.assertGreaterEqual()``
-    - ``TestCase.assertLess()``
-    - ``TestCase.assertLessEqual()``
-    - ``TestCase.assertIn()``
-    - ``TestCase.assertNotIn()``
-    - ``TestCase.assertItemsEqual()``
-    - ``TestCase.assertIsNone()``
-    - ``TestCase.assertIsNotNone()``
-    - ``TestCase.assertRegexpMatches()``
-    - ``TestCase.assertNotRegexpMatches()``
-
-
-Existing JavaScript unit test frameworks don't tend to lend themselves to
-automatic testing as they typically report the results graphically in the
-browser... which is totally worthless if you want to run tests as part of an
-automatic pre-commit step.  Remember what the late, great Ian Clatworthy taught
-us: pre-commit continuous integration is 100% awesome.
-
-If this weren't enough, there are some reasons why dmedia and Novacut in
-particular benefit from this type of JavaScript testing.  Both use HTML5 user
-interfaces that do everything, and I mean *everything*, by talking directly to
-CouchDB with XMLHttpRequest.  The supporting core JavaScript needs to be very
-solid to enable great user experiences to be built atop.
-
-Considering the importance of these code paths, it's very handy to do setup from
-Python before calling `JSTestCase.run_js()`... for example, putting a CouchDB
-database into a known state.  Likewise, it's very handy to do out-of-band checks
-from Python after `JSTestCase.run_js()` completes... for example, verifying that
-the expected changes were made to the CouchDB  database.
-
-
-How it Works
-============
-
-When you call `JSTestCase.run_js()`, the following happens:
-
-    1. The correct HTML and JavaScript for the test are prepared
-
-    2. The `ResultsApp` is fired up in a ``multiprocessing.Process``
-
-    3. The ``dummy-client`` script is launched using ``subprocess.Popen()``
-
-    4. The ``dummy-client`` requests the HTML and JavaScript from the
-       `ResultsApp`
-
-    5. The ``dummy-client`` executes the ``py.run()`` JavaScript function and
-       posts the results to the `ResultsApp` as the test runs
-
-    6. The `ResultsApp` puts the results in a ``multiprocessing.Queue`` as it
-       receives them
-
-    7. In the main process, `JSTestCase.collect_results()` gets results from the
-       queue and tests the assertions till the test completes, an exception is
-       raised, or the 5 second timeout is exceeded
-
-    8. The `JSTestCase.tearDown()` method terminates the ``dummy-client`` and
-       `ResultsApp` processes
-
-
-FIXME:
-
-    1. Need to be able to supply arbitrary files to ResultsApp so tests can GET
-       these files... this is especially important for testing on binary data,
-       which we can't directly make available to JavaScript.  We can borrow code
-       from test-server.py, which already makes this totally generic.
-"""
-
-
-from unittest import TestCase
-import sys
-from os import path
-from subprocess import Popen
-import multiprocessing
-from Queue import Empty
-from wsgiref.simple_server import make_server
-import json
-from textwrap import dedent
-
-from genshi.template import MarkupTemplate
-
-from .util import render_var
-
-
-tree = path.dirname(path.dirname(path.dirname(path.abspath(__file__))))
-if path.exists(path.join(tree, 'setup.py')):
-    dummy_client = path.join(tree, 'dummy-client')
-else:
-    dummy_client = path.join(sys.prefix, 'lib', 'dmedia', 'dummy-client')
-assert path.isfile(dummy_client)
-
-
-def read_input(environ):
-    try:
-        length = int(environ.get('CONTENT_LENGTH', '0'))
-    except ValueError:
-        return ''
-    return environ['wsgi.input'].read(length)
-
-
-class ResultsApp(object):
-    """
-    Simple WSGI app for collecting results from JavaScript tests.
-
-    REST API
-    ========
-
-    To retrieve the test HTML page (will have appropriate JavaScript):
-
-        ::
-
-            GET / HTTP/1.1
-
-    To retrieve a JavaScript file:
-
-        ::
-
-            GET /scripts/foo.js HTTP/1.1
-
-    To test an assertion (assertEqual, assertTrue, etc):
-
-        ::
-
-            POST /assert HTTP/1.1
-            Content-Type: application/json
-
-            {"method": "assertEqual", "args": ["foo", "bar"]}
-
-    To report an unhandled exception:
-
-        ::
-
-            POST /error HTTP/1.1
-            Content-Type: application/json
-
-            "Oh no, caught an unhandled JavaScript exception!"
-
-    Finally, to conclude a test:
-
-        ::
-
-            POST /complete HTTP/1.1
-    """
-    def __init__(self, q, scripts, index, mime='text/html'):
-        self.q = q
-        self.scripts = scripts
-        self.index = index
-        self.mime = mime
-
-    def __call__(self, environ, start_response):
-        method = environ['REQUEST_METHOD']
-        if method not in ('GET', 'POST'):
-            self.q.put(('bad_method', method))
-            start_response('405 Method Not Allowed', [])
-            return ''
-        path_info = environ['PATH_INFO']
-        if method == 'GET':
-            if path_info == '/':
-                headers = [
-                    ('Content-Type', self.mime),
-                    ('Content-Length', str(len(self.index))),
-                ]
-                self.q.put(('get', path_info))
-                start_response('200 OK', headers)
-                return self.index
-            s = '/scripts/'
-            if path_info.startswith(s):
-                name = path_info[len(s):]
-                if name in self.scripts:
-                    script = self.scripts[name]
-                    headers = [
-                        ('Content-Type', 'application/javascript'),
-                        ('Content-Length', str(len(script))),
-                    ]
-                    self.q.put(('get', path_info))
-                    start_response('200 OK', headers)
-                    return script
-            self.q.put(('not_found', path_info))
-            start_response('404 Not Found', [])
-            return ''
-        if method == 'POST':
-            if path_info == '/assert':
-                content = read_input(environ)
-                self.q.put(('assert', content))
-                start_response('202 Accepted', [])
-                return ''
-            if path_info == '/error':
-                content = read_input(environ)
-                self.q.put(('error', content))
-                start_response('202 Accepted', [])
-                return ''
-            if path_info == '/complete':
-                self.q.put(('complete', None))
-                start_response('202 Accepted', [])
-                return ''
-        self.q.put(
-            ('bad_request', '%(REQUEST_METHOD)s %(PATH_INFO)s' % environ)
-        )
-        start_response('400 Bad Request', [])
-        return ''
-
-
-def results_server(q, scripts, index, mime):
-    """
-    Start HTTP server with `ResponseApp`.
-
-    This function is the target of a ``multiprocessing.Process`` when the
-    response server is started by `JSTestCase.start_results_server()`.
-
-    :param q: a ``multiprocessing.Queue`` used to send results to main process
-    :param scripts: a ``dict`` mapping script names to script content
-    :param index: the HTML/XHTML to send to client
-    :param mime: the content-type of the index page, eg ``'text/html'``
-    """
-    app = ResultsApp(q, scripts, index, mime)
-    httpd = make_server('', 8000, app)
-    httpd.serve_forever()
-
-
-class JavaScriptError(StandardError):
-    pass
-
-
-class JavaScriptTimeout(StandardError):
-    pass
-
-
-class InvalidTestMethod(StandardError):
-    pass
-
-# unittest.TestCase methods that we allow to be called from JavaScript
-METHODS = (
-    'assertTrue',
-    'assertFalse',
-
-    'assertEqual',
-    'assertNotEqual',
-    'assertAlmostEqual',
-    'assertNotAlmostEqual',
-
-    'assertGreater',
-    'assertGreaterEqual',
-    'assertLess',
-    'assertLessEqual',
-
-    'assertIn',
-    'assertNotIn',
-    'assertItemsEqual',
-
-    'assertIsNone',
-    'assertIsNotNone',
-
-    'assertRegexpMatches',
-    'assertNotRegexpMatches',
-)
-
-
-class JSTestCase(TestCase):
-    js_files = tuple()
-    q = None
-    server = None
-    client = None
-
-    template = """
-    <html
-        xmlns="http://www.w3.org/1999/xhtml"
-        xmlns:py="http://genshi.edgewall.org/"
-    >
-    <head>
-    <title py:content="title" />
-    <script py:content="js_inline" type="text/javascript" />
-    <script
-        py:for="link in js_links"
-        type="text/javascript"
-        src="${link}"
-    />
-    </head>
-    <body onload="py.run()">
-    <div id="example" />
-    </body>
-    </html>
-    """
-
-    # The entire client-side test harness is only 39 lines of JavaScript!
-    #
-    # Note that py.data is dynamically written by JSTestCase.build_js_inline(),
-    # and that this JavaScript will be inline in the first <script> tag in the
-    # test HTML/XHTML page.
-    #
-    # The JavaScript files containing implementation and tests will follow in
-    # the order they were defined in the JSTestClass.js_files subclass
-    # attribute.
-    javascript = """
-    var py = {
-        /* Synchronously POST results to ResultsApp */
-        post: function(path, obj) {
-            var request = new XMLHttpRequest();
-            request.open('POST', path, false);
-            if (obj) {
-                request.setRequestHeader('Content-Type', 'application/json');
-                request.send(JSON.stringify(obj));
-            }
-            else {
-                request.send();
-            }
-        },
-
-        /* Initialize the py.assertFoo() functions */
-        init: function() {
-            py.data.assertMethods.forEach(function(name) {
-                py[name] = function() {
-                    var args = Array.prototype.slice.call(arguments);
-                    py.post('/assert', {method: name, args: args});
-                };
-            });
-        },
-
-        /* Run the test function indicated by py.data.methodName */
-        run: function() {
-            try {
-                py.init();
-                var className = py.data.className;
-                var obj = py[className];
-                if (!obj) {
-                    py.post('/error',
-                        'Missing class ' + ['py', className].join('.')
-                    );
-                }
-                else {
-                    var methodName = py.data.methodName;
-                    var method = obj[methodName];
-                    if (!method) {
-                        py.post('/error',
-                            'Missing method ' + ['py', className, methodName].join('.')
-                        );
-                    }
-                    else {
-                        method();
-                    }
-                }
-            }
-            catch (e) {
-                py.post('/error', e);
-            }
-            finally {
-                py.post('/complete');
-            }
-        },
-    };
-    """
-
-    @classmethod
-    def setUpClass(cls):
-        cls.template = dedent(cls.template).strip()
-        cls.template_t = MarkupTemplate(cls.template)
-        cls.javascript = dedent(cls.javascript).strip()
-        cls.scripts = tuple(cls.load_scripts())
-        cls.js_links = tuple(
-            '/scripts/' + name for (name, script) in cls.scripts
-        )
-
-    @classmethod
-    def load_scripts(cls):
-        for filename in cls.js_files:
-            yield (
-                path.basename(filename),
-                open(filename, 'rb').read()
-            )
-
-    def setUp(self):
-        self.title = '%s.%s' % (self.__class__.__name__, self._testMethodName)
-        self.q = multiprocessing.Queue()
-        self.messages = []
-
-    def run_js(self, **extra):
-        index = self.build_page(**extra)
-        self.start_results_server(dict(self.scripts), index)
-        self.start_dummy_client()
-        self.collect_results()
-
-    def build_data(self, **extra):
-        data = {
-            'className': self.__class__.__name__,
-            'methodName': self._testMethodName,
-            'assertMethods': METHODS,
-        }
-        data.update(extra)
-        return data
-
-    def build_js_inline(self, **extra):
-        data = self.build_data(**extra)
-        return '\n'.join([self.javascript, render_var('py.data', data, 4)])
-
-    def render(self, **kw):
-        return self.template_t.generate(**kw).render('xhtml', doctype='html5')
-
-    def build_page(self, **extra):
-        kw = dict(
-            title=self.title,
-            js_inline=self.build_js_inline(**extra),
-            js_links=self.js_links,
-        )
-        return self.render(**kw)
-
-    def start_results_server(self, scripts, index, mime='text/html'):
-        self.server = multiprocessing.Process(
-            target=results_server,
-            args=(self.q, scripts, index, mime),
-        )
-        self.server.daemon = True
-        self.server.start()
-
-    def start_dummy_client(self):
-        cmd = [dummy_client, 'http://localhost:8000/']
-        self.client = Popen(cmd)
-
-    def collect_results(self, timeout=5):
-        while True:
-            try:
-                (action, data) = self.q.get(timeout=timeout)
-                self.messages.append((action, data))
-            except Empty:
-                raise JavaScriptTimeout()
-            self.assertIn(
-                action,
-                ['get', 'not_found', 'assert', 'error', 'complete']
-            )
-            # Note that no action is taken for 'get' and 'not_found'.
-            # 'not_found' is allowed because of things like GET /favicon.ico
-            if action == 'error':
-                raise JavaScriptError(data)
-            if action == 'complete':
-                break
-            if action == 'assert':
-                d = json.loads(data)
-                if d['method'] not in METHODS:
-                    raise InvalidTestMethod(data)
-                method = getattr(self, d['method'])
-                method(*d['args'])
-
-    def tearDown(self):
-        if self.server is not None:
-            self.server.terminate()
-            self.server.join()
-        self.server = None
-        self.q = None
-        if self.client is not None:
-            self.client.terminate()
-            self.client.wait()
-        self.client = None

=== removed directory 'dmedia/webui/tests'
=== removed file 'dmedia/webui/tests/__init__.py'
--- dmedia/webui/tests/__init__.py	2011-03-26 06:53:57 +0000
+++ dmedia/webui/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for the `dmedia.webui` package.
-"""

=== removed file 'dmedia/webui/tests/test_basejs.py'
--- dmedia/webui/tests/test_basejs.py	2011-04-17 22:44:52 +0000
+++ dmedia/webui/tests/test_basejs.py	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Test the base.js JavaScript.
-"""
-
-from dmedia.webui.js import JSTestCase
-from dmedia.webui.util import datafile
-
-class TestFunctions(JSTestCase):
-    js_files = (
-        datafile('base.js'),
-        datafile('test_base.js'),
-    )
-
-    def test_dollar(self):
-        """
-        Test the $() JavaScript function.
-        """
-        self.run_js()
-
-    def test_dollar_el(self):
-        """
-        Test the $el() JavaScript function.
-        """
-        self.run_js()
-
-    def test_dollar_replace(self):
-        """
-        Test the $replace() JavaScript function.
-        """
-        self.run_js()
-
-    def test_dollar_hide(self):
-        """
-        Test the $hide() JavaScript function.
-        """
-        self.run_js()
-
-    def test_dollar_show(self):
-        """
-        Test the $show() JavaScript function.
-        """
-        self.run_js()
-
-    def test_minsec(self):
-        self.run_js()
-
-    def test_todata(self):
-        self.run_js()

=== removed file 'dmedia/webui/tests/test_browserjs.py'
--- dmedia/webui/tests/test_browserjs.py	2011-04-13 05:03:16 +0000
+++ dmedia/webui/tests/test_browserjs.py	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Test the browser.js JavaScript.
-"""
-
-from dmedia.webui.js import JSTestCase
-from dmedia.webui.util import datafile
-
-class TestBrowser(JSTestCase):
-    js_files = (
-        datafile('couch.js'),
-        datafile('base.js'),
-        datafile('browser.js'),
-        datafile('test_browser.js'),
-    )
-
-    def test_init(self):
-        self.run_js()

=== removed file 'dmedia/webui/tests/test_couchjs.py'
--- dmedia/webui/tests/test_couchjs.py	2011-04-18 02:57:38 +0000
+++ dmedia/webui/tests/test_couchjs.py	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2011 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Test the couch.js JavaScript.
-"""
-
-from dmedia.webui.js import JSTestCase
-from dmedia.webui.util import datafile
-
-
-class TestCouchRequest(JSTestCase):
-    js_files = (
-        datafile('couch.js'),
-        datafile('test_couch.js'),
-    )
-
-    def test_request(self):
-        self.run_js()
-
-    def test_async_request(self):
-        self.run_js()
-
-
-class TestCouchBase(JSTestCase):
-    js_files = (
-        datafile('couch.js'),
-        datafile('test_couch.js'),
-    )
-
-    def test_init(self):
-        self.run_js()
-
-    def test_path(self):
-        self.run_js()
-
-    def test_request(self):
-        self.run_js()
-
-    def test_async_request(self):
-        self.run_js()
-
-    def test_post(self):
-        self.run_js()
-
-    def test_put(self):
-        self.run_js()
-
-    def test_get(self):
-        self.run_js()
-
-    def test_delete(self):
-        self.run_js()
-
-
-class TestServer(JSTestCase):
-    js_files = (
-        datafile('couch.js'),
-        datafile('test_couch.js'),
-    )
-
-    def test_database(self):
-        self.run_js()
-
-
-class TestDatabase(JSTestCase):
-    js_files = (
-        datafile('couch.js'),
-        datafile('test_couch.js'),
-    )
-
-    def test_save(self):
-        self.run_js()
-
-    def test_bulksave(self):
-        self.run_js()
-
-    def test_view(self):
-        self.run_js()

=== removed file 'dmedia/webui/tests/test_js.py'
--- dmedia/webui/tests/test_js.py	2011-04-17 22:04:38 +0000
+++ dmedia/webui/tests/test_js.py	1970-01-01 00:00:00 +0000
@@ -1,491 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-#
-# dmedia: distributed media library
-# Copyright (C) 2010 Jason Gerard DeRose <[e-mail]>
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` 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 Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Unit tests for `base.js` module.
-"""
-
-from unittest import TestCase
-import json
-import subprocess
-import time
-import multiprocessing
-import multiprocessing.queues
-
-from dmedia.webui import js
-from dmedia.webui.util import datafile, load_data
-from dmedia.tests.helpers import DummyQueue, raises
-
-
-class StartResponse(object):
-    status = None
-    headers = None
-
-    def __call__(self, status, headers):
-        assert self.status is None
-        assert self.headers is None
-        self.status = status
-        self.headers = headers
-
-
-class Input(object):
-    def __init__(self, content):
-        self.content = content
-
-    def read(self, length):
-        return self.content
-
-
-class test_ResultsApp(TestCase):
-    klass = js.ResultsApp
-
-    def test_init(self):
-        q = DummyQueue()
-        scripts = {
-            'mootools.js': 'here be mootools',
-            'base.js': 'here be dmedia',
-        }
-        index = 'foo'
-        inst = self.klass(q, scripts, index)
-        self.assertTrue(inst.q is q)
-        self.assertTrue(inst.scripts is scripts)
-        self.assertTrue(inst.index is index)
-        self.assertEqual(inst.mime, 'text/html')
-
-        inst = self.klass(q, scripts, index, mime='application/xhtml+xml')
-        self.assertTrue(inst.q is q)
-        self.assertTrue(inst.scripts is scripts)
-        self.assertTrue(inst.index is index)
-        self.assertEqual(inst.mime, 'application/xhtml+xml')
-
-    def test_call(self):
-        q = DummyQueue()
-        scripts = {
-            'mootools.js': 'here be mootools',
-            'base.js': 'here be dmedia',
-        }
-        index = 'foo bar'
-        inst = self.klass(q, scripts, index)
-
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), 'foo bar')
-        self.assertEqual(sr.status, '200 OK')
-        self.assertEqual(
-            sr.headers,
-            [
-                ('Content-Type', 'text/html'),
-                ('Content-Length', '7'),
-            ]
-        )
-        self.assertEqual(q.messages, [('get', '/')])
-
-        post1 = json.dumps({'args': ('one', 'two'), 'method': 'assertEqual'})
-        env = {
-            'REQUEST_METHOD': 'POST',
-            'PATH_INFO': '/assert',
-            'wsgi.input': Input(post1),
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '202 Accepted')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            q.messages,
-            [
-                ('get', '/'),
-                ('assert', post1),
-            ]
-        )
-
-        post2 = 'oh no, it no worky!'
-        env = {
-            'REQUEST_METHOD': 'POST',
-            'PATH_INFO': '/error',
-            'wsgi.input': Input(post2),
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '202 Accepted')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            q.messages,
-            [
-                ('get', '/'),
-                ('assert', post1),
-                ('error', post2),
-            ]
-        )
-
-        env = {
-            'REQUEST_METHOD': 'POST',
-            'PATH_INFO': '/complete',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '202 Accepted')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            q.messages,
-            [
-                ('get', '/'),
-                ('assert', post1),
-                ('error', post2),
-                ('complete', None),
-            ]
-        )
-
-        # Test with bad requests
-        q = DummyQueue()
-        index = 'foo bar'
-        inst = self.klass(q, scripts, index)
-        env = {'REQUEST_METHOD': 'PUT'}
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '405 Method Not Allowed')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(q.messages, [('bad_method', 'PUT')])
-
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/error',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '404 Not Found')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            q.messages,
-            [
-                ('bad_method', 'PUT'),
-                ('not_found', '/error'),
-            ]
-        )
-
-        env = {
-            'REQUEST_METHOD': 'POST',
-            'PATH_INFO': '/nope',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '400 Bad Request')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            q.messages,
-            [
-                ('bad_method', 'PUT'),
-                ('not_found', '/error'),
-                ('bad_request', 'POST /nope'),
-            ]
-        )
-
-        # Test script reqests
-        q = DummyQueue()
-        index = 'foo bar'
-        inst = self.klass(q, scripts, index)
-
-        # /scripts/mootools.js
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/scripts/mootools.js',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), 'here be mootools')
-        self.assertEqual(sr.status, '200 OK')
-        self.assertEqual(
-            sr.headers,
-            [
-                ('Content-Type', 'application/javascript'),
-                ('Content-Length', '16'),
-            ]
-        )
-        self.assertEqual(inst.q.messages, [('get', '/scripts/mootools.js')])
-
-        # /scripts/base.js
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/scripts/base.js',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), 'here be dmedia')
-        self.assertEqual(sr.status, '200 OK')
-        self.assertEqual(
-            sr.headers,
-            [
-                ('Content-Type', 'application/javascript'),
-                ('Content-Length', '14'),
-            ]
-        )
-        self.assertEqual(
-            inst.q.messages,
-            [
-                ('get', '/scripts/mootools.js'),
-                ('get', '/scripts/base.js'),
-            ]
-        )
-
-        # /scripts/foo.js
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/scripts/foo.js',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '404 Not Found')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            inst.q.messages,
-            [
-                ('get', '/scripts/mootools.js'),
-                ('get', '/scripts/base.js'),
-                ('not_found', '/scripts/foo.js'),
-            ]
-        )
-
-        # /mootools.js
-        env = {
-            'REQUEST_METHOD': 'GET',
-            'PATH_INFO': '/mootools.js',
-        }
-        sr = StartResponse()
-        self.assertEqual(inst(env, sr), '')
-        self.assertEqual(sr.status, '404 Not Found')
-        self.assertEqual(sr.headers, [])
-        self.assertEqual(
-            inst.q.messages,
-            [
-                ('get', '/scripts/mootools.js'),
-                ('get', '/scripts/base.js'),
-                ('not_found', '/scripts/foo.js'),
-                ('not_found', '/mootools.js'),
-            ]
-        )
-
-
-expected = """
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<title>Hello Naughty Nurse!</title>
-<script type="text/javascript">var foo = "bar";</script>
-<script type="text/javascript" src="/scripts/base.js"></script>
-</head>
-<body onload="py.run()">
-<div id="example"></div>
-</body>
-</html>
-""".strip()
-
-
-class test_JSTestCase(js.JSTestCase):
-
-    def test_load_scripts(self):
-        klass = self.__class__
-        self.assertEqual(list(klass.load_scripts()), [])
-        klass.js_files = (
-            datafile('browser.js'),
-            datafile('base.js'),
-        )
-        self.assertEqual(
-            list(klass.load_scripts()),
-            [
-                ('browser.js', load_data(datafile('browser.js'))),
-                ('base.js', load_data(datafile('base.js'))),
-            ]
-        )
-
-    def test_start_results_server(self):
-        self.assertEqual(
-            self.title, 'test_JSTestCase.test_start_results_server'
-        )
-        self.start_results_server({}, 'foo bar')
-        self.assertTrue(isinstance(self.q, multiprocessing.queues.Queue))
-        self.assertTrue(isinstance(self.server, multiprocessing.Process))
-        time.sleep(1)
-        self.assertTrue(self.server.daemon)
-        self.assertTrue(self.server.is_alive())
-        self.assertEqual(
-            self.server._args,
-            (self.q, {}, 'foo bar', 'text/html')
-        )
-        self.assertEqual(self.server._kwargs, {})
-        self.server.terminate()
-        self.server.join()
-
-    def test_start_dummy_client(self):
-        self.assertEqual(
-            self.title, 'test_JSTestCase.test_start_dummy_client'