diff --git a/swh/web/ui/api.py b/swh/web/ui/api.py
index 4ec71d55..497983e5 100644
--- a/swh/web/ui/api.py
+++ b/swh/web/ui/api.py
@@ -1,305 +1,306 @@
 # Copyright (C) 2015  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from flask import request, url_for
 
 from flask.ext.api.decorators import set_renderers
 
 from swh.web.ui.main import app
 from swh.web.ui import service, renderers, utils
 from swh.web.ui.exc import BadInputExc, NotFoundExc
 
 
 @app.route('/browse/')
 def api_browse_endpoints():
     """List the current api endpoints starting with /api or /api/.
 
     Returns:
         List of endpoints at /api
 
     """
     return utils.filter_endpoints(app.url_map, '/browse')
 
 
 @app.route('/api/')
 def api_main_endpoints():
     """List the current api endpoints starting with /api or /api/.
 
     Returns:
         List of endpoints at /api
 
     """
     return utils.filter_endpoints(app.url_map, '/api')
 
 
 @app.route('/api/1/')
 def api_main_v1_endpoints():
     """List the current api v1 endpoints starting with /api/1 or /api/1/.
 
     Returns:
         List of endpoints at /api/1
 
     """
     return utils.filter_endpoints(app.url_map, '/api/1')
 
 
 @app.route('/api/1/stat/counters/')
 def api_stats():
     """Return statistics on SWH storage.
 
     Returns:
         SWH storage's statistics
 
     """
     return service.stat_counters()
 
 
 @app.route('/api/1/search/<string:q>/')
 def api_search(q):
     """Search a content per hash.
 
     Args:
         q is of the form algo_hash:hash with algo_hash in
         (sha1, sha1_git, sha256)
 
     Returns:
         Dictionary with 'found' key and the associated result.
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
 
     """
     r = service.lookup_hash(q).get('found')
     return {'found': True if r else False}
 
 
 def _api_lookup(criteria, lookup_fn, error_msg_if_not_found):
     """Factorize function regarding the api to lookup for data."""
     res = lookup_fn(criteria)
     if not res:
         raise NotFoundExc(error_msg_if_not_found)
     if isinstance(res, map):
         return list(res)
     return res
 
 
 @app.route('/api/1/origin/<int:origin_id>/')
 def api_origin(origin_id):
     """Return information about origin with id origin_id.
 
 
     Args:
         origin_id: the origin's identifier
 
     Returns:
         Information on the origin if found.
 
     Raises:
         NotFoundExc if the origin is not found.
 
     """
     return _api_lookup(
         origin_id, lookup_fn=service.lookup_origin,
         error_msg_if_not_found='Origin with id %s not found.' % origin_id)
 
 
 @app.route('/api/1/person/<int:person_id>/')
 def api_person(person_id):
     """Return information about person with identifier person_id.
 
     Args:
         person_id: the person's identifier
 
     Returns:
         Information on the person if found.
 
     Raises:
         NotFoundExc if the person is not found.
 
     """
     return _api_lookup(
         person_id, lookup_fn=service.lookup_person,
         error_msg_if_not_found='Person with id %s not found.' % person_id)
 
 
 @app.route('/api/1/release/<string:sha1_git>/')
 def api_release(sha1_git):
     """Return information about release with id sha1_git.
 
     Args:
         sha1_git: the release's hash
 
     Returns:
         Information on the release if found.
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
         NotFoundExc if the release is not found.
 
     """
     error_msg = 'Release with sha1_git %s not found.' % sha1_git
     return _api_lookup(
         sha1_git,
         lookup_fn=service.lookup_release,
         error_msg_if_not_found=error_msg)
 
 
 @app.route('/api/1/revision/<string:sha1_git>/')
 def api_revision(sha1_git):
     """Return information about revision with id sha1_git.
 
     Args:
         sha1_git: the revision's hash
 
     Returns:
         Information on the revision if found.
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
         NotFoundExc if the revision is not found.
 
     """
     error_msg = 'Revision with sha1_git %s not found.' % sha1_git
     return _api_lookup(
         sha1_git,
         lookup_fn=service.lookup_revision,
         error_msg_if_not_found=error_msg)
 
 
 @app.route('/api/1/revision/<string:sha1_git>/log/')
 def api_revision_log(sha1_git):
     """Return information about revision with id sha1_git.
 
     Args:
         sha1_git: the revision's hash
 
     Returns:
         Information on the revision if found.
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
         NotFoundExc if the revision is not found.
 
     """
     error_msg = 'Revision with sha1_git %s not found.' % sha1_git
     return _api_lookup(
         sha1_git,
         lookup_fn=service.lookup_revision_log,
         error_msg_if_not_found=error_msg)
 
 
 @app.route('/api/1/directory/<string:sha1_git>/')
 def api_directory(sha1_git):
     """Return information about release with id sha1_git.
 
     Args:
         Directory's sha1_git
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
         NotFoundExc if the content is not found.
 
     """
-    directory_entries = service.lookup_directory(sha1_git)
-    if not directory_entries:
-        raise NotFoundExc('Directory with sha1_git %s not found.' % sha1_git)
-    return list(directory_entries)
+    error_msg = 'Directory with sha1_git %s not found.' % sha1_git
+    return _api_lookup(
+        sha1_git,
+        lookup_fn=service.lookup_directory,
+        error_msg_if_not_found=error_msg)
 
 
 @app.route('/api/1/browse/<string:q>/')
 def api_content_checksum_to_origin(q):
     """Return content information up to one of its origin if the content
     is found.
 
     Args:
         q is of the form algo_hash:hash with algo_hash in
         (sha1, sha1_git, sha256)
 
     Returns:
         Information on one possible origin for such content.
 
     Raises:
         BadInputExc in case of unknown algo_hash or bad hash
         NotFoundExc if the content is not found.
 
     """
     found = service.lookup_hash(q)['found']
     if not found:
         raise NotFoundExc('Content with %s not found.' % q)
 
     return service.lookup_hash_origin(q)
 
 
 @app.route('/api/1/content/<string:q>/raw/')
 @set_renderers(renderers.BytesRenderer)
 def api_content_raw(q):
     """Return content's raw data if content is found.
 
     Args:
         q is of the form (algo_hash:)hash with algo_hash in
         (sha1, sha1_git, sha256).
         When algo_hash is not provided, 'hash' is considered sha1.
 
     Returns:
         Content's raw data in text/plain.
 
     Raises:
         - BadInputExc in case of unknown algo_hash or bad hash
         - NotFoundExc if the content is not found.
 
     """
     content = service.lookup_content_raw(q)
     if not content:
         raise NotFoundExc('Content with %s not found.' % q)
 
     return content['data']
 
 
 @app.route('/api/1/content/<string:q>/')
 def api_content_with_details(q):
     """Return content information if content is found.
 
     Args:
         q is of the form (algo_hash:)hash with algo_hash in
         (sha1, sha1_git, sha256).
         When algo_hash is not provided, 'hash' is considered sha1.
 
     Returns:
         Content's information.
 
     Raises:
         - BadInputExc in case of unknown algo_hash or bad hash
         - NotFoundExc if the content is not found.
 
     """
     content = service.lookup_content(q)
     if not content:
         raise NotFoundExc('Content with %s not found.' % q)
 
     content['data'] = url_for('api_content_raw', q=content['sha1'])
     return content
 
 
 @app.route('/api/1/uploadnsearch/', methods=['POST'])
 def api_uploadnsearch():
     """Upload the file's content in the post body request.
        Compute its hash and determine if it exists in the storage.
 
     Args:
         request.files filled with the filename's data to upload.
 
     Returns:
         Dictionary with 'sha1', 'filename' and 'found' predicate depending
         on whether we find it or not.
 
     Raises:
         BadInputExc in case of the form submitted is incorrect.
 
     """
     file = request.files.get('filename')
     if not file:
         raise BadInputExc('Bad request, missing \'filename\' entry in form.')
 
     return service.upload_and_search(file)
diff --git a/swh/web/ui/service.py b/swh/web/ui/service.py
index b1f4c038..79fe96bd 100644
--- a/swh/web/ui/service.py
+++ b/swh/web/ui/service.py
@@ -1,246 +1,243 @@
 # Copyright (C) 2015  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 
 from swh.core import hashutil
 from swh.web.ui import converters, main, query, upload
 from swh.web.ui.exc import BadInputExc
 
 
 def hash_and_search(filepath):
     """Hash the filepath's content as sha1, then search in storage if
     it exists.
 
     Args:
         Filepath of the file to hash and search.
 
     Returns:
         Tuple (hex sha1, found as True or false).
         The found boolean, according to whether the sha1 of the file
         is present or not.
     """
     h = hashutil.hashfile(filepath)
     c = main.storage().content_find(h)
     if c:
         r = converters.from_content(c)
         r['found'] = True
         return r
     else:
         return {'sha1': hashutil.hash_to_hex(h['sha1']),
                 'found': False}
 
 
 def upload_and_search(file):
     """Upload a file and compute its hash.
 
     """
     tmpdir, filename, filepath = upload.save_in_upload_folder(file)
     res = {'filename': filename}
     try:
         content = hash_and_search(filepath)
         res.update(content)
         return res
     finally:
         # clean up
         if tmpdir:
             upload.cleanup(tmpdir)
 
 
 def lookup_hash(q):
     """Checks if the storage contains a given content checksum
 
     Args: query string of the form <hash_algo:hash>
 
     Returns: Dict with key found to True or False, according to
         whether the checksum is present or not
 
     """
     (algo, hash) = query.parse_hash(q)
     found = main.storage().content_find({algo: hash})
     return {'found': found,
             'algo': algo}
 
 
 def lookup_hash_origin(q):
     """Return information about the checksum contained in the query q.
 
     Args: query string of the form <hash_algo:hash>
 
     Returns:
         origin as dictionary if found for the given content.
 
     """
     algo, h = query.parse_hash(q)
     origin = main.storage().content_find_occurrence({algo: h})
     return converters.from_origin(origin)
 
 
 def lookup_origin(origin_id):
     """Return information about the origin with id origin_id.
 
     Args:
         origin_id as string
 
     Returns:
         origin information as dict.
 
     """
     return main.storage().origin_get({'id': origin_id})
 
 
 def lookup_person(person_id):
     """Return information about the person with id person_id.
 
     Args:
         person_id as string
 
     Returns:
         person information as dict.
 
     """
     persons = main.storage().person_get([person_id])
     if not persons:
         return None
     return converters.from_person(persons[0])
 
 
 def lookup_directory(sha1_git):
     """Return information about the directory with id sha1_git.
 
     Args:
         sha1_git as string
 
     Returns:
         directory information as dict.
 
     """
     algo, hBinSha1 = query.parse_hash(sha1_git)
     if algo != 'sha1':  # HACK: sha1_git really but they are both sha1...
         raise BadInputExc('Only sha1_git is supported.')
 
     directory_entries = main.storage().directory_get(hBinSha1)
     if not directory_entries:
         return None
 
-    res = []
-    for directory_entry in directory_entries:
-        res.append(converters.from_directory_entry(directory_entry))
-    return res
+    return map(converters.from_directory_entry, directory_entries)
 
 
 def lookup_release(release_sha1_git):
     """Return information about the release with sha1 release_sha1_git.
 
     Args:
         release_sha1_git: The release's sha1 as hexadecimal
 
     Returns:
         Release information as dict.
 
     Raises:
         ValueError if the identifier provided is not of sha1 nature.
 
     """
     algo, hBinSha1 = query.parse_hash(release_sha1_git)
     if algo != 'sha1':  # HACK: sha1_git really but they are both sha1...
         raise BadInputExc('Only sha1_git is supported.')
 
     res = main.storage().release_get([hBinSha1])
 
     if res and len(res) >= 1:
         return converters.from_release(res[0])
     return None
 
 
 def lookup_revision(rev_sha1_git, rev_type='git'):
     """Return information about the revision with sha1 revision_sha1_git.
 
     Args:
         revision_sha1_git: The revision's sha1 as hexadecimal
 
     Returns:
         Revision information as dict.
 
     Raises:
         ValueError if the identifier provided is not of sha1 nature.
 
     """
     algo, hBinSha1 = query.parse_hash(rev_sha1_git)
     if algo != 'sha1':  # HACK: sha1_git really but they are both sha1...
         raise BadInputExc('Only sha1_git is supported.')
 
     res = main.storage().revision_get([hBinSha1])
 
     if res and len(res) >= 1:
         return converters.from_revision(res[0])
     return None
 
 
 def lookup_revision_log(rev_sha1_git):
     """Return information about the revision with sha1 revision_sha1_git.
 
     Args:
         revision_sha1_git: The revision's sha1 as hexadecimal
 
     Returns:
         Revision information as dict.
 
     Raises:
         ValueError if the identifier provided is not of sha1 nature.
 
     """
     algo, hBinSha1 = query.parse_hash(rev_sha1_git)
     if algo != 'sha1':  # HACK: sha1_git really but they are both sha1...
         raise BadInputExc('Only sha1_git is supported.')
 
     revision_entries = main.storage().revision_log(hBinSha1)
 
     return map(converters.from_revision, revision_entries)
 
 
 def lookup_content(q):
     """Lookup the content designed by q.
 
     Args:
         q: The release's sha1 as hexadecimal
 
     """
     (algo, hash) = query.parse_hash(q)
     c = main.storage().content_find({algo: hash})
     if c:
         return converters.from_content(c)
     return None
 
 
 def lookup_content_raw(q):
     """Lookup the content designed by q.
 
     Args:
         q: query string of the form <hash_algo:hash>
 
     Returns:
         dict with 'sha1' and 'data' keys.
         data representing its raw data decoded.
 
     """
     (algo, hash) = query.parse_hash(q)
     c = main.storage().content_find({algo: hash})
     if not c:
         return None
 
     sha1 = c['sha1']
     contents = main.storage().content_get([sha1])
     if contents and len(contents) >= 1:
         return converters.from_content(contents[0])
     return None
 
 
 def stat_counters():
     """Return the stat counters for Software Heritage
 
     Returns:
         A dict mapping textual labels to integer values.
     """
     return main.storage().stat_counters()