def _send_hook_request(self, obj, method):
        url = self._build_hook_url(obj)

        if method in ('POST', 'PUT'):
            # Build the body
            serializer = self.get_serializer(obj)
            renderer = JSONRenderer()
            context = {'request': self.request}
            body = renderer.render(serializer.data, renderer_context=context)
        else:
            body = None
        headers = {
            'content-type': 'application/json',
            'X-Signature': self._build_hook_signature(method, url, body)
        }

        try:
            response = requests.request(method, url, data=body,
                                        timeout=0.5, headers=headers)
            response.raise_for_status()
        except requests.exceptions.ConnectionError:
            # Host could not be resolved or connection refused
            pass
        except requests.exceptions.Timeout:
            # Request timed out
            pass
        except requests.exceptions.RequestException:
            # Server responded with 4XX or 5XX status code
            pass

def send_notifications(snapshot_time):
    positions = Position.objects.filter(snapshot_time=snapshot_time)

    serializer = PositionSerializer(positions, many=True)
    rendered = JSONRenderer().render(serializer.data)

    Group('trams/positions').send({'text': rendered.decode()})

    def test_create_object(self):
        jr = JSONRenderer()

        for name, model in models.generated_models.models.items():
            serializer = models.generated_models.model_serializer(name)
            obj = G(model)
            pk = model._meta.pk.name
            # PUT
            data = serializer(N(model)).data
            if pk in data:
                del data[pk]
            url = reverse(self.view_name, kwargs={'model': name, 'pk': obj.id})
            response = self.client.put(url, jr.render(data), content_type='application/json')
            response_data = response.data
            if pk in response_data:
                del response_data[pk]
            self.assertDictEqual(data, response_data)
            # PATCH
            orig_data = serializer(obj).data
            patch_data = {}
            for key, val in orig_data.items():
                if key != pk and val != data.get(key):
                    patch_data = {
                        key: val
                    }
                    data[key] = val
                    break
            response = self.client.patch(url, jr.render(patch_data), content_type='application/json')
            response_data = response.data
            if pk in response_data:
                del response_data[pk]
            self.assertDictEqual(data, response_data)

    def test_render_dict_abc_obj(self):
        class Dict(MutableMapping):
            def __init__(self):
                self._dict = dict()

            def __getitem__(self, key):
                return self._dict.__getitem__(key)

            def __setitem__(self, key, value):
                return self._dict.__setitem__(key, value)

            def __delitem__(self, key):
                return self._dict.__delitem__(key)

            def __iter__(self):
                return self._dict.__iter__()

            def __len__(self):
                return self._dict.__len__()

            def keys(self):
                return self._dict.keys()

        x = Dict()
        x["key"] = "string value"
        x[2] = 3
        ret = JSONRenderer().render(x)
        data = json.loads(ret.decode("utf-8"))
        self.assertEquals(data, {"key": "string value", "2": 3})

    def test_datetime_timezone_awareness(self):
        # Addresses issue #24 - ensure that datetime strings terminating
        # in 'Z' are correctly handled.
        from rest_framework import serializers
        from rest_framework.renderers import JSONRenderer

        class PersonSerializer(serializers.ModelSerializer):
            class Meta:
                model = Person

        # Figure out what the date strings should look like based on the
        # serializer output.
        john = Person.objects.get(name="John")
        data = PersonSerializer(john).data
        datetime_str = JSONRenderer().render(parse_datetime(data['datetime_joined']) + datetime.timedelta(seconds=0.6)).decode('utf-8').strip('"')

        # This is more for documentation - DRF appends a 'Z' to timezone aware UTC datetimes when rendering:
        # https://github.com/tomchristie/django-rest-framework/blob/3.2.0/rest_framework/fields.py#L1002-L1006
        self.assertTrue(datetime_str.endswith('Z'))

        GET = {
            'datetime_joined__lte': datetime_str,
        }
        f = AllLookupsPersonDateFilter(GET, queryset=Person.objects.all())
        self.assertEqual(len(list(f)), 1)
        p = list(f)[0]
        self.assertEqual(p.name, "John")

def channel_page(request, channel, allow_edit=False):
    channel_serializer =  ChannelSerializer(channel)

    channel_list = Channel.objects.select_related('main_tree').prefetch_related('editors').prefetch_related('viewers')\
                            .exclude(id=channel.pk).filter(Q(deleted=False) & (Q(editors=request.user) | Q(viewers=request.user)))\
                            .annotate(is_view_only=Case(When(editors=request.user, then=Value(0)),default=Value(1),output_field=IntegerField()))\
                            .distinct().values("id", "name", "is_view_only").order_by('name')

    fileformats = get_or_set_cached_constants(FileFormat, FileFormatSerializer)
    licenses = get_or_set_cached_constants(License, LicenseSerializer)
    formatpresets = get_or_set_cached_constants(FormatPreset, FormatPresetSerializer)
    contentkinds = get_or_set_cached_constants(ContentKind, ContentKindSerializer)

    json_renderer = JSONRenderer()

    return render(request, 'channel_edit.html', {"allow_edit":allow_edit,
                                                "channel" : json_renderer.render(channel_serializer.data),
                                                "channel_id" : channel.pk,
                                                "channel_name": channel.name,
                                                "channel_list" : channel_list,
                                                "fileformat_list" : fileformats,
                                                "license_list" : licenses,
                                                "fpreset_list" : formatpresets,
                                                "ckinds_list" : contentkinds,
                                                "current_user" : json_renderer.render(CurrentUserSerializer(request.user).data),
                                                "preferences" : request.user.preferences,
                                            })

 def _send_hook_request(self, obj, method):
     url = self._build_hook_url(obj)
     if method in ('post', 'put'):
         # Build body
         serializer = self.get_serializer(obj)
         renderer = JSONRenderer()
         context = {'request': self.request}
         body = renderer.render(serializer.data, renderer_context=context)
     else:
         body = None
     headers = {
         'content-type': 'application/json',
         'X-Signature': self._build_hook_signature(method, url, body),
     }
     try:
         response = requests.request(method, url,
                                     timeout=0.5, headers=headers)
         response.raise_for_status()
     except requests.exceptions.ConnectionError:
         """Host cannot be resolved or connection refused"""
         pass
     except requests.exceptions.Timeout:
         """Request timed out"""
         pass
     except requests.exceptions.RequestException:
         """Server response of 4XX or 5XX"""
         pass

 def _send_hook_request(self, obj, method):
     url = self._build_hook_url(obj)
     if method in ('POST', 'PUT'):
         #compõe o corpo
         serializer = self.get_serializer(obj)
         rendererer = JSONRenderer()
         context = {'request': self.request}
         body = rendererer.render(serializer.data, renderer_context=context)
     else:
         body = None
     headers = {
         'content-type': 'application/json',
         'X-Signature': self._build_hook_signature(method, url, body)
     }
     try:
         s = requests.Session()
         requisicao = requests.Request(method, url, data=body, headers=headers)
         prepared = requisicao.prepare()
         response = s.send(prepared, timeout=0.5)
         response.raise_for_status()
     except requests.exceptions.ConnectionError:
         # Host não pôde ser resolvido ou a conexão foi recusada
         pass
     except requests.exceptions.Timeout:
         # Solicitação expirou
         pass
     except requests.exceptions.RequestException:
         # Servidor respondeu com código de status 4XX ou 5XX
         pass

	def perform_create(self, serializer):
		serializer.save(owner=self.request.user)

		# add push notification task for the created question
		renderer = JSONRenderer()
		question_data = renderer.render(data=serializer.data)
		tasks.push_question.delay(question_data)

	def _send_hook_request(self, obj, method):
		url = self._build_hook_url(obj)

		if method in ('POST', 'PUT'):
			serializer = self.get_serializer(obj)
			renderer = JSONRenderer()
			context = {'request': self.request}
			body = renderer.render(serializer.data, renderer_context=context)
		else:
			body = None

		headers = {
			'context-type': 'application/json',
			'X-Signature': self._build_hook_signarute(method, url, body)
		}

		try:
			print('Enviando peticion a :' + url + ' con metodo '+ method)
			response = requests.request(method, url, data=body, timeout=0.5, headers=headers)
			response.raise_for_status()
			print('Peticion enviada...')
		except requests.exceptions.ConnectionError:
			print('Error de conexion')
			# concexion rechazada
			pass
		except requests.exceptions.Timeout:
			print('Error de timeout')
			# timeout
			pass
		except requests.exceptions.RequestException, e:
			print('Error de 400 o 500', e.message)
			# error 4XX o 5XX
			pass

    def process_response(self, request, response):
        if 'HTTP_ACCEPT' in request.META.keys() and 'text/html' in request.META['HTTP_ACCEPT']:
            try:
                path = resolve(request.path)
            except Resolver404:
                pass
            else:
                if hasattr(path.func, 'cls') and hasattr(path.func.cls, 'crud_model'):
                    request._request = request

                    if not hasattr(response, 'data'):
                        content = {"Error": response.content}
                    else:
                        renderer = JSONRenderer()
                        renderer_context = {'indent': 4}
                        content = renderer.render(response.data, "application/json", renderer_context)

                    renderer_context = {
                        'content': content,
                        'request': request,
                        'response': response,
                        'args': {},
                        'kwargs': {}
                    }
                    return TemplateResponse(request, "api.html", renderer_context).render()
        return response

def channel(request, channel_id):
    channel = get_object_or_404(Channel, id=channel_id, deleted=False)
    channel_serializer =  ChannelSerializer(channel)

    accessible_channel_list = Channel.objects.filter( Q(deleted=False, public=True) | Q(deleted=False, editors__email__contains= request.user.email))
    accessible_channel_list = ChannelListSerializer.setup_eager_loading(accessible_channel_list)
    accessible_channel_list_serializer = ChannelListSerializer(accessible_channel_list, many=True)

    channel_list = accessible_channel_list.filter(editors__email__contains= request.user.email).exclude(id=channel_id).values("id", "name")
    fileformats = get_or_set_cached_constants(FileFormat, FileFormatSerializer)
    licenses = get_or_set_cached_constants(License, LicenseSerializer)
    formatpresets = get_or_set_cached_constants(FormatPreset, FormatPresetSerializer)
    contentkinds = get_or_set_cached_constants(ContentKind, ContentKindSerializer)

    channel_tags = ContentTag.objects.filter(channel = channel)
    channel_tags_serializer = TagSerializer(channel_tags, many=True)

    json_renderer = JSONRenderer()

    return render(request, 'channel_edit.html', {"channel" : json_renderer.render(channel_serializer.data),
                                                "channel_id" : channel_id,
                                                "channel_name": channel.name,
                                                "accessible_channels" : json_renderer.render(accessible_channel_list_serializer.data),
                                                "channel_list" : channel_list,
                                                "fileformat_list" : fileformats,
                                                 "license_list" : licenses,
                                                 "fpreset_list" : formatpresets,
                                                 "ckinds_list" : contentkinds,
                                                 "ctags": json_renderer.render(channel_tags_serializer.data),
                                                 "current_user" : json_renderer.render(CurrentUserSerializer(request.user).data)})

def _handle_error(status_code):
    info = {
        'status': status_code
    }

    renderer = JSONRenderer()
    content_type = '{media}; charset={charset}'.format(media=renderer.media_type, charset=renderer.charset)
    return HttpResponse(renderer.render(info), content_type=content_type, status=status_code)

    def get_context_data(self, **kwargs):
        # Add some serialized json for bootstrapping the client-side app
        renderer = JSONRenderer()
        kwargs['project_json'] = renderer.render(serializers.ProjectSerializer(self.get_project()).data)
        kwargs['scheme_json'] = renderer.render(serializers.SchemeSerializer(self.object).data)
        kwargs['user_json'] = renderer.render(serializers.UserSerializer(self.request.user).data)

        return super(SchemeEditorView, self).get_context_data(**kwargs)

 def test_u2028_u2029(self):
     # The \u2028 and \u2029 characters should be escaped,
     # even when the non-escaping unicode representation is used.
     # Regression test for #2169
     obj = {'should_escape': '\u2028\u2029'}
     renderer = JSONRenderer()
     content = renderer.render(obj, 'application/json')
     self.assertEqual(content, '{"should_escape":"\\u2028\\u2029"}'.encode('utf-8'))

 def test_compact(self):
     renderer = JSONRenderer()
     data = OrderedDict([('a', 1), ('b', 2)])
     context = {'indent': 4}
     assert (
         renderer.render(data, renderer_context=context) ==
         b'{\n    "a": 1,\n    "b": 2\n}'
     )

 def test_with_content_type_args(self):
     """
     Test JSON rendering with additional content type arguments supplied.
     """
     obj = {"foo": ["bar", "baz"]}
     renderer = JSONRenderer()
     content = renderer.render(obj, "application/json; indent=2")
     self.assertEqual(strip_trailing_whitespace(content.decode("utf-8")), _indented_repr)

def emit_hedwig_serializer_data(action, module_name, serializer_name, serializer):
    if not bool(hedwig_rest_framework_settings.SERIALIZER_SIGNALS):
        return

    routing_key = '.'.join([project_name, module_name, 'serializer', serializer_name, action,
                            str(serializer.instance.pk)])
    json_renderer = JSONRenderer()
    hedwig_emitter.emit(routing_key, json_renderer.render(serializer.data))

 def test_without_content_type_args(self):
     """
     Test basic JSON rendering.
     """
     obj = {'foo': ['bar', 'baz']}
     renderer = JSONRenderer()
     content = renderer.render(obj, 'application/json')
     # Fix failing test case which depends on version of JSON library.
     self.assertEqual(content.decode('utf-8'), _flat_repr)

 def render(self, data=None, accepted_media_type=None, renderer_context=None):
     if isinstance(data, bytes):
         return data
     else:
         jr = JSONRenderer()
         self.media_type = jr.media_type
         self.format = jr.format
         self.charset = jr.charset
         self.render_style = jr.render_style
         return jr.render(data, accepted_media_type=accepted_media_type, renderer_context=renderer_context)