edx-enterprise-data 8.11.0__py3-none-any.whl → 8.12.0__py3-none-any.whl

enterprise_data/api/v1/views/analytics_enrollments.py

@@ -1,52 +1,71 @@
-"""Advance Analytics for Enrollments"""
+"""
+Advance Analytics for API endpoints to fetch enterprise enrollments data.
+"""
 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
+from rest_framework.decorators import action
 from rest_framework.response import Response
-from rest_framework.views import APIView
+from rest_framework.viewsets import ViewSet
 
-from django.http import HttpResponse, StreamingHttpResponse
+from django.http import StreamingHttpResponse
 
-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.admin_analytics.constants import ResponseType
+from enterprise_data.admin_analytics.database.tables import FactEnrollmentAdminDashTable
 from enterprise_data.api.v1.paginators import AdvanceAnalyticsPagination
 from enterprise_data.api.v1.serializers import (
     AdvanceAnalyticsEnrollmentStatsSerializer,
     AdvanceAnalyticsQueryParamSerializer,
 )
+from enterprise_data.api.v1.views.base import AnalyticsPaginationMixin
 from enterprise_data.renderers import IndividualEnrollmentsCSVRenderer
-from enterprise_data.utils import date_filter, timer
+from enterprise_data.utils import timer
 
 LOGGER = getLogger(__name__)
 
 
-class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
+class AdvanceAnalyticsEnrollmentsView(AnalyticsPaginationMixin, ViewSet):
     """
-    API for getting the advance analytics individual enrollments data.
+    View to handle requests for enterprise enrollments data.
+
+    Here is the list of URLs that are handled by this view:
+    1. `enterprise_data_api_v1.enterprise-learner-enrollment-list`: Get individual enrollment data.
+    2. `enterprise_data_api_v1.enterprise-learner-enrollment-stats`: Get enrollment stats data.
     """
     authentication_classes = (JwtAuthentication,)
     pagination_class = AdvanceAnalyticsPagination
-    http_method_names = ['get']
+    http_method_names = ('get', )
 
     @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
-    def get(self, request, enterprise_uuid):
-        """Get individual enrollments data"""
+    def list(self, request, enterprise_uuid):
+        """
+        Get individual enrollments data for the enterprise.
+        """
         serializer = AdvanceAnalyticsQueryParamSerializer(data=request.GET)
         serializer.is_valid(raise_exception=True)
-
-        cache_expiry = fetch_enrollments_cache_expiry_timestamp()
-        enrollments_df = fetch_and_cache_enrollments_data(enterprise_uuid, cache_expiry)
+        min_enrollment_date, _ = FactEnrollmentAdminDashTable().get_enrollment_date_range(
+            enterprise_uuid,
+        )
 
         # get values from query params or use default values
-        start_date = serializer.data.get('start_date', enrollments_df.enterprise_enrollment_date.min())
+        start_date = serializer.data.get('start_date', min_enrollment_date)
         end_date = serializer.data.get('end_date', datetime.now())
+        page = serializer.data.get('page', 1)
+        page_size = serializer.data.get('page_size', 100)
+        enrollments = FactEnrollmentAdminDashTable().get_all_enrollments(
+            enterprise_customer_uuid=enterprise_uuid,
+            start_date=start_date,
+            end_date=end_date,
+            limit=page_size,
+            offset=(page - 1) * page_size,
+        )
+        total_count = FactEnrollmentAdminDashTable().get_enrollment_count(
+            enterprise_customer_uuid=enterprise_uuid,
+            start_date=start_date,
+            end_date=end_date,
+        )
         response_type = request.query_params.get('response_type', ResponseType.JSON.value)
 
         LOGGER.info(
@@ -56,333 +75,72 @@ class AdvanceAnalyticsIndividualEnrollmentsView(APIView):
             end_date,
         )
 
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        # select only the columns that will be in the table.
-        enrollments = enrollments[
-            [
-                "email",
-                "course_title",
-                "course_subject",
-                "enroll_type",
-                "enterprise_enrollment_date",
-            ]
-        ]
-        enrollments["enterprise_enrollment_date"] = enrollments["enterprise_enrollment_date"].dt.date
-        enrollments = enrollments.sort_values(by="enterprise_enrollment_date", ascending=False).reset_index(drop=True)
-
-        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)),
+                IndividualEnrollmentsCSVRenderer().render(self._stream_serialized_data(
+                    enterprise_uuid, start_date, end_date, total_count
+                )),
                 content_type="text/csv",
                 headers={"Content-Disposition": f'attachment; filename="{filename}"'},
             )
 
-        paginator = self.pagination_class()
-        page = paginator.paginate_queryset(enrollments, request)
-        serialized_data = page.data.to_dict(orient='records')
-        response = paginator.get_paginated_response(serialized_data)
-
-        return response
+        return self.get_paginated_response(
+            request=request,
+            records=enrollments,
+            page=page,
+            page_size=page_size,
+            total_count=total_count,
+        )
 
-    def _stream_serialized_data(self, enrollments, chunk_size=50000):
+    @staticmethod
+    def _stream_serialized_data(enterprise_uuid, start_date, end_date, total_count, page_size=50000):
         """
         Stream the serialized data.
         """
-        total_rows = enrollments.shape[0]
-        for start_index in range(0, total_rows, chunk_size):
-            end_index = min(start_index + chunk_size, total_rows)
-            chunk = enrollments.iloc[start_index:end_index]
-            yield from chunk.to_dict(orient='records')
-
-
-class AdvanceAnalyticsEnrollmentStatsView(APIView):
-    """
-    API for getting the advance analytics enrollment chart stats.
-    """
-    authentication_classes = (JwtAuthentication,)
-    http_method_names = ['get']
+        offset = 0
+        while offset < total_count:
+            enrollments = FactEnrollmentAdminDashTable().get_all_enrollments(
+                enterprise_customer_uuid=enterprise_uuid,
+                start_date=start_date,
+                end_date=end_date,
+                limit=page_size,
+                offset=offset,
+            )
+            yield from enrollments
+            offset += page_size
 
     @permission_required('can_access_enterprise', fn=lambda request, enterprise_uuid: enterprise_uuid)
-    def get(self, request, enterprise_uuid):  # lint-amnesty, pylint: disable=inconsistent-return-statements
-        """Get enrollment chart stats"""
-        serializer = AdvanceAnalyticsEnrollmentStatsSerializer(data=request.GET)
-        serializer.is_valid(raise_exception=True)
-
-        cache_expiry = fetch_enrollments_cache_expiry_timestamp()
-        enrollments_df = fetch_and_cache_enrollments_data(enterprise_uuid, cache_expiry)
-
-        # 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)
-        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)
-
-        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):
-        """
-        Common method for constructing enrollments over time data.
-
-        Arguments:
-            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
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        # aggregate enrollments by granularity
-        enrollments = granularity_aggregation(
-            level=granularity,
-            group=["enterprise_enrollment_date", "enroll_type"],
-            date="enterprise_enrollment_date",
-            data_frame=enrollments,
-        )
-
-        # aggregate enrollments by calculation
-        enrollments = calculation_aggregation(calc=calculation, data_frame=enrollments)
-
-        return enrollments
-
-    def construct_enrollments_over_time(self, enrollments_df, start_date, end_date, granularity, calculation):
-        """
-        Construct enrollments over time data.
-
-        Arguments:
-            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
-        """
-        enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
-
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_enrollments_over_time_csv(self, enrollments_df, start_date, end_date, granularity, calculation):
-        """
-        Construct enrollments over time CSV.
-
-        Arguments:
-            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
-        """
-        enrollments = self.enrollments_over_time_common(enrollments_df, start_date, end_date, granularity, calculation)
-
-        enrollments = enrollments.pivot(
-            index="enterprise_enrollment_date", columns="enroll_type", values="count"
-        )
-
-        filename = f"Enrollment Timeseries, {start_date} - {end_date} ({granularity} {calculation}).csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def top_courses_by_enrollments_common(self, enrollments_df, start_date, end_date, group_by_columns, columns):
-        """
-        Common method for constructing top courses by enrollments data.
-
-        Arguments:
-            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'
-            group_by_columns {list} -- List of columns to group by
-            columns {list} -- List of column for the final result
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        courses = list(
-            enrollments.groupby(["course_key"]).size().sort_values(ascending=False)[:10].index
-        )
-
-        enrollments = (
-            enrollments[enrollments.course_key.isin(courses)]
-            .groupby(group_by_columns)
-            .size()
-            .reset_index()
-        )
-        enrollments.columns = columns
-
-        return enrollments
-
-    def construct_top_courses_by_enrollments(self, enrollments_df, start_date, end_date):
+    @action(detail=False, methods=['get'], name='Charts Data', url_path='stats')
+    def stats(self, request, enterprise_uuid):
         """
-        Construct top courses by enrollments data.
+        Get data to populate enterprise enrollment charts.
 
-        Arguments:
-            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'
+        Here is the list of the charts and their corresponding data:
+        1. `enrollments_over_time`: This will show time series data of enrollments over time.
+        2. `top_courses_by_enrollments`: This will show the top courses by enrollments.
+        3. `top_subjects_by_enrollments`: This will show the top subjects by enrollments.
         """
-        group_by_columns = ["course_key", "enroll_type"]
-        columns = ["course_key", "enroll_type", "count"]
-        enrollments = self.top_courses_by_enrollments_common(
-            enrollments_df,
-            start_date,
-            end_date,
-            group_by_columns,
-            columns
-        )
-
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_top_courses_by_enrollments_csv(self, enrollments_df, start_date, end_date):
-        """
-        Construct top courses by enrollments CSV.
-
-        Arguments:
-            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'
-        """
-        group_by_columns = ["course_key", "course_title", "enroll_type"]
-        columns = ["course_key", "course_title", "enroll_type", "count"]
-        enrollments = self.top_courses_by_enrollments_common(
-            enrollments_df,
-            start_date,
-            end_date,
-            group_by_columns,
-            columns
-        )
-
-        enrollments = enrollments.pivot(
-            index=["course_key", "course_title"], columns="enroll_type", values="count"
-        )
-
-        filename = f"Top 10 Courses, {start_date} - {end_date}.csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def top_subjects_by_enrollments_common(self, enrollments_df, start_date, end_date):
-        """
-        Common method for constructing top subjects by enrollments data.
-
-        Arguments:
-            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'
-        """
-        # filter enrollments by date
-        enrollments = date_filter(start_date, end_date, enrollments_df, "enterprise_enrollment_date")
-
-        subjects = list(
-            enrollments.groupby(["course_subject"]).size().sort_values(ascending=False)[:10].index
-        )
+        serializer = AdvanceAnalyticsEnrollmentStatsSerializer(data=request.GET)
+        serializer.is_valid(raise_exception=True)
 
-        enrollments = (
-            enrollments[enrollments.course_subject.isin(subjects)]
-            .groupby(["course_subject", "enroll_type"])
-            .size()
-            .reset_index()
+        min_enrollment_date, _ = FactEnrollmentAdminDashTable().get_enrollment_date_range(
+            enterprise_uuid,
         )
-        enrollments.columns = ["course_subject", "enroll_type", "count"]
-
-        return enrollments
-
-    def construct_top_subjects_by_enrollments(self, enrollments_df, start_date, end_date):
-        """
-        Construct top subjects by enrollments data.
-
-        Arguments:
-            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'
-        """
-        enrollments = self.top_subjects_by_enrollments_common(enrollments_df, start_date, end_date)
-        # convert dataframe to a list of records
-        return enrollments.to_dict(orient='records')
-
-    def construct_top_subjects_by_enrollments_csv(self, enrollments_df, start_date, end_date):
-        """
-        Construct top subjects by enrollments CSV.
-
-        Arguments:
-            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'
-        """
-        enrollments = self.top_subjects_by_enrollments_common(enrollments_df, start_date, end_date)
-        enrollments = enrollments.pivot(index="course_subject", columns="enroll_type", values="count")
-
-        filename = f"Top 10 Subjects by Enrollment, {start_date} - {end_date}.csv"
-        return self.construct_csv_response(enrollments, filename)
-
-    def construct_csv_response(self, enrollments, filename):
-        """
-        Construct CSV response.
-
-        Arguments:
-            enrollments {DataFrame} -- DataFrame of enrollments
-            filename {str} -- Filename for the CSV
-        """
-        response = HttpResponse(content_type='text/csv')
-        response['Content-Disposition'] = f'attachment; filename="{filename}"'
-        response['Access-Control-Expose-Headers'] = 'Content-Disposition'
-        enrollments.to_csv(path_or_buf=response)
-
-        return response
+        # get values from query params or use default
+        start_date = serializer.data.get('start_date', min_enrollment_date)
+        end_date = serializer.data.get('end_date', datetime.now())
+        with timer('construct_enrollment_all_stats'):
+            data = {
+                'enrollments_over_time': FactEnrollmentAdminDashTable().get_enrolment_time_series_data(
+                    enterprise_uuid, start_date, end_date
+                ),
+                'top_courses_by_enrollments': FactEnrollmentAdminDashTable().get_top_courses_by_enrollments(
+                    enterprise_uuid, start_date, end_date,
+                ),
+                'top_subjects_by_enrollments': FactEnrollmentAdminDashTable().get_top_subjects_by_enrollments(
+                    enterprise_uuid, start_date, end_date,
+                ),
+            }
+        return Response(data)

enterprise_data/api/v1/views/base.py

@@ -1,9 +1,14 @@
 """
 Base views for enterprise data api v1.
 """
+import math
+
 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.exceptions import NotFound
+from rest_framework.response import Response
+from rest_framework.utils.urls import remove_query_param, replace_query_param
 
 from enterprise_data.constants import ANALYTICS_API_VERSION_1
 
@@ -24,3 +29,77 @@ class EnterpriseViewSetMixin(PermissionRequiredMixin):
         if 'no_page' in self.request.query_params:
             return None
         return super().paginate_queryset(queryset)
+
+
+class AnalyticsPaginationMixin:
+    """
+    Mixin that provides utility methods to allow pagination on views.
+    """
+    page_query_param = 'page'
+    page_size_query_param = 'page_size'
+
+    def get_next_link(self, request, page_number, page_count):
+        """
+        Get the link to the next page.
+
+        Arguments:
+            request (Request): The request object.
+            page_number (int): The current page number.
+            page_count (int): The total number of pages.
+
+        Returns:
+            str: The link to the next page.
+        """
+        if page_number >= page_count:
+            return None
+        return replace_query_param(
+            url=request.build_absolute_uri(),
+            key=self.page_query_param,
+            val=page_number + 1,
+        )
+
+    def get_previous_link(self, request, page_number):
+        """
+        Get the link to the previous page.
+
+        Arguments:
+            request (Request): The request object.
+            page_number (int): The current page number.
+
+        Returns:
+            str: The link to the previous page.
+        """
+        if page_number <= 1:
+            return None
+        url = request.build_absolute_uri()
+        next_page = page_number - 1
+        if next_page == 1:
+            return remove_query_param(url, self.page_query_param)
+        return replace_query_param(url, self.page_query_param, next_page)
+
+    def get_paginated_response(self, request, records, page, page_size, total_count):
+        """
+        Get pagination data.
+
+        Arguments:
+            request (Request): The request object.
+            records (list): The records to return.
+            page (int): The current page number.
+            page_size (int): The number of records per page.
+            total_count (int): The total number of records
+
+        Returns:
+            (Response): The pagination data.
+        """
+        page_count = math.ceil(total_count / page_size)
+        if page <= 0 or page > page_count:
+            raise NotFound('Invalid page.')
+
+        return Response({
+            'next': self.get_next_link(request, page, page_count),
+            'previous': self.get_previous_link(request, page),
+            'count': total_count,
+            'num_pages': page_count,
+            'current_page': page,
+            'results': records,
+        })

enterprise_data/api/v1/views/enterprise_admin.py

@@ -95,6 +95,8 @@ class EnterpriseAdminAnalyticsAggregatesView(APIView):
         """
         HTTP GET endpoint to retrieve the enterprise admin aggregate data.
         """
+        # Validate the enterprise_id
+        enterprise_id = enterprise_id.replace('-', '')
         serializer = serializers.AdminAnalyticsAggregatesQueryParamsSerializer(
             data=request.GET
         )
@@ -106,7 +108,7 @@ class EnterpriseAdminAnalyticsAggregatesView(APIView):
         )
 
         start_date = serializer.data.get(
-            'start_date', min_enrollment_date.date()
+            'start_date', min_enrollment_date
         )
         end_date = serializer.data.get('end_date', datetime.today())
 
@@ -128,8 +130,8 @@ class EnterpriseAdminAnalyticsAggregatesView(APIView):
                 'hours': hours,
                 'sessions': sessions,
                 'last_updated_at': last_updated_at.date() if last_updated_at else None,
-                'min_enrollment_date': min_enrollment_date.date(),
-                'max_enrollment_date': max_enrollment_date.date(),
+                'min_enrollment_date': min_enrollment_date,
+                'max_enrollment_date': max_enrollment_date,
             },
             status=HTTP_200_OK,
         )

enterprise_data/tests/admin_analytics/mock_analytics_data.py

@@ -384,18 +384,6 @@ def engagements_dataframe():
     return engagements
 
 
-def enrollments_csv_content():
-    """Return the CSV content of enrollments."""
-    return (
-        b'email,course_title,course_subject,enroll_type,enterprise_enrollment_date\r\n'
-        b'rebeccanelson@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-04\r\n'
-        b'taylorjames@example.com,Re-engineered tangible approach,business-management,certificate,2021-07-03\r\n'
-        b'ssmith@example.com,Secured static capability,medicine,certificate,2021-05-11\r\n'
-        b'amber79@example.com,Streamlined zero-defect attitude,communication,certificate,2020-04-08\r\n'
-        b'kathleenmartin@example.com,Horizontal solution-oriented hub,social-sciences,certificate,2020-04-03\r\n'
-    )
-
-
 def leaderboard_csv_content():
     """Return the CSV content of leaderboard."""
     # return (