edx-enterprise-data 9.1.1__py3-none-any.whl → 9.2.0__py3-none-any.whl

enterprise_data/admin_analytics/utils.py

@@ -1,180 +0,0 @@
-"""
-Utility functions for fetching data from the database.
-"""
-from datetime import datetime, timedelta
-from enum import Enum
-from logging import getLogger
-
-from edx_django_utils.cache import TieredCache, get_cache_key
-
-from enterprise_data.admin_analytics.constants import Calculation, Granularity
-from enterprise_data.admin_analytics.data_loaders import (
-    fetch_engagement_data,
-    fetch_enrollment_data,
-    fetch_max_enrollment_datetime,
-)
-
-LOGGER = getLogger(__name__)
-
-
-class ChartType(Enum):
-    """
-    Chart types.
-    """
-    COMPLETIONS_OVER_TIME = 'completions_over_time'
-    TOP_COURSES_BY_COMPLETIONS = 'top_courses_by_completions'
-    TOP_SUBJECTS_BY_COMPLETIONS = 'top_subjects_by_completions'
-
-
-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
-
-
-def fetch_engagements_cache_expiry_timestamp():
-    """Calculate cache expiry timestamp"""
-    # TODO: Implement correct cache expiry logic for `engagements` data.
-    #       Current cache expiry logic is based on `enterprise_learner_enrollment` table,
-    #       Which has nothing to do with the `engagements` data. Instead cache expiry should
-    #       be based on `fact_enrollment_engagement_day_admin_dash` table. Currently we have
-    #       no timestamp in `fact_enrollment_engagement_day_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
-
-
-def granularity_aggregation(level, group, date, data_frame, aggregation_type="count"):
-    """Aggregate data based on granularity"""
-    df = data_frame
-
-    period_mapping = {
-        Granularity.WEEKLY.value: "W",
-        Granularity.MONTHLY.value: "M",
-        Granularity.QUARTERLY.value: "Q"
-    }
-
-    if level in period_mapping:
-        df[date] = df[date].dt.to_period(period_mapping[level]).dt.start_time
-
-    agg_column_name = "count"
-    if aggregation_type == "count":
-        df = df.groupby(group).size().reset_index()
-    elif aggregation_type == "sum":
-        df = df.groupby(group).sum().reset_index()
-        agg_column_name = "sum"
-
-    df.columns = group + [agg_column_name]
-    return df
-
-
-def calculation_aggregation(calc, data_frame, aggregation_type="count"):
-    """Aggregate data based on calculation"""
-    df = data_frame
-
-    window_mapping = {
-        Calculation.MOVING_AVERAGE_3_PERIOD.value: 3,
-        Calculation.MOVING_AVERAGE_7_PERIOD.value: 7,
-    }
-
-    aggregation_column = "count" if aggregation_type == "count" else "sum"
-
-    if calc == Calculation.RUNNING_TOTAL.value:
-        df[aggregation_column] = df.groupby("enroll_type")[aggregation_column].cumsum()
-    elif calc in [Calculation.MOVING_AVERAGE_3_PERIOD.value, Calculation.MOVING_AVERAGE_7_PERIOD.value]:
-        df[aggregation_column] = (
-            df.groupby("enroll_type")[aggregation_column]
-            .rolling(window_mapping[calc])
-            .mean()
-            .droplevel(level=[0])
-        )
-
-    return df
-
-
-def get_cache_timeout(cache_expiry):
-    """
-    Helper method to calculate cache timeout in seconds.
-
-    Arguments:
-        cache_expiry (datetime): Datetime object denoting the cache expiry.
-
-    Returns:
-        (int): Cache timeout in seconds.
-    """
-    now = datetime.now()
-    cache_timeout = 0
-    if cache_expiry > now:
-        # Calculate cache expiry in seconds from now.
-        cache_timeout = (cache_expiry - now).seconds
-
-    return cache_timeout
-
-
-def fetch_and_cache_enrollments_data(enterprise_id, cache_expiry):
-    """
-    Helper method to fetch and cache enrollments data.
-
-    Arguments:
-        enterprise_id (str): UUID of the enterprise customer in string format.
-        cache_expiry (datetime): Datetime object denoting the cache expiry.
-
-    Returns:
-        (pandas.DataFrame): The enrollments data.
-    """
-    cache_key = get_cache_key(
-        resource='enterprise-admin-analytics-aggregates-enrollments',
-        enterprise_customer=enterprise_id,
-    )
-    cached_response = TieredCache.get_cached_response(cache_key)
-
-    if cached_response.is_found:
-        LOGGER.info(f"Enrollments data found in cache for Enterprise [{enterprise_id}]")
-        return cached_response.value
-    else:
-        enrollments = fetch_enrollment_data(enterprise_id)
-        TieredCache.set_all_tiers(
-            cache_key, enrollments, get_cache_timeout(cache_expiry)
-        )
-        return enrollments
-
-
-def fetch_and_cache_engagements_data(enterprise_id, cache_expiry):
-    """
-    Helper method to fetch and cache engagements data.
-
-    Arguments:
-        enterprise_id (str): UUID of the enterprise customer in string format.
-        cache_expiry (datetime): Datetime object denoting the cache expiry.
-
-    Returns:
-        (pandas.DataFrame): The engagements data.
-    """
-    cache_key = get_cache_key(
-        resource='enterprise-admin-analytics-aggregates-engagements',
-        enterprise_customer=enterprise_id,
-    )
-    cached_response = TieredCache.get_cached_response(cache_key)
-
-    if cached_response.is_found:
-        LOGGER.info(f"Engagements data found in cache for Enterprise [{enterprise_id}]")
-        return cached_response.value
-    else:
-        engagements = fetch_engagement_data(enterprise_id)
-        TieredCache.set_all_tiers(
-            cache_key, engagements, get_cache_timeout(cache_expiry)
-        )
-        return engagements

enterprise_data/api/v1/paginators.py

@@ -1,121 +0,0 @@
-"""Custom paginator for the Advance Analytics API."""
-
-import math
-from dataclasses import dataclass
-from typing import Any
-
-from rest_framework.exceptions import NotFound
-from rest_framework.pagination import PageNumberPagination
-from rest_framework.response import Response
-
-
-@dataclass
-class Page:
-    """
-    A class representing a single page of paginated data.
-
-    Attributes:
-        data (Any): The data contained in the current page.
-        count (int): The total number of items across all pages.
-        num_pages (int): The total number of pages.
-        current_page (int): The current page number.
-    """
-    data: Any
-    count: int
-    num_pages: int
-    current_page: int
-
-    def has_next(self):
-        """
-        Check if there is a next page.
-
-        Returns:
-            bool: True if there is a next page, False otherwise.
-        """
-        return self.current_page < self.num_pages
-
-    def has_previous(self):
-        """
-        Check if there is a previous page.
-
-        Returns:
-            bool: True if there is a previous page, False otherwise.
-        """
-        return self.current_page > 1
-
-    def next_page_number(self):
-        """
-        Get the next page number.
-
-        Returns:
-            int: The next page number.
-        """
-        return self.current_page + 1
-
-    def previous_page_number(self):
-        """
-        Get the previous page number.
-
-        Returns:
-            int: The previous page number.
-        """
-        return self.current_page - 1
-
-
-class AdvanceAnalyticsPagination(PageNumberPagination):
-    """
-    Custom pagination class for advanced analytics.
-
-    Attributes:
-        page_size_query_param (str): The query parameter for the page size.
-        page_size (int): The default page size.
-        max_page_size (int): The maximum allowed page size.
-    """
-    page_size_query_param = "page_size"
-    page_size = 50
-    max_page_size = 100
-
-    def paginate_queryset(self, queryset, request, view=None):
-        """
-        Paginate a given dataframe based on the request parameters.
-
-        Args:
-            queryset (pd.DataFrame): The dataframe to paginate.
-            request (Request): The request object containing query parameters.
-            view (View, optional): The view that is calling the paginator.
-
-        Returns:
-            Page: A Page object. `data` attribute of the object will contain the paginated data.
-        """
-        dataframe = queryset
-
-        self.request = request  # pylint: disable=attribute-defined-outside-init
-        page_size = self.get_page_size(request)
-        if not page_size:
-            return None
-
-        total_rows = dataframe.shape[0]
-        num_pages = math.ceil(total_rows / page_size)
-
-        page_number = int(request.query_params.get(self.page_query_param) or 1)
-        if page_number <= 0 or page_number > num_pages:
-            raise NotFound('Invalid page.')
-
-        start_index = (page_number - 1) * page_size
-        end_index = min(start_index + page_size, total_rows)
-        data_frame_page = dataframe.iloc[start_index:end_index]
-
-        # pylint: disable=attribute-defined-outside-init
-        self.page = Page(data_frame_page, total_rows, num_pages, page_number)
-
-        return self.page
-
-    def get_paginated_response(self, data):
-        return Response({
-            'next': self.get_next_link(),
-            'previous': self.get_previous_link(),
-            'count': self.page.count,
-            'num_pages': self.page.num_pages,
-            'current_page': self.page.current_page,
-            'results': data
-        })

enterprise_data/tests/admin_analytics/test_utils.py

@@ -1,102 +0,0 @@
-"""
-Test the utility functions in the admin_analytics app.
-"""
-from datetime import datetime, timedelta
-
-from mock import patch
-
-from django.test import TestCase
-
-from enterprise_data.admin_analytics.utils import (
-    fetch_and_cache_engagements_data,
-    fetch_and_cache_enrollments_data,
-    get_cache_timeout,
-)
-
-
-class TestUtils(TestCase):
-    """
-    Test suite for the utility functions in the admin_analytics package.
-    """
-
-    def test_get_cache_timeout(self):
-        """
-        Validate the get_cache_timeout function.
-        """
-        now = datetime.now().replace(microsecond=0)
-        with patch('enterprise_data.admin_analytics.utils.datetime') as mock_datetime:
-            mock_datetime.now.return_value = now
-            cache_expiry = now
-            self.assertEqual(get_cache_timeout(cache_expiry), 0)
-
-            cache_expiry = now + timedelta(seconds=10)
-            self.assertEqual(get_cache_timeout(cache_expiry), 10)
-
-            cache_expiry = now + timedelta(seconds=100)
-            self.assertEqual(get_cache_timeout(cache_expiry), 100)
-
-            # Validate the case where cache_expiry is in the past.
-            cache_expiry = now - timedelta(seconds=10)
-            self.assertEqual(get_cache_timeout(cache_expiry), 0)
-
-    def test_fetch_and_cache_enrollments_data(self):
-        """
-        Validate the fetch_and_cache_enrollments_data function.
-        """
-        with patch('enterprise_data.admin_analytics.utils.fetch_enrollment_data') as mock_fetch_enrollment_data:
-            with patch('enterprise_data.admin_analytics.utils.TieredCache') as mock_tiered_cache:
-                # Simulate the scenario where the data is not found in the cache.
-                mock_tiered_cache.get_cached_response.return_value.is_found = False
-                mock_fetch_enrollment_data.return_value = 'enrollments'
-
-                enrollments = fetch_and_cache_enrollments_data('enterprise_id', datetime.now() + timedelta(seconds=10))
-                self.assertEqual(enrollments, 'enrollments')
-                self.assertEqual(mock_tiered_cache.get_cached_response.call_count, 1)
-                self.assertEqual(mock_tiered_cache.set_all_tiers.call_count, 1)
-
-    def test_fetch_and_cache_enrollments_data_with_data_cache_found(self):
-        """
-        Validate the fetch_and_cache_enrollments_data function.
-        """
-        with patch('enterprise_data.admin_analytics.utils.fetch_enrollment_data') as mock_fetch_enrollment_data:
-            with patch('enterprise_data.admin_analytics.utils.TieredCache') as mock_tiered_cache:
-                # Simulate the scenario where the data is found in the cache.
-                mock_tiered_cache.get_cached_response.return_value.is_found = True
-                mock_tiered_cache.get_cached_response.return_value.value = 'cached-enrollments'
-                mock_fetch_enrollment_data.return_value = 'enrollments'
-
-                enrollments = fetch_and_cache_enrollments_data('enterprise_id', datetime.now() + timedelta(seconds=10))
-                self.assertEqual(enrollments, 'cached-enrollments')
-                self.assertEqual(mock_tiered_cache.get_cached_response.call_count, 1)
-                self.assertEqual(mock_tiered_cache.set_all_tiers.call_count, 0)
-
-    def test_fetch_and_cache_engagements_data(self):
-        """
-        Validate the fetch_and_cache_engagements_data function.
-        """
-        with patch('enterprise_data.admin_analytics.utils.fetch_engagement_data') as mock_fetch_engagement_data:
-            with patch('enterprise_data.admin_analytics.utils.TieredCache') as mock_tiered_cache:
-                # Simulate the scenario where the data is not found in the cache.
-                mock_tiered_cache.get_cached_response.return_value.is_found = False
-                mock_fetch_engagement_data.return_value = 'engagements'
-
-                enrollments = fetch_and_cache_engagements_data('enterprise_id', datetime.now() + timedelta(seconds=10))
-                self.assertEqual(enrollments, 'engagements')
-                self.assertEqual(mock_tiered_cache.get_cached_response.call_count, 1)
-                self.assertEqual(mock_tiered_cache.set_all_tiers.call_count, 1)
-
-    def test_fetch_and_cache_engagements_data_with_data_cache_found(self):
-        """
-        Validate the fetch_and_cache_engagements_data function.
-        """
-        with patch('enterprise_data.admin_analytics.utils.fetch_engagement_data') as mock_fetch_engagement_data:
-            with patch('enterprise_data.admin_analytics.utils.TieredCache') as mock_tiered_cache:
-                # Simulate the scenario where the data is found in the cache.
-                mock_tiered_cache.get_cached_response.return_value.is_found = True
-                mock_tiered_cache.get_cached_response.return_value.value = 'cached-engagements'
-                mock_fetch_engagement_data.return_value = 'engagements'
-
-                enrollments = fetch_and_cache_engagements_data('enterprise_id', datetime.now() + timedelta(seconds=10))
-                self.assertEqual(enrollments, 'cached-engagements')
-                self.assertEqual(mock_tiered_cache.get_cached_response.call_count, 1)
-                self.assertEqual(mock_tiered_cache.set_all_tiers.call_count, 0)