edx-enterprise-data 8.7.0__py3-none-any.whl → 8.8.1__py3-none-any.whl

enterprise_data/api/v1/views/analytics_enrollments.py

@@ -1,5 +1,6 @@
 """Advance Analytics for Enrollments"""
-from datetime import datetime, timedelta
+from datetime import datetime
+from logging import getLogger
 
 from edx_rbac.decorators import permission_required
 from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
@@ -8,35 +9,22 @@ from rest_framework.views import APIView
 
 from django.http import HttpResponse, StreamingHttpResponse
 
-from enterprise_data.admin_analytics.constants import CALCULATION, ENROLLMENT_CSV, GRANULARITY
-from enterprise_data.admin_analytics.data_loaders import fetch_max_enrollment_datetime
+from enterprise_data.admin_analytics.constants import Calculation, EnrollmentChart, Granularity, ResponseType
 from enterprise_data.admin_analytics.utils import (
     calculation_aggregation,
     fetch_and_cache_enrollments_data,
+    fetch_enrollments_cache_expiry_timestamp,
     granularity_aggregation,
 )
 from enterprise_data.api.v1.paginators import AdvanceAnalyticsPagination
 from enterprise_data.api.v1.serializers import (
-    AdvanceAnalyticsEnrollmentSerializer,
     AdvanceAnalyticsEnrollmentStatsSerializer,
+    AdvanceAnalyticsQueryParamSerializer,
 )
 from enterprise_data.renderers import IndividualEnrollmentsCSVRenderer
-from enterprise_data.utils import date_filter
+from enterprise_data.utils import date_filter, timer
 
-
-def fetch_enrollments_cache_expiry_timestamp():
-    """Calculate cache expiry timestamp"""
-    # TODO: Implement correct cache expiry logic for `enrollments` data.
-    #       Current cache expiry logic is based on `enterprise_learner_enrollment` table,
-    #       Which has nothing to do with the `enrollments` data. Instead cache expiry should
-    #       be based on `fact_enrollment_admin_dash` table. Currently we have no timestamp in
-    #       `fact_enrollment_admin_dash` table that can be used for cache expiry. Add a new
-    #       column in the table for this purpose and then use that column for cache expiry.
-    last_updated_at = fetch_max_enrollment_datetime()
-    cache_expiry = (
-        last_updated_at + timedelta(days=1) if last_updated_at else datetime.now()
-    )
-    return cache_expiry
+LOGGER = getLogger(__name__)
 
 
 class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
@@ -50,7 +38,7 @@ class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
     @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
     def get(self, request, enterprise_uuid):
         """Get individual enrollments data"""
-        serializer = AdvanceAnalyticsEnrollmentSerializer(data=request.GET)
+        serializer = AdvanceAnalyticsQueryParamSerializer(data=request.GET)
         serializer.is_valid(raise_exception=True)
 
         cache_expiry = fetch_enrollments_cache_expiry_timestamp()
@@ -59,7 +47,14 @@ class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
         # get values from query params or use default values
         start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
         end_date = serializer.data.get('end_date', datetime.now())
-        csv_type = request.query_params.get('csv_type')
+        response_type = request.query_params.get('response_type', ResponseType.JSON.value)
+
+        LOGGER.info(
+            "Individual enrollments data requested for enterprise [%s] from [%s] to [%s]",
+            enterprise_uuid,
+            start_date,
+            end_date,
+        )
 
         # filter enrollments by date
         enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
@@ -77,11 +72,19 @@ class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
         enrollments["enterprise_enrollment_date"] = enrollments["enterprise_enrollment_date"].dt.date
         enrollments = enrollments.sort_values(by="enterprise_enrollment_date", ascending=False).reset_index(drop=True)
 
-        if csv_type == ENROLLMENT_CSV.INDIVIDUAL_ENROLLMENTS.value:
+        LOGGER.info(
+            "Individual enrollments data prepared for enterprise [%s] from [%s] to [%s]",
+            enterprise_uuid,
+            start_date,
+            end_date,
+        )
+
+        if response_type == ResponseType.CSV.value:
+            filename = f"""individual_enrollments, {start_date} - {end_date}.csv"""
             return StreamingHttpResponse(
                 IndividualEnrollmentsCSVRenderer().render(self._stream_serialized_data(enrollments)),
                 content_type="text/csv",
-                headers={"Content-Disposition": 'attachment; filename="individual_enrollments.csv"'},
+                headers={"Content-Disposition": f'attachment; filename="{filename}"'},
             )
 
         paginator = self.pagination_class()
@@ -121,51 +124,60 @@ class AdvanceAnalyticsEnrollmentStatsView(APIView):
         # get values from query params or use default
         start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
         end_date = serializer.data.get('end_date', datetime.now())
-        granularity = serializer.data.get('granularity', GRANULARITY.DAILY.value)
-        calculation = serializer.data.get('calculation', CALCULATION.TOTAL.value)
-        csv_type = serializer.data.get('csv_type')
-
-        if csv_type is None:
-            data = {
-                "enrollments_over_time": self.construct_enrollments_over_time(
-                    enrollments_df.copy(),
-                    start_date,
-                    end_date,
-                    granularity,
-                    calculation,
-                ),
-                "top_courses_by_enrollments": self.construct_top_courses_by_enrollments(
-                    enrollments_df.copy(),
-                    start_date,
-                    end_date,
-                ),
-                "top_subjects_by_enrollments": self.construct_top_subjects_by_enrollments(
-                    enrollments_df.copy(),
-                    start_date,
-                    end_date,
-                ),
-            }
+        granularity = serializer.data.get('granularity', Granularity.DAILY.value)
+        calculation = serializer.data.get('calculation', Calculation.TOTAL.value)
+        response_type = serializer.data.get('response_type', ResponseType.JSON.value)
+        chart_type = serializer.data.get('chart_type')
+
+        # TODO: Add validation that if response_type is CSV then chart_type must be provided
+
+        if response_type == ResponseType.JSON.value:
+            with timer('construct_enrollment_all_stats'):
+                data = {
+                    "enrollments_over_time": self.construct_enrollments_over_time(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                        granularity,
+                        calculation,
+                    ),
+                    "top_courses_by_enrollments": self.construct_top_courses_by_enrollments(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                    ),
+                    "top_subjects_by_enrollments": self.construct_top_subjects_by_enrollments(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                    ),
+                }
             return Response(data)
-        elif csv_type == ENROLLMENT_CSV.ENROLLMENTS_OVER_TIME.value:
-            return self.construct_enrollments_over_time_csv(
-                enrollments_df.copy(),
-                start_date,
-                end_date,
-                granularity,
-                calculation,
-            )
-        elif csv_type == ENROLLMENT_CSV.TOP_COURSES_BY_ENROLLMENTS.value:
-            return self.construct_top_courses_by_enrollments_csv(
-                enrollments_df.copy(),
-                start_date,
-                end_date,
-            )
-        elif csv_type == ENROLLMENT_CSV.TOP_SUBJECTS_BY_ENROLLMENTS.value:
-            return self.construct_top_subjects_by_enrollments_csv(
-                enrollments_df.copy(),
-                start_date,
-                end_date,
-            )
+
+        if response_type == ResponseType.CSV.value:
+            if chart_type == EnrollmentChart.ENROLLMENTS_OVER_TIME.value:
+                with timer('construct_enrollments_over_time_csv'):
+                    return self.construct_enrollments_over_time_csv(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                        granularity,
+                        calculation,
+                    )
+            elif chart_type == EnrollmentChart.TOP_COURSES_BY_ENROLLMENTS.value:
+                with timer('construct_top_courses_by_enrollments_csv'):
+                    return self.construct_top_courses_by_enrollments_csv(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                    )
+            elif chart_type == EnrollmentChart.TOP_SUBJECTS_BY_ENROLLMENTS.value:
+                with timer('construct_top_subjects_by_enrollments_csv'):
+                    return self.construct_top_subjects_by_enrollments_csv(
+                        enrollments_df.copy(),
+                        start_date,
+                        end_date,
+                    )
 
     def enrollments_over_time_common(self, enrollments_df, start_date, end_date, granularity, calculation):
         """
@@ -175,8 +187,8 @@ class AdvanceAnalyticsEnrollmentStatsView(APIView):
             enrollments_df {DataFrame} -- DataFrame of enrollments
             start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
             end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of GRANULARITY choices
-            calculation {str} -- Calculation of the data. One of CALCULATION choices
+            granularity {str} -- Granularity of the data. One of Granularity choices
+            calculation {str} -- Calculation of the data. One of Calculation choices
         """
         # filter enrollments by date
         enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
@@ -202,8 +214,8 @@ class AdvanceAnalyticsEnrollmentStatsView(APIView):
             enrollments_df {DataFrame} -- DataFrame of enrollments
             start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
             end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of GRANULARITY choices
-            calculation {str} -- Calculation of the data. One of CALCULATION choices
+            granularity {str} -- Granularity of the data. One of Granularity choices
+            calculation {str} -- Calculation of the data. One of Calculation choices
         """
         enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
 
@@ -218,8 +230,8 @@ class AdvanceAnalyticsEnrollmentStatsView(APIView):
             enrollments_df {DataFrame} -- DataFrame of enrollments
             start_date {datetime} -- Enrollment start date in the format 'YYYY-MM-DD'
             end_date {datetime} -- Enrollment end date in the format 'YYYY-MM-DD'
-            granularity {str} -- Granularity of the data. One of GRANULARITY choices
-            calculation {str} -- Calculation of the data. One of CALCULATION choices
+            granularity {str} -- Granularity of the data. One of Granularity choices
+            calculation {str} -- Calculation of the data. One of Calculation choices
         """
         enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
 

enterprise_data/api/v1/views/analytics_leaderboard.py

@@ -0,0 +1,141 @@
+"""Advance Analytics for Leaderboard"""
+from datetime import datetime
+from logging import getLogger
+
+import numpy as np
+import pandas as pd
+from edx_rbac.decorators import permission_required
+from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
+from rest_framework.views import APIView
+
+from django.http import StreamingHttpResponse
+
+from enterprise_data.admin_analytics.constants import ResponseType
+from enterprise_data.admin_analytics.utils import (
+    fetch_and_cache_engagements_data,
+    fetch_and_cache_enrollments_data,
+    fetch_engagements_cache_expiry_timestamp,
+    fetch_enrollments_cache_expiry_timestamp,
+)
+from enterprise_data.api.v1.paginators import AdvanceAnalyticsPagination
+from enterprise_data.api.v1.serializers import AdvanceAnalyticsQueryParamSerializer
+from enterprise_data.renderers import LeaderboardCSVRenderer
+from enterprise_data.utils import date_filter
+
+LOGGER = getLogger(__name__)
+
+
+class AdvanceAnalyticsLeaderboardView(APIView):
+    """
+    API for getting the advance analytics leaderboard data.
+    """
+    authentication_classes = (JwtAuthentication,)
+    pagination_class = AdvanceAnalyticsPagination
+    http_method_names = ['get']
+
+    @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
+    def get(self, request, enterprise_uuid):
+        """Get leaderboard data"""
+        serializer = AdvanceAnalyticsQueryParamSerializer(data=request.GET)
+        serializer.is_valid(raise_exception=True)
+
+        enrollments_cache_expiry = fetch_enrollments_cache_expiry_timestamp()
+        enrollments_df = fetch_and_cache_enrollments_data(enterprise_uuid, enrollments_cache_expiry)
+
+        engagements_cache_expiry = fetch_engagements_cache_expiry_timestamp()
+        engagements_df = fetch_and_cache_engagements_data(enterprise_uuid, engagements_cache_expiry)
+
+        start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
+        end_date = serializer.data.get('end_date', datetime.now())
+        response_type = serializer.data.get('response_type', ResponseType.JSON.value)
+
+        LOGGER.info(
+            "Leaderboard data requested for enterprise [%s] from [%s] to [%s]",
+            enterprise_uuid,
+            start_date,
+            end_date,
+        )
+
+        # only include learners who have passed the course
+        enrollments_df = enrollments_df[enrollments_df["has_passed"] == 1]
+
+        # filter enrollments by date
+        enrollments_df = date_filter(start_date, end_date, enrollments_df, "passed_date")
+
+        completions = enrollments_df.groupby(["email"]).size().reset_index()
+        completions.columns = ["email", "course_completions"]
+
+        # filter engagements by date
+        engagements_df = date_filter(start_date, end_date, engagements_df, "activity_date")
+
+        engage = (
+            engagements_df.groupby(["email"])
+            .agg({"is_engaged": ["sum"], "learning_time_seconds": ["sum"]})
+            .reset_index()
+        )
+        engage.columns = ["email", "daily_sessions", "learning_time_seconds"]
+        engage["learning_time_hours"] = round(
+            engage["learning_time_seconds"].astype("float") / 60 / 60, 1
+        )
+
+        # if daily_sessions is 0, set average_session_length to 0 becuase otherwise it will be `inf`
+        engage["average_session_length"] = np.where(
+            engage["daily_sessions"] == 0,
+            0,
+            round(engage["learning_time_hours"] / engage["daily_sessions"].astype("float"), 1)
+        )
+
+        leaderboard_df = engage.merge(completions, on="email", how="left")
+        leaderboard_df = leaderboard_df.sort_values(
+            by=["learning_time_hours", "daily_sessions", "course_completions"],
+            ascending=[False, False, False],
+        )
+
+        # move the aggregated row with email 'null' to the end of the table
+        idx = leaderboard_df.index[leaderboard_df['email'] == 'null']
+        leaderboard_df.loc[idx, 'email'] = 'learners who have not shared consent'
+        leaderboard_df = pd.concat([leaderboard_df.drop(idx), leaderboard_df.loc[idx]])
+
+        # convert `nan` values to `None` because `nan` is not JSON serializable
+        leaderboard_df = leaderboard_df.replace(np.nan, None)
+
+        LOGGER.info(
+            "Leaderboard data prepared for enterprise [%s] from [%s] to [%s]",
+            enterprise_uuid,
+            start_date,
+            end_date,
+        )
+
+        if response_type == ResponseType.CSV.value:
+            filename = f"""Leaderboard, {start_date} - {end_date}.csv"""
+            leaderboard_df = leaderboard_df[
+                [
+                    "email",
+                    "learning_time_hours",
+                    "daily_sessions",
+                    "average_session_length",
+                    "course_completions",
+                ]
+            ]
+            return StreamingHttpResponse(
+                LeaderboardCSVRenderer().render(self._stream_serialized_data(leaderboard_df)),
+                content_type="text/csv",
+                headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+            )
+
+        paginator = self.pagination_class()
+        page = paginator.paginate_queryset(leaderboard_df, request)
+        serialized_data = page.data.to_dict(orient='records')
+        response = paginator.get_paginated_response(serialized_data)
+
+        return response
+
+    def _stream_serialized_data(self, leaderboard_df, chunk_size=50000):
+        """
+        Stream the serialized data.
+        """
+        total_rows = leaderboard_df.shape[0]
+        for start_index in range(0, total_rows, chunk_size):
+            end_index = min(start_index + chunk_size, total_rows)
+            chunk = leaderboard_df.iloc[start_index:end_index]
+            yield from chunk.to_dict(orient='records')

enterprise_data/api/v1/views/enterprise_admin.py

@@ -27,7 +27,7 @@ from enterprise_data.models import (
     EnterpriseAdminSummarizeInsights,
     EnterpriseExecEdLCModulePerformance,
 )
-from enterprise_data.utils import date_filter
+from enterprise_data.utils import date_filter, timer
 
 from .base import EnterpriseViewSetMixin
 
@@ -211,24 +211,25 @@ class EnterpriseAdminAnalyticsSkillsView(APIView):
             csv_data.to_csv(path_or_buf=response, index=False)
             return response
 
-        top_skills = get_skills_chart_data(
-            chart_type=ChartType.BUBBLE,
-            start_date=start_date,
-            end_date=end_date,
-            skills=skills,
-        )
-        top_skills_enrollments = get_skills_chart_data(
-            chart_type=ChartType.TOP_SKILLS_ENROLLMENT,
-            start_date=start_date,
-            end_date=end_date,
-            skills=skills,
-        )
-        top_skills_by_completions = get_skills_chart_data(
-            chart_type=ChartType.TOP_SKILLS_COMPLETION,
-            start_date=start_date,
-            end_date=end_date,
-            skills=skills,
-        )
+        with timer('skills_all_charts_data'):
+            top_skills = get_skills_chart_data(
+                chart_type=ChartType.BUBBLE,
+                start_date=start_date,
+                end_date=end_date,
+                skills=skills,
+            )
+            top_skills_enrollments = get_skills_chart_data(
+                chart_type=ChartType.TOP_SKILLS_ENROLLMENT,
+                start_date=start_date,
+                end_date=end_date,
+                skills=skills,
+            )
+            top_skills_by_completions = get_skills_chart_data(
+                chart_type=ChartType.TOP_SKILLS_COMPLETION,
+                start_date=start_date,
+                end_date=end_date,
+                skills=skills,
+            )
 
         response_data = {
             "top_skills": top_skills.to_dict(orient="records"),

enterprise_data/api/v1/views/enterprise_completions.py

@@ -1,6 +1,7 @@
 """Views for enterprise admin completions analytics."""
 import datetime
 from datetime import datetime, timedelta
+from logging import getLogger
 
 from edx_rbac.decorators import permission_required
 from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
@@ -18,12 +19,14 @@ from enterprise_data.admin_analytics.completions_utils import (
     get_top_courses_by_completions,
     get_top_subjects_by_completions,
 )
-from enterprise_data.admin_analytics.constants import CALCULATION, GRANULARITY
+from enterprise_data.admin_analytics.constants import Calculation, Granularity
 from enterprise_data.admin_analytics.data_loaders import fetch_max_enrollment_datetime
 from enterprise_data.admin_analytics.utils import ChartType, fetch_and_cache_enrollments_data
 from enterprise_data.api.v1 import serializers
 from enterprise_data.api.v1.paginators import AdvanceAnalyticsPagination
-from enterprise_data.utils import date_filter
+from enterprise_data.utils import date_filter, timer
+
+LOGGER = getLogger(__name__)
 
 
 class EnterrpiseAdminCompletionsStatsView(APIView):
@@ -67,39 +70,43 @@ class EnterrpiseAdminCompletionsStatsView(APIView):
             csv_data = {}
 
             if chart_type == ChartType.COMPLETIONS_OVER_TIME.value:
-                csv_data = get_csv_data_for_completions_over_time(
-                    start_date=start_date,
-                    end_date=end_date,
-                    enrollments=enrollments.copy(),
-                    date_agg=serializer.data.get('granularity', GRANULARITY.DAILY.value),
-                    calc=serializer.data.get('calculation', CALCULATION.TOTAL.value),
-                )
+                with timer('completions_over_time_csv_data'):
+                    csv_data = get_csv_data_for_completions_over_time(
+                        start_date=start_date,
+                        end_date=end_date,
+                        enrollments=enrollments.copy(),
+                        date_agg=serializer.data.get('granularity', Granularity.DAILY.value),
+                        calc=serializer.data.get('calculation', Calculation.TOTAL.value),
+                    )
             elif chart_type == ChartType.TOP_COURSES_BY_COMPLETIONS.value:
-                csv_data = get_csv_data_for_top_courses_by_completions(
-                    start_date=start_date, end_date=end_date, enrollments=enrollments.copy()
-                )
+                with timer('top_courses_by_completions_csv_data'):
+                    csv_data = get_csv_data_for_top_courses_by_completions(
+                        start_date=start_date, end_date=end_date, enrollments=enrollments.copy()
+                    )
             elif chart_type == ChartType.TOP_SUBJECTS_BY_COMPLETIONS.value:
-                csv_data = get_csv_data_for_top_subjects_by_completions(
-                    start_date=start_date, end_date=end_date, enrollments=enrollments.copy()
-                )
+                with timer('top_subjects_by_completions_csv_data'):
+                    csv_data = get_csv_data_for_top_subjects_by_completions(
+                        start_date=start_date, end_date=end_date, enrollments=enrollments.copy()
+                    )
             filename = csv_data['filename']
             response['Content-Disposition'] = f'attachment; filename="{filename}"'
             csv_data['data'].to_csv(path_or_buf=response)
             return response
 
-        completions_over_time = get_completions_over_time(
-            start_date=start_date,
-            end_date=end_date,
-            dff=enrollments.copy(),
-            date_agg=serializer.data.get('granularity', GRANULARITY.DAILY.value),
-            calc=serializer.data.get('calculation', CALCULATION.TOTAL.value),
-        )
-        top_courses_by_completions = get_top_courses_by_completions(
-            start_date=start_date, end_date=end_date, dff=enrollments.copy()
-        )
-        top_subjects_by_completions = get_top_subjects_by_completions(
-            start_date=start_date, end_date=end_date, dff=enrollments.copy()
-        )
+        with timer('completions_all_charts_data'):
+            completions_over_time = get_completions_over_time(
+                start_date=start_date,
+                end_date=end_date,
+                dff=enrollments.copy(),
+                date_agg=serializer.data.get('granularity', Granularity.DAILY.value),
+                calc=serializer.data.get('calculation', Calculation.TOTAL.value),
+            )
+            top_courses_by_completions = get_top_courses_by_completions(
+                start_date=start_date, end_date=end_date, dff=enrollments.copy()
+            )
+            top_subjects_by_completions = get_top_subjects_by_completions(
+                start_date=start_date, end_date=end_date, dff=enrollments.copy()
+            )
 
         return Response(
             data={
@@ -153,6 +160,13 @@ class EnterrpiseAdminCompletionsView(APIView):
         )
         end_date = serializer.data.get('end_date', datetime.now())
 
+        LOGGER.info(
+            "Completions data requested for enterprise [%s] from [%s] to [%s]",
+            enterprise_id,
+            start_date,
+            end_date,
+        )
+
         dff = enrollments[enrollments['has_passed'] == 1]
 
         # Date filtering
@@ -162,6 +176,13 @@ class EnterrpiseAdminCompletionsView(APIView):
         dff['passed_date'] = dff['passed_date'].dt.date
         dff = dff.sort_values(by="passed_date", ascending=False).reset_index(drop=True)
 
+        LOGGER.info(
+            "Completions data prepared for enterprise [%s] from [%s] to [%s]",
+            enterprise_id,
+            start_date,
+            end_date,
+        )
+
         if serializer.data.get('response_type') == 'csv':
             response = HttpResponse(content_type='text/csv')
             filename = f"Individual Completions, {start_date} - {end_date}.csv"

enterprise_data/renderers.py

@@ -43,3 +43,17 @@ class IndividualEnrollmentsCSVRenderer(CSVStreamingRenderer):
         'enroll_type',
         'enterprise_enrollment_date',
     ]
+
+
+class LeaderboardCSVRenderer(CSVStreamingRenderer):
+    """
+    Custom streaming csv renderer for advance analytics leaderboard data.
+    """
+
+    header = [
+        'email',
+        'learning_time_hours',
+        'daily_sessions',
+        'average_session_length',
+        'course_completions',
+    ]