edx-enterprise-data 8.0.0__py3-none-any.whl → 8.3.0__py3-none-any.whl

enterprise_data/api/v1/{views.py → views/enterprise_learner.py}

@@ -1,22 +1,15 @@
 """
-Views for enterprise api v1.
+Views for the enterprise learner.
 """
 
 from datetime import date, timedelta
 from logging import getLogger
 from uuid import UUID
 
-from django_filters.rest_framework import DjangoFilterBackend
 from edx_django_utils.cache import TieredCache
-from edx_rbac.decorators import permission_required
-from edx_rbac.mixins import PermissionRequiredMixin
-from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
-from edx_rest_framework_extensions.paginators import DefaultPagination
 from rest_framework import filters, viewsets
 from rest_framework.decorators import action
 from rest_framework.response import Response
-from rest_framework.status import HTTP_200_OK, HTTP_404_NOT_FOUND
-from rest_framework.views import APIView
 
 from django.conf import settings
 from django.core.paginator import Paginator
@@ -27,52 +20,18 @@ from django.http import StreamingHttpResponse
 from django.utils import timezone
 
 from enterprise_data.api.v1 import serializers
-from enterprise_data.constants import ANALYTICS_API_VERSION_1
 from enterprise_data.filters import AuditEnrollmentsFilterBackend, AuditUsersEnrollmentFilterBackend
-from enterprise_data.models import (
-    EnterpriseAdminLearnerProgress,
-    EnterpriseAdminSummarizeInsights,
-    EnterpriseLearner,
-    EnterpriseLearnerEnrollment,
-    EnterpriseOffer,
-)
+from enterprise_data.models import EnterpriseLearner, EnterpriseLearnerEnrollment
 from enterprise_data.paginators import EnterpriseEnrollmentsPagination
 from enterprise_data.renderers import EnrollmentsCSVRenderer
-from enterprise_data.utils import get_cache_key
+from enterprise_data.utils import get_cache_key, subtract_one_month
+
+from .base import EnterpriseViewSetMixin
 
 LOGGER = getLogger(__name__)
 DEFAULT_LEARNER_CACHE_TIMEOUT = 60 * 10
 
 
-def subtract_one_month(original_date):
-    """
-    Returns a date exactly one month prior to the passed in date.
-    """
-    one_day = timedelta(days=1)
-    one_month_earlier = original_date - one_day
-    while one_month_earlier.month == original_date.month or one_month_earlier.day > original_date.day:
-        one_month_earlier -= one_day
-    return one_month_earlier
-
-
-class EnterpriseViewSetMixin(PermissionRequiredMixin):
-    """
-    Base class for all Enterprise view sets.
-    """
-    authentication_classes = (JwtAuthentication,)
-    pagination_class = DefaultPagination
-    permission_required = 'can_access_enterprise'
-    API_VERSION = ANALYTICS_API_VERSION_1
-
-    def paginate_queryset(self, queryset):
-        """
-        Allows no_page query param to skip pagination
-        """
-        if 'no_page' in self.request.query_params:
-            return None
-        return super().paginate_queryset(queryset)
-
-
 class EnterpriseLearnerEnrollmentViewSet(EnterpriseViewSetMixin, viewsets.ReadOnlyModelViewSet):
     """
     Viewset for routes related to Enterprise course enrollments.
@@ -337,37 +296,6 @@ class EnterpriseLearnerEnrollmentViewSet(EnterpriseViewSetMixin, viewsets.ReadOn
         return Response(content)
 
 
-class EnterpriseOfferViewSet(EnterpriseViewSetMixin, viewsets.ReadOnlyModelViewSet):
-    """
-    Viewset for enterprise offers.
-    """
-    serializer_class = serializers.EnterpriseOfferSerializer
-    filter_backends = (filters.OrderingFilter, DjangoFilterBackend,)
-    ordering_fields = '__all__'
-
-    lookup_field = 'offer_id'
-
-    filterset_fields = (
-        'offer_id',
-        'status'
-    )
-
-    def get_object(self):
-        """
-        This ensures that UUIDs with dashes are properly handled when requesting info about offers.
-
-        Related to the work in EnterpriseOfferSerializer with `to_internal_value` and `to_representation`
-        """
-        self.kwargs['offer_id'] = self.kwargs['offer_id'].replace('-', '')
-        return super().get_object()
-
-    def get_queryset(self):
-        enterprise_customer_uuid = self.kwargs['enterprise_id']
-        return EnterpriseOffer.objects.filter(
-            enterprise_customer_uuid=enterprise_customer_uuid,
-        )
-
-
 class EnterpriseLearnerViewSet(EnterpriseViewSetMixin, viewsets.ReadOnlyModelViewSet):
     """
     Viewset for routes related to Enterprise Learners.
@@ -498,40 +426,3 @@ class EnterpriseLearnerCompletedCoursesViewSet(EnterpriseViewSetMixin, viewsets.
             is_consent_granted=True,  # DSC check required
         ).values('user_email').annotate(completed_courses=Count('courserun_key')).order_by('user_email')
         return enrollments
-
-
-class EnterpriseAdminInsightsView(APIView):
-    """
-    API for getting the enterprise admin insights.
-    """
-    authentication_classes = (JwtAuthentication,)
-    http_method_names = ['get']
-
-    @permission_required('can_access_enterprise', fn=lambda request, enterprise_id: enterprise_id)
-    def get(self, request, enterprise_id):
-        """
-        HTTP GET endpoint to retrieve the enterprise admin insights
-        """
-        response_data = {}
-        learner_progress = {}
-        learner_engagement = {}
-
-        try:
-            learner_progress = EnterpriseAdminLearnerProgress.objects.get(enterprise_customer_uuid=enterprise_id)
-            learner_progress = serializers.EnterpriseAdminLearnerProgressSerializer(learner_progress).data
-            response_data['learner_progress'] = learner_progress
-        except EnterpriseAdminLearnerProgress.DoesNotExist:
-            pass
-
-        try:
-            learner_engagement = EnterpriseAdminSummarizeInsights.objects.get(enterprise_customer_uuid=enterprise_id)
-            learner_engagement = serializers.EnterpriseAdminSummarizeInsightsSerializer(learner_engagement).data
-            response_data['learner_engagement'] = learner_engagement
-        except EnterpriseAdminSummarizeInsights.DoesNotExist:
-            pass
-
-        status = HTTP_200_OK
-        if learner_progress == {} and learner_engagement == {}:
-            status = HTTP_404_NOT_FOUND
-
-        return Response(data=response_data, status=status)

enterprise_data/api/v1/views/enterprise_offers.py

@@ -0,0 +1,41 @@
+"""
+Views for enterprise offers
+"""
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import filters, viewsets
+
+from enterprise_data.api.v1 import serializers
+from enterprise_data.models import EnterpriseOffer
+
+from .base import EnterpriseViewSetMixin
+
+
+class EnterpriseOfferViewSet(EnterpriseViewSetMixin, viewsets.ReadOnlyModelViewSet):
+    """
+    Viewset for enterprise offers.
+    """
+    serializer_class = serializers.EnterpriseOfferSerializer
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend,)
+    ordering_fields = '__all__'
+
+    lookup_field = 'offer_id'
+
+    filterset_fields = (
+        'offer_id',
+        'status'
+    )
+
+    def get_object(self):
+        """
+        This ensures that UUIDs with dashes are properly handled when requesting info about offers.
+
+        Related to the work in EnterpriseOfferSerializer with `to_internal_value` and `to_representation`
+        """
+        self.kwargs['offer_id'] = self.kwargs['offer_id'].replace('-', '')
+        return super().get_object()
+
+    def get_queryset(self):
+        enterprise_customer_uuid = self.kwargs['enterprise_id']
+        return EnterpriseOffer.objects.filter(
+            enterprise_customer_uuid=enterprise_customer_uuid,
+        )

enterprise_data/tests/admin_analytics/test_data_loaders.py

@@ -0,0 +1,86 @@
+"""
+Test the utility functions in the admin_analytics app for data loading operations.
+"""
+from uuid import uuid4
+
+import pytest
+from mock import patch
+
+from django.http import Http404
+from django.test import TestCase
+
+from enterprise_data.admin_analytics.data_loaders import (
+    fetch_engagement_data,
+    fetch_enrollment_data,
+    fetch_max_enrollment_datetime,
+)
+from enterprise_data.tests.test_utils import get_dummy_engagements_data, get_dummy_enrollments_data
+
+
+class TestDataLoaders(TestCase):
+    """
+    Test suite for the utility functions in the admin_analytics package for data loading operations.
+    """
+
+    def test_fetch_max_enrollment_datetime(self):
+        """
+        Validate the fetch_max_enrollment_datetime function.
+        """
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query') as mock_run_query:
+            mock_run_query.return_value = [['2024-07-26']]
+
+            max_enrollment_date = fetch_max_enrollment_datetime()
+            self.assertEqual(max_enrollment_date.strftime('%Y-%m-%d'), '2024-07-26')
+
+            # Validate the case where the query returns an empty result.
+            mock_run_query.return_value = []
+            max_enrollment_date = fetch_max_enrollment_datetime()
+            self.assertIsNone(max_enrollment_date)
+
+    def test_fetch_engagement_data(self):
+        """
+        Validate the fetch_engagement_data function.
+        """
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query') as mock_run_query:
+            enterprise_uuid = str(uuid4())
+            mock_run_query.return_value = [
+                list(item.values()) for item in get_dummy_engagements_data(enterprise_uuid, 10)
+            ]
+
+            engagement_data = fetch_engagement_data(enterprise_uuid)
+            self.assertEqual(engagement_data.shape, (10, 14))
+
+    def test_fetch_engagement_data_empty_data(self):
+        """
+        Validate the fetch_engagement_data function behavior when no data is returned from the query.
+        """
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query') as mock_run_query:
+            mock_run_query.return_value = []
+            enterprise_uuid = str(uuid4())
+            with pytest.raises(Http404) as error:
+                fetch_engagement_data(enterprise_uuid)
+            error.value.message = f'No engagement data found for enterprise {enterprise_uuid}'
+
+    def test_fetch_enrollment_data(self):
+        """
+        Validate the fetch_enrollment_data function.
+        """
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query') as mock_run_query:
+            enterprise_uuid = str(uuid4())
+            mock_run_query.return_value = [
+                list(item.values()) for item in get_dummy_enrollments_data(enterprise_uuid)
+            ]
+
+            enrollment_data = fetch_enrollment_data(enterprise_uuid)
+            self.assertEqual(enrollment_data.shape, (10, 21))
+
+    def test_fetch_enrollment_data_empty_data(self):
+        """
+        Validate the fetch_enrollment_data function behavior when no data is returned from the query.
+        """
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query') as mock_run_query:
+            mock_run_query.return_value = []
+            enterprise_uuid = str(uuid4())
+            with pytest.raises(Http404) as error:
+                fetch_enrollment_data(enterprise_uuid)
+            error.value.message = f'No enrollment data found for enterprise {enterprise_uuid}'

enterprise_data/tests/admin_analytics/test_utils.py

@@ -0,0 +1,102 @@
+"""
+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)

enterprise_data/tests/api/v1/views/test_enterprise_admin.py

@@ -0,0 +1,82 @@
+"""
+Test cases for enterprise_admin views
+"""
+from unittest import mock
+
+import ddt
+from mock import patch
+from pytest import mark
+from rest_framework import status
+from rest_framework.reverse import reverse
+from rest_framework.test import APITransactionTestCase
+
+from enterprise_data.tests.mixins import JWTTestMixin
+from enterprise_data.tests.test_utils import (
+    UserFactory,
+    get_dummy_engagements_data,
+    get_dummy_enrollments_data,
+    get_dummy_enterprise_api_data,
+)
+from enterprise_data_roles.constants import ENTERPRISE_DATA_ADMIN_ROLE
+from enterprise_data_roles.models import EnterpriseDataFeatureRole, EnterpriseDataRoleAssignment
+
+
+@ddt.ddt
+@mark.django_db
+class TestEnterpriseAdminAnalyticsAggregatesView(JWTTestMixin, APITransactionTestCase):
+    """
+    Tests for EnterpriseAdminAnalyticsAggregatesView.
+    """
+
+    def setUp(self):
+        """
+        Setup method.
+        """
+        super().setUp()
+        self.user = UserFactory(is_staff=True)
+        role, __ = EnterpriseDataFeatureRole.objects.get_or_create(name=ENTERPRISE_DATA_ADMIN_ROLE)
+        self.role_assignment = EnterpriseDataRoleAssignment.objects.create(
+            role=role,
+            user=self.user
+        )
+        self.client.force_authenticate(user=self.user)
+
+        mocked_get_enterprise_customer = mock.patch(
+            'enterprise_data.filters.EnterpriseApiClient.get_enterprise_customer',
+            return_value=get_dummy_enterprise_api_data()
+        )
+
+        self.mocked_get_enterprise_customer = mocked_get_enterprise_customer.start()
+        self.addCleanup(mocked_get_enterprise_customer.stop)
+        self.enterprise_id = 'ee5e6b3a-069a-4947-bb8d-d2dbc323396c'
+        self.set_jwt_cookie()
+
+    def _mock_run_query(self, query):
+        """
+        mock implementation of run_query.
+        """
+        if 'fact_enrollment_admin_dash' in query:
+            return [
+                list(item.values()) for item in get_dummy_enrollments_data(self.enterprise_id, 15)
+            ]
+        else:
+            return [
+                list(item.values()) for item in get_dummy_engagements_data(self.enterprise_id, 15)
+            ]
+
+    def test_get_admin_analytics_aggregates(self):
+        """
+        Test to get admin analytics aggregates.
+        """
+        url = reverse('v1:enterprise-admin-analytics-aggregates', kwargs={'enterprise_id': self.enterprise_id})
+        with patch('enterprise_data.admin_analytics.data_loaders.run_query', side_effect=self._mock_run_query):
+            response = self.client.get(url)
+            assert response.status_code == status.HTTP_200_OK
+            assert 'enrolls' in response.json()
+            assert 'courses' in response.json()
+            assert 'completions' in response.json()
+            assert 'hours' in response.json()
+            assert 'sessions' in response.json()
+            assert 'last_updated_at' in response.json()
+            assert 'min_enrollment_date' in response.json()
+            assert 'max_enrollment_date' in response.json()

enterprise_data/tests/test_filters.py

@@ -12,7 +12,7 @@ from rest_framework.test import APIRequestFactory, APITestCase
 
 from django.conf import settings
 
-from enterprise_data.api.v1.views import EnterpriseLearnerViewSet
+from enterprise_data.api.v1.views.enterprise_learner import EnterpriseLearnerViewSet
 from enterprise_data.filters import AuditUsersEnrollmentFilterBackend
 from enterprise_data.models import EnterpriseEnrollment, EnterpriseLearnerEnrollment
 from enterprise_data.tests.mixins import JWTTestMixin

enterprise_data/tests/test_utils.py

@@ -345,3 +345,76 @@ def get_dummy_enterprise_api_data(**kwargs):
         'replace_sensitive_sso_username': False
     }
     return enterprise_api_dummy_data
+
+
+def get_dummy_engagements_data(enterprise_uuid: str, count=10):
+    """
+    Utility method to get dummy enrollment's data.
+    """
+    return [
+        {
+            'user_id': FAKER.random_int(min=1),
+            'email': FAKER.email(),
+            'enterprise_customer_uuid': enterprise_uuid,
+            'course_key': FAKER.slug(),
+            'enroll_type': 'verified',
+            'activity_date': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'course_title': ' '.join(FAKER.words(nb=5)).title(),
+            'course_subject': ' '.join(FAKER.words(nb=2)).title(),
+            'is_engaged': FAKER.boolean(),
+            'is_engaged_video': FAKER.boolean(),
+            'is_engaged_forum': FAKER.boolean(),
+            'is_engaged_problem': FAKER.boolean(),
+            'is_active': FAKER.boolean(),
+            'learning_time_seconds': FAKER.random_int(min=1),
+        } for _ in range(count)
+    ]
+
+
+def get_dummy_enrollments_data(enterprise_uuid: str, count=10):
+    """
+    Utility method to get dummy enrollment's data.
+    """
+    return [
+        {
+            'enterprise_customer_name': ' '.join(FAKER.words(nb=2)).title(),
+            'enterprise_customer_uuid': enterprise_uuid,
+            'lms_enrollment_id': FAKER.random_int(min=1),
+            'user_id': FAKER.random_int(min=1),
+            'email': FAKER.email(),
+            'course_key': FAKER.slug(),
+            'courserun_key': FAKER.slug(),
+            'course_id': FAKER.slug(),
+            'course_subject': ' '.join(FAKER.words(nb=2)).title(),
+            'course_title': ' '.join(FAKER.words(nb=5)).title(),
+            'enterprise_enrollment_date': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'lms_enrollment_mode': 'verified',
+            'enroll_type': 'verified',
+            'program_title': ' '.join(FAKER.words(nb=2)).title(),
+            'date_certificate_awarded': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'grade_percent': FAKER.pyfloat(right_digits=2, min_value=0, max_value=1),
+            'cert_awarded': FAKER.boolean(),
+            'date_certificate_created_raw': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'passed_date_raw': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'passed_date': FAKER.date_time_between(
+                start_date='-2M',
+                end_date='+2M',
+            ),
+            'has_passed': FAKER.boolean(),
+        } for _ in range(count)
+    ]

enterprise_data/utils.py

@@ -1,9 +1,14 @@
 """
 Utility functions for Enterprise Data app.
 """
-
 import hashlib
 import random
+import time
+from datetime import timedelta
+from functools import wraps
+from logging import getLogger
+
+LOGGER = getLogger(__name__)
 
 
 def get_cache_key(**kwargs):
@@ -35,3 +40,45 @@ def get_unique_id():
     Return a unique 32 bit integer.
     """
     return random.getrandbits(32)
+
+
+def subtract_one_month(original_date):
+    """
+    Return a date exactly one month prior to the passed in date.
+    """
+    one_day = timedelta(days=1)
+    one_month_earlier = original_date - one_day
+    while one_month_earlier.month == original_date.month or one_month_earlier.day > original_date.day:
+        one_month_earlier -= one_day
+    return one_month_earlier
+
+
+def timeit(func):
+    """
+    Measure time taken by a function.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        LOGGER.info(f'Time taken by {func.__name__}: {end - start} seconds')
+        return result
+
+    return wrapper
+
+
+def date_filter(start, end, data_frame, date_column):
+    """
+    Filter a pandas DataFrame by date range.
+
+    Arguments:
+        start (DatetimeScalar | NaTType | None): The start date.
+        end (DatetimeScalar | NaTType | None): The end date.
+        data_frame (pandas.DataFrame): The DataFrame to filter.
+        date_column (str): The name of the date column.
+
+    Returns:
+        (pandas.DataFrame): The filtered DataFrame.
+    """
+    return data_frame[(start <= data_frame[date_column]) & (data_frame[date_column] <= end)]

enterprise_reporting/clients/__init__.py

@@ -2,18 +2,17 @@
 Clients used to access third party systems.
 """
 
+import logging
 import os
 from datetime import datetime, timedelta
 from functools import wraps
 from urllib.parse import parse_qs, urljoin, urlparse
-from edx_rest_api_client.client import get_oauth_access_token
 
-import logging
 import requests
+from edx_rest_api_client.client import get_oauth_access_token
 
 from enterprise_reporting.utils import retry_on_exception
 
-
 LOGGER = logging.getLogger(__name__)
 
 

enterprise_reporting/external_resource_link_report.py

@@ -3,13 +3,13 @@ External Resource Link Report Generation Code.
 """
 
 
-from collections import Counter
-from datetime import date
-import operator
 import logging
+import operator
 import os
 import re
 import sys
+from collections import Counter
+from datetime import date
 from urllib.parse import urlparse
 
 from py2neo import Graph

enterprise_reporting/tests/test_clients.py

@@ -1,9 +1,9 @@
 """
 Tests for clients in enterprise_reporting.
 """
+from datetime import datetime, timedelta
 from unittest.mock import Mock, patch
 from urllib.parse import urljoin
-from datetime import datetime, timedelta
 
 import responses