Example #1
0
def query(request):
    '''Gets NLP API response'''
    if request.method == 'POST':
        try:
            data = CamelCaseJSONParser().parse(request)
            text = data['nlp_text']
        except KeyError:
            return HttpResponseBadRequest()

        text = check_text(text)

        if text is None:
            return JsonResponse(RESPONSE_EMPTY, status=200)

        client = LanguageServiceClient()

        # pylint: disable=no-member
        document = types.Document(
            content=text,
            type=enums.Document.Type.PLAIN_TEXT)
        # pylint: enable=no-member

        try:
            google_category_response = client.classify_text(document=document)
            google_analysis_response = client.analyze_entities(document=document)
            response = MessageToDict(google_category_response)
            analysis_response = MessageToDict(google_analysis_response)
        except InvalidArgument:
            return JsonResponse(RESPONSE_EMPTY, status=200)

        response = make_response(response, analysis_response)

        return JsonResponse(response, status=200)
    return HttpResponseNotAllowed(['POST'])
Example #2
0
    def run(self, end_point_tracker_id, shipment_tracker_id):
        shipment_tracker = ShipmentSyncTracker.objects.get(
            id=shipment_tracker_id)
        end_point_tracker = SellerEndPointTracker.objects.get(
            id=end_point_tracker_id)
        shipment_tracker.state = ShipmentSyncTracker.STARTED
        shipment_tracker.save()
        response = self.fetch(shipment_tracker.seller.access_token,
                              shipment_tracker.shipment_id)

        if response.status_code == 200:
            end_point_tracker.remaining_req_limit = int(
                response.headers["x-ratelimit-remaining"])
            end_point_tracker.limit_reset_at = now() + timedelta(
                seconds=int(response.headers["x-ratelimit-reset"]))
            end_point_tracker.save()
            stream = BytesIO(bytes(response.text, 'utf-8'))
            serializer = ShipmentSerializer(
                data=CamelCaseJSONParser().parse(stream=stream),
                context={"seller": shipment_tracker.seller})
            serializer.is_valid()
            serializer.save()
            shipment_tracker.state = ShipmentSyncTracker.FINISHED
            shipment_tracker.save()

        elif response.status_code == 429:
            end_point_tracker.remaining_req_limit = 0
            end_point_tracker.limit_reset_at = now() + timedelta(
                seconds=int(response.headers["x-ratelimit-reset"]))
            end_point_tracker.save()
Example #3
0
def test_deserialize_with_obj(db_obj):
    consumer = consumers.SelfContainedTestConsumer()
    consumer.action = 'subscribe'
    consumer.parser = CamelCaseJSONParser()

    # No data
    consumer.data = payload()
    assert consumer.deserialize(db_obj, partial=True).validated_data == {}

    # Partial data
    consumer.data = payload(counter=270)
    with pytest.raises(exceptions.ValidationError):
        consumer.deserialize()

    data = consumer.deserialize(db_obj, partial=True).validated_data
    assert data == {'counter': 270}

    # Complete data
    consumer.data = payload(id=234, name='Andrew', counter=270)
    data = consumer.deserialize(db_obj).validated_data
    assert data == {'name': 'Andrew', 'counter': 270}

    consumer.data = payload(id=db_obj.pk, name='Andrew', counter=270)
    data = consumer.deserialize(db_obj).validated_data
    assert data == {'name': 'Andrew', 'counter': 270}
Example #4
0
def consumer_with_custom_serializer_meta(**kwargs):
    kwargs.update({'model': models.APIModel})
    Meta = type('Meta', (), kwargs)
    Serializer = type('Serializer', (ModelSerializer, ), {'Meta': Meta})
    return type(
        'TestConsumer', (consumers.SelfContainedTestConsumer, ), {
            'view': views.TestViewSet,
            'serializer_class': Serializer,
            'parser': CamelCaseJSONParser(),
        })()
Example #5
0
def test_deserialize_exception():
    consumer = consumers.SelfContainedTestConsumer()
    consumer.action = 'subscribe'
    consumer.parser = CamelCaseJSONParser()
    consumer.data = payload(id=234, city='London', counter=15)
    with pytest.raises(exceptions.APIException):
        consumer.deserialize()

    consumer.data = payload(id=234, name='Natasha', counter='-')
    with pytest.raises(exceptions.APIException):
        consumer.deserialize()
Example #6
0
def test_deserialize_permissions():
    class TestConsumer(consumers.SelfContainedTestConsumer):
        view = views.TestViewSet

        def check_permissions(self, obj):
            raise exceptions.APIException()

    consumer = TestConsumer()
    consumer.parser = CamelCaseJSONParser()
    consumer.data = payload(name='me', counter=0)
    with pytest.raises(exceptions.APIException):
        consumer.deserialize()
Example #7
0
 def test_organization_list_fields(self):
     """Test list's fields of organization REST API endpoint."""
     response = self.client.get('/api/organizations/')
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     # dirty hack intead of checking response.data because of issue
     # djangorestframework-camel-case #26:
     for organization in CamelCaseJSONParser().parse(
             BytesIO(response.content)):
         self.assertIsInstance(organization.pop('id'), int)
         self.assertIsInstance(organization.pop('name'), str)
         self.assertIsInstance(organization.pop('slug'), str)
         self.assertIsInstance(organization.pop('url'), str)
         self.assertEqual(len(organization), 0)
Example #8
0
 def post(self, request):
     data = CamelCaseJSONParser().parse(request)
     serializer = ShortLayoutDataSerializer(data=data)
     if serializer.is_valid():
         layout, priorities = serializer.save()
         layout.width = calculate_layout_width(layout.duration_limit)
         layout.save()
         save_layout_priorities(layout, priorities)
         return Response(ShortLayoutDataSerializer(layout).data,
                         status=status.HTTP_200_OK)
     return Response(ErrorMessageSerializer(
         message_from_serializer_errors(serializer.errors)).data,
                     status=status.HTTP_400_BAD_REQUEST)
Example #9
0
 def post(self, request):
     try:
         data = CamelCaseJSONParser().parse(request)
         serializer = FullLayoutDataSerializer(data=data)
         if serializer.is_valid():
             layout_data = serializer.save()
             layout_obj = layout_data.to_layout()
             optimize(layout_obj, layout_obj.update_date)
             layout_data = LayoutData.from_layout(layout_obj)
             return Response(FullLayoutDataSerializer(layout_data).data,
                             status=status.HTTP_200_OK)
         raise message_from_serializer_errors(serializer.errors)
     except ErrorMessage as e:
         return Response(ErrorMessageSerializer(e).data,
                         status=status.HTTP_400_BAD_REQUEST)
Example #10
0
 def test_offer_list_fields(self):
     """Test list's fields of offers REST API endpoint."""
     response = self.client.get('/api/offers/')
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     # dirty hack intead of checking response.data because of issue
     # djangorestframework-camel-case #26:
     for offer in CamelCaseJSONParser().parse(BytesIO(response.content)):
         self.assertIsInstance(offer.pop('finished_at'), str)
         self.assertIsInstance(offer.pop('id'), int)
         self.assertIsInstance(offer.pop('image'), (str, type(None)))
         self.assertIsInstance(offer.pop('location'), str)
         self.assertIsInstance(offer.pop('organization'), str)
         self.assertIsInstance(offer.pop('slug'), str)
         self.assertIsInstance(offer.pop('started_at'), str)
         self.assertIsInstance(offer.pop('title'), str)
         self.assertIsInstance(offer.pop('url'), str)
         self.assertEqual(len(offer), 0)
Example #11
0
def test_receive_exception(db_obj):
    class TestConsumer(consumers.ExceptionToMessageConsumer):
        def perform_update(self, serializer):
            assert isinstance(self.object, models.APIModel)
            raise exceptions.APIException('Just an error')

    consumer = TestConsumer()
    consumer.parser = CamelCaseJSONParser()
    assert consumer.object is None
    consumer.receive(
        ('go', 'update', str(db_obj.pk)),
        json.dumps({'payload': {
            'counter': 301
        }}),
    )
    error = consumer.messages.pop()
    assert isinstance(error, exceptions.APIException)
    assert error.detail == 'Just an error'
    assert consumer.object is None
Example #12
0
 def post(self, request, pk):
     try:
         layout = Layout.objects.get(pk=pk)
     except Layout.DoesNotExist:
         return Response({}, status=status.HTTP_404_NOT_FOUND)
     data = CamelCaseJSONParser().parse(request)
     serializer = FullLayoutDataSerializer(data=data)
     try:
         check_in_edit_mode(request, layout)
         if serializer.is_valid():
             layout_data = serializer.save()
             update_layout_in_db(layout_data, layout)
             layout_obj = get_layout_from_db(layout)
             layout_data = LayoutData.from_layout(layout_obj)
             return Response(FullLayoutDataSerializer(layout_data).data,
                             status=status.HTTP_200_OK)
         raise message_from_serializer_errors(serializer.errors)
     except ErrorMessage as e:
         return Response(ErrorMessageSerializer(e).data,
                         status=status.HTTP_400_BAD_REQUEST)
Example #13
0
def test_deserialize_no_obj():
    consumer = consumers.SelfContainedTestConsumer()
    consumer.action = 'subscribe'
    consumer.parser = CamelCaseJSONParser()

    # No data
    consumer.data = payload()
    assert consumer.deserialize(partial=True).validated_data == {}

    # Partial data
    consumer.data = payload(name='Andrew')
    with pytest.raises(exceptions.ValidationError):
        consumer.deserialize()

    data = consumer.deserialize(partial=True).validated_data
    assert data == {'name': 'Andrew'}

    # Complete data
    consumer.data = payload(something=1, name='Andrew', counter=270)
    data = consumer.deserialize().validated_data
    assert data == {'name': 'Andrew', 'counter': 270}
Example #14
0
def test_get_objects_fields():
    consumer = consumers.TestConsumer()
    consumer.parser = CamelCaseJSONParser()

    # One field
    consumer.data = payload(counter=41)

    # Empty database
    assert not consumer.get_objects().exists()

    models.APIModel.objects.bulk_create((
        models.APIModel(name='Luke', counter=41),
        models.APIModel(name='Mary', counter=41),
        models.APIModel(name='Luke', counter=26),
    ))

    # 2 objects
    objects = list(consumer.get_objects())
    assert len(objects) == 2
    assert objects[0].counter == objects[1].counter == 41

    # 1 object
    consumer.data = payload(counter=26)
    objects = list(consumer.get_objects())
    assert len(objects) == 1
    assert objects[0].name == 'Luke'

    # Two fields
    # 1 object
    consumer.data = payload(name='Luke', counter=41)
    objects = list(consumer.get_objects())
    assert len(objects) == 1
    assert objects[0].name == 'Luke'

    # 0 objects
    consumer.data = payload(name='Mary', counter=26)
    assert not consumer.get_objects().exists()
Example #15
0
def test_parse():
    consumer = consumers.SelfContainedTestConsumer()
    consumer.parser = CamelCaseJSONParser()
    consumer.data = b'{"payload":{"field":"v","anotherF":["Espa\u00F1a",""]}}'
    data = consumer.parse()
    assert data == {'field': 'v', 'another_f': ['EspaƱa', '']}