Django फ़िल्टर टाइमस्टैम्प डेटा ग्रुप-ब-दिन, सप्ताह, महीने, साल

Question

Django फ़िल्टर टाइमस्टैम्प डेटा ग्रुप-ब-दिन, सप्ताह, महीने, साल

वोट

30

मैं जिसमें मैं एपीआई प्रतिक्रिया के आधार पर समय-समय पर timeseries डेटा भंडारण के एक Django (डीआरएफ) अनुप्रयोग है। यहाँ मेरी model.py है

# Model to store the Alexa API Data
class Alexa(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    extra = jsonfield.JSONField(null=True)
    rank =  models.PositiveIntegerField(default=0, null=True)

मैं एक सीमा (__lte, __gte) के आधार पर क्वेरी डेटा को Django-फ़िल्टर का उपयोग कर रहा हूँ। जैसा /api/alexa/?created_at__lte=2020-02-14T09:15:52.329641Zपहले बनाए गए सभी डेटा वापस2020-02-14T09:15:52.329641Z

[
    {
        id: 1,
        created_at: 2020-02-03T19:30:57.868588Z,
        extra: {'load_time': 00, 'backlink': 0},
        rank: 0
    },
    ...
 ]

वहाँ एक अंत बिंदु का निर्माण करने के क्वेरी पैरामीटर मैं पारित के आधार पर दिन, सप्ताह, महीने और साल के आधार पर वर्गीकृत समेकित डेटा वापस जाने के लिए एक रास्ता है। उदाहरण के लिए, /api/alexa/?created_at__lte=2020-02-14T09:15:52.329641Z&group_by=monthवापसी होगी

[
    {
        created_at: 2020-01-01T00:00:00.000000Z,
        extra: {'load_time': 00, 'backlink': 0}, <- Aggregated Data 
        rank: 0                                    <- Aggregated Data
    },
    {
        created_at: 2020-02-01T00:00:00.000000Z,
        extra: {'load_time': 00, 'backlink': 0}, <- Aggregated Data 
        rank: 0                                    <- Aggregated Data 
    },
 ]

यहाँ मेरे वर्तमान serializer.py है

class AlexaViewSet(viewsets.ModelViewSet):
    queryset = Alexa.objects.all()
    filter_fields = {'created_at' : ['iexact', 'lte', 'gte']}
    http_method_names = ['get', 'post', 'head']

मैं कई एकत्रीकरण कर के टुकड़े को देखा है, लेकिन कोई भी पूरी तरह से मेरी आवश्यकताओं को पूरा करने और न ही मुझे विषय के बारे में एक पूरा विचार दे रही है।

मैं सामान्य रूप में Django के लिए नए और निर्माण एनालिटिक्स डैशबोर्ड्स हूँ, अगर वहाँ सामने के अंत रेखांकन में खपत के लिए इस तरह के timeseries डेटा का प्रतिनिधित्व करने के किसी अन्य तरीके से कर रहे हैं, मैं भी है कि करने के लिए अपने सुझाव की सराहना करेंगे।

python django django-rest-framework django-orm django-filters

15/02/2020 को 08:48
उपयोगकर्ता Shouvik Mitra

अन्य भाषाओं में...

1 जवाब

H E · Answer 1 · 2020-02-15 20:34

सबसे पहले, वर्ग AlexaViewSetएक serializer लेकिन एक ViewSet नहीं है। तो मैं आपको लगता है कि निर्दिष्ट करने की आवश्यकता आपको लगता है कि ViewSet पर serializer वर्ग निर्दिष्ट नहीं किया।

दूसरी ओर, यदि आप URL पर एक कस्टम क्वेरी परम पास करना चाहते हैं तो आप को ओवरराइट listइस ViewSet की विधि और क्वेरी स्ट्रिंग में पारित कर दिया पार्स requestवस्तु का मान प्राप्त करने के लिए group_by, उसे सत्यापित करने में, और उसके बाद एकत्रीकरण अपने आप perfom ।

एक अन्य समस्या यह है कि मैं देख रहा हूँ कि आप भी क्या एक JSON क्षेत्र है, जो एसक्यूएल में समर्थित नहीं है एकत्र करने के लिए है परिभाषित करने की जरूरत है और यह बहुत ही रिश्तेदार है, इसलिए आप आप कैसे इस JSON क्षेत्र की जानकारी स्टोर अगर आप चाहते हैं की पुनः रचना पर विचार कर सकते इसके अंदर खेतों पर perfom एकत्रित करने के लिए। मैं क्षेत्रों आप (जब उन्हें डेटाबेस में भंडारण) JSON से कुल और एक एसक्यूएल कॉलम में उन्हें अलग से रखें ताकि आप पर एकत्रित बाद में प्रदर्शन कर सकता है चाहता हूँ निकालने का सुझाव देते हैं। ग्राहक भी उदाहरण के लिए, एक क्वेरी पैरामीटर के रूप agregation आपरेशन गुजर सकता है aggregation=sumया aggregation=avg।

एक साधारण मामला है, जहां आप सिर्फ औसत के रैंकों यह एक (आप जोड़ सकते उदाहरण के रूप में उपयोगी होना चाहिए की जरूरत है TruncQuarter, आदि):

class AlexaViewSet(viewsets.ModelViewSet):
    serializer_class = AlexaSerializer
    queryset = Alexa.objects.all()
    filter_fields = {'created_at': ['iexact', 'lte', 'gte']}
    http_method_names = ['get', 'post', 'head']

    GROUP_CASTING_MAP = {  # Used for outputing the reset datetime when grouping
        'day': Cast(TruncDate('created_at'), output_field=DateTimeField()),
        'month': Cast(TruncMonth('created_at'), output_field=DateTimeField()),
        'week': Cast(TruncWeek('created_at'), output_field=DateTimeField()),
        'year': Cast(TruncYear('created_at'), output_field=DateTimeField()),
    }

    GROUP_ANNOTATIONS_MAP = {  # Defines the fields used for grouping
        'day': {
            'day': TruncDay('created_at'),
            'month': TruncMonth('created_at'),
            'year': TruncYear('created_at'),
        },
        'week': {
            'week': TruncWeek('created_at')
        },
        'month': {
            'month': TruncMonth('created_at'),
            'year': TruncYear('created_at'),
        },
        'year': {
            'year': TruncYear('created_at'),
        },
    }

    def list(self, request, *args, **kwargs):
        group_by_field = request.GET.get('group_by', None)
        if group_by_field and group_by_field not in self.GROUP_CASTING_MAP.keys():  # validate possible values
            return Response(status=status.HTTP_400_BAD_REQUEST)

        queryset = self.filter_queryset(self.get_queryset())

        if group_by_field:
            queryset = queryset.annotate(**self.GROUP_ANNOTATIONS_MAP[group_by_field]) \
                .values(*self.GROUP_ANNOTATIONS_MAP[group_by_field]) \
                .annotate(rank=Avg('rank'), created_at=self.GROUP_CASTING_MAP[group_by_field]) \
                .values('rank', 'created_at')

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

इन मूल्यों के लिए:

GET /alexa
[
    {
        "id": 1,
        "created_at": "2020-03-16T12:04:59.096098Z",
        "extra": "{}",
        "rank": 2
    },
    {
        "id": 2,
        "created_at": "2020-02-15T12:05:01.907920Z",
        "extra": "{}",
        "rank": 64
    },
    {
        "id": 3,
        "created_at": "2020-02-15T12:05:03.890150Z",
        "extra": "{}",
        "rank": 232
    },
    {
        "id": 4,
        "created_at": "2020-02-15T12:05:06.357748Z",
        "extra": "{}",
        "rank": 12
    }
]

GET /alexa/?group_by=day
[
    {
        "created_at": "2020-02-15T00:00:00Z",
        "extra": null,
        "rank": 102
    },
    {
        "created_at": "2020-03-16T00:00:00Z",
        "extra": null,
        "rank": 2
    }
]

GET /alexa/?group_by=week
[
    {
        "created_at": "2020-02-10T00:00:00Z",
        "extra": null,
        "rank": 102
    },
    {
        "created_at": "2020-03-16T00:00:00Z",
        "extra": null,
        "rank": 2
    }
]

GET /alexa/?group_by=month
[
    {
        "created_at": "2020-02-01T00:00:00Z",
        "extra": null,
        "rank": 102
    },
    {
        "created_at": "2020-03-01T00:00:00Z",
        "extra": null,
        "rank": 2
    }
]

GET /alexa/?group_by=year
[
    {
        "created_at": "2020-01-01T00:00:00Z",
        "extra": null,
        "rank": 77
    }
]