diff --git a/swh/web/ui/renderers.py b/swh/web/ui/renderers.py
index f78ae067..02e837bc 100644
--- a/swh/web/ui/renderers.py
+++ b/swh/web/ui/renderers.py
@@ -1,145 +1,144 @@
 # 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
 
 import re
 import yaml
 
 from flask import make_response, request
 from flask.ext.api import renderers, parsers
 from flask_api.mediatypes import MediaType
 from swh.web.ui import utils
 
 
 class SWHFilterEnricher():
     """Global filter on fields.
 
     """
     def filter_by_fields(self, data):
         """Extract a request parameter 'fields' if it exists to permit the
            filtering on the data dict's keys.
 
            If such field is not provided, returns the data as is.
 
         """
         fields = request.args.get('fields')
         if fields:
             fields = set(fields.split(','))
             data = utils.filter_field_keys(data, fields)
 
         return data
 
 
 class YAMLRenderer(renderers.BaseRenderer, SWHFilterEnricher):
     """Renderer for application/yaml.
     Orchestrate from python data structure to yaml.
 
     """
     media_type = 'application/yaml'
 
     def render(self, data, media_type, **options):
         data = self.filter_by_fields(data)
         return yaml.dump(data, encoding=self.charset)
 
 
 class JSONPEnricher():
     """JSONP rendering.
 
     """
     def enrich_with_jsonp(self, data):
         """Defines a jsonp function that extracts a potential 'callback'
            request parameter holding the function name and wraps the data
            inside a call to such function
 
            e.g:
            GET /blah/foo/bar renders: {'output': 'wrapped'}
            GET /blah/foo/bar?callback=fn renders: fn({'output': 'wrapped'})
         """
         jsonp = request.args.get('callback')
         if jsonp:
             return '%s(%s)' % (jsonp, data)
 
         return data
 
 
 class SWHJSONRenderer(renderers.JSONRenderer,
                       SWHFilterEnricher,
                       JSONPEnricher):
     """Renderer for application/json.
     Serializes in json the data and returns it.
 
     Also deals with jsonp.  If callback is found in request parameter,
     wrap the result as a function with name the value of the parameter
     query 'callback'.
 
     """
     def render(self, data, media_type, **options):
         data = self.filter_by_fields(data)
         res = super().render(data, media_type, **options)
         return self.enrich_with_jsonp(res)
 
 
 def urlize_api_links(content):
     """Utility function for decorating api links in browsable api."""
     return re.sub(r'"(/api/.*)"', r'"<a href="\1">\1</a>"', content)
 
 
 def safe_docstring_display(docstring):
     """Utility function to safely decorate docstring in browsable api."""
-    print(docstring)
     src = r'(Args|Raises|Throws|Returns|Examples?|Samples?):?.*'
     dest = r'<h4>\1:</h4>&nbsp;&nbsp;'
     return re.sub(src, dest, docstring)
 
 
 class SWHBrowsableAPIRenderer(renderers.BrowsableAPIRenderer):
     """SWH's browsable api renderer.
 
     """
     template = "api.html"
 
 
 RENDERERS = [
     'swh.web.ui.renderers.SWHJSONRenderer',
     'swh.web.ui.renderers.SWHBrowsableAPIRenderer',
     'flask.ext.api.parsers.URLEncodedParser',
     'swh.web.ui.renderers.YAMLRenderer',
 ]
 
 
 RENDERERS_INSTANCE = [
     SWHJSONRenderer(),
     SWHBrowsableAPIRenderer(),
     parsers.URLEncodedParser(),
     YAMLRenderer(),
 ]
 
 
 RENDERERS_BY_TYPE = {
     r.media_type: r
     for r in RENDERERS_INSTANCE
 }
 
 
 def error_response(default_error_msg, error_code, error):
     """Private function to create a custom error response.
 
     """
     # if nothing is requested by client, use json
     default_application_type = 'application/json'
     accept_type = request.headers.get('Accept', default_application_type)
     renderer = RENDERERS_BY_TYPE.get(
         accept_type,
         RENDERERS_BY_TYPE[default_application_type])
 
     # for edge cases, use the elected renderer's media type
     accept_type = renderer.media_type
     response = make_response(default_error_msg, error_code)
     response.headers['Content-Type'] = accept_type
     response.data = renderer.render({"error": str(error)},
                                     media_type=MediaType(accept_type),
                                     status=error_code,
                                     headers={'Content-Type': accept_type})
 
     return response