code: def _render_serializable(self, obj, context):
          
          logging.info("""Careful, you're calling ._render_serializable on the
          base resource, which is probably not what you actually want to be
          doing!""")
          if obj is None:
              logging.debug(
                      "_render_serializable passed a None obj, returning None")
              return None
          output = {}
          if self._fields_to_render is None:
              return output
          for field in self._fields_to_render:
              renderer = self._fields[field].render
              output[field] = renderer(obj, field, context)
          return output
docs: Renders a JSON-serializable version of the object passed in.
          Usually this means turning a Python object into a dict, but sometimes
          it might make sense to render a list, or a string, or a tuple.
  
          In this base class, we provide a default implementation that assumes
          some things about your application architecture, namely, that your
          models specified in `underlying_model` have properties with the same
          name as all of the `_fields` that you've specified on a
          resource, and that all of those fields are public.
  
          Obviously this may not be appropriate for your app, so your
          subclass(es) of Resource should implement this method to serialize
          your things in the way that works for you.
  
          Do what you need to do.  The world is your oyster.