learning-credentials 0.2.0rc1__py2.py3-none-any.whl

learning_credentials/models.py

@@ -0,0 +1,381 @@
+"""Database models for learning_credentials."""
+
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from importlib import import_module
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import jsonfield
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models.signals import post_delete
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+from django_celery_beat.models import IntervalSchedule, PeriodicTask
+from edx_ace import Message, Recipient, ace
+from model_utils.models import TimeStampedModel
+from opaque_keys.edx.django.models import LearningContextKeyField
+
+from learning_credentials.compat import get_learning_context_name
+from learning_credentials.exceptions import AssetNotFoundError, CredentialGenerationError
+
+if TYPE_CHECKING:  # pragma: no cover
+    from django.core.files import File
+    from django.db.models import QuerySet
+
+
+log = logging.getLogger(__name__)
+
+
+class CredentialType(TimeStampedModel):
+    """
+    Model to store global credential configurations for each type.
+
+    .. no_pii:
+    """
+
+    name = models.CharField(max_length=255, unique=True, help_text=_('Name of the credential type.'))
+    retrieval_func = models.CharField(max_length=200, help_text=_('A name of the function to retrieve eligible users.'))
+    generation_func = models.CharField(max_length=200, help_text=_('A name of the function to generate credentials.'))
+    custom_options = jsonfield.JSONField(default=dict, blank=True, help_text=_('Custom options for the functions.'))
+
+    # TODO: Document how to add custom functions to the credential generation pipeline.
+
+    def __str__(self):
+        """Get a string representation of this model's instance."""
+        return self.name
+
+    def clean(self):
+        """Ensure that the `retrieval_func` and `generation_func` exist."""
+        for func_field in ['retrieval_func', 'generation_func']:
+            func_path = getattr(self, func_field)
+            try:
+                # TODO: Move the function retrieval to a method to avoid code duplication.
+                module_path, func_name = func_path.rsplit('.', 1)
+                module = import_module(module_path)
+                getattr(module, func_name)  # Will raise AttributeError if the function does not exist.
+            except ValueError as exc:
+                raise ValidationError({func_field: "Function path must be in format 'module.function_name'."}) from exc
+            except (ImportError, AttributeError) as exc:
+                raise ValidationError(
+                    {func_field: f"The function {func_path} could not be found. Please provide a valid path."},
+                ) from exc
+
+
+class CredentialConfiguration(TimeStampedModel):
+    """
+    Model to store context-specific credential configurations for each credential type.
+
+    .. no_pii:
+    """
+
+    learning_context_key = LearningContextKeyField(
+        max_length=255,
+        help_text=_('ID of a learning context (e.g., a course or a Learning Path).'),
+    )
+    credential_type = models.ForeignKey(
+        CredentialType,
+        on_delete=models.CASCADE,
+        help_text=_('Associated credential type.'),
+    )
+    periodic_task = models.OneToOneField(
+        PeriodicTask,
+        on_delete=models.CASCADE,
+        help_text=_('Associated periodic task.'),
+    )
+    custom_options = jsonfield.JSONField(
+        default=dict,
+        blank=True,
+        help_text=_(
+            'Custom options for the functions. If specified, they are merged with the options defined in the '
+            'credential type.',
+        ),
+    )
+
+    class Meta:  # noqa: D106
+        unique_together = (('learning_context_key', 'credential_type'),)
+
+    def __str__(self):  # noqa: D105
+        return f'{self.credential_type.name} in {self.learning_context_key}'
+
+    def save(self, *args, **kwargs):
+        """Create a new PeriodicTask every time a new CredentialConfiguration is created."""
+        from learning_credentials.tasks import generate_credentials_for_config_task as task  # Avoid circular imports.
+
+        # Use __wrapped__ to get the original function, as the task is wrapped by the @app.task decorator.
+        task_path = f"{task.__wrapped__.__module__}.{task.__wrapped__.__name__}"
+
+        if self._state.adding:
+            schedule, created = IntervalSchedule.objects.get_or_create(every=10, period=IntervalSchedule.DAYS)
+            self.periodic_task = PeriodicTask.objects.create(
+                enabled=False,
+                interval=schedule,
+                name=f'{self.credential_type} in {self.learning_context_key}',
+                task=task_path,
+            )
+
+        super().save(*args, **kwargs)
+
+        # Update the task on each save to prevent it from getting out of sync (e.g., after changing a task definition).
+        self.periodic_task.task = task_path
+        # Update the args of the PeriodicTask to include the ID of the CredentialConfiguration.
+        self.periodic_task.args = json.dumps([self.id])
+        self.periodic_task.save()
+
+    # Replace the return type with `QuerySet[Self]` after migrating to Python 3.10+.
+    @classmethod
+    def get_enabled_configurations(cls) -> QuerySet[CredentialConfiguration]:
+        """
+        Get the list of enabled configurations.
+
+        :return: A list of CredentialConfiguration objects.
+        """
+        return CredentialConfiguration.objects.filter(periodic_task__enabled=True)
+
+    def generate_credentials(self):
+        """This method allows manual credential generation from the Django admin."""
+        user_ids = self.get_eligible_user_ids()
+        log.info("The following users are eligible in %s: %s", self.learning_context_key, user_ids)
+        filtered_user_ids = self.filter_out_user_ids_with_credentials(user_ids)
+        log.info("The filtered users eligible in %s: %s", self.learning_context_key, filtered_user_ids)
+        for user_id in filtered_user_ids:
+            self.generate_credential_for_user(user_id)
+
+    def filter_out_user_ids_with_credentials(self, user_ids: list[int]) -> list[int]:
+        """
+        Filter out user IDs that already have a credential for this course and credential type.
+
+        :param user_ids: A list of user IDs to filter.
+        :return: A list of user IDs that either:
+                 1. Do not have a credential for this course and credential type.
+                 2. Have such a credential with an error status.
+        """
+        users_ids_with_credentials = Credential.objects.filter(
+            models.Q(learning_context_key=self.learning_context_key),
+            models.Q(credential_type=self.credential_type),
+            ~(models.Q(status=Credential.Status.ERROR)),
+        ).values_list('user_id', flat=True)
+
+        filtered_user_ids_set = set(user_ids) - set(users_ids_with_credentials)
+        return list(filtered_user_ids_set)
+
+    def get_eligible_user_ids(self) -> list[int]:
+        """
+        Get the list of eligible learners for the given course.
+
+        :return: A list of user IDs.
+        """
+        func_path = self.credential_type.retrieval_func
+        module_path, func_name = func_path.rsplit('.', 1)
+        module = import_module(module_path)
+        func = getattr(module, func_name)
+
+        custom_options = {**self.credential_type.custom_options, **self.custom_options}
+        return func(self.learning_context_key, custom_options)
+
+    def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
+        """
+        Celery task for processing a single user's credential.
+
+        This function retrieves an CredentialConfiguration object based on context ID and credential type,
+        retrieves the data using the retrieval_func specified in the associated CredentialType object,
+        and passes this data to the function specified in the generation_func field.
+
+        Args:
+            user_id: The ID of the user to process the credential for.
+            celery_task_id (optional): The ID of the Celery task that is running this function.
+        """
+        user = get_user_model().objects.get(id=user_id)
+        # Use the name from the profile if it is not empty. Otherwise, use the first and last name.
+        # We check if the profile exists because it may not exist in some cases (e.g., when a User is created manually).
+        user_full_name = getattr(getattr(user, 'profile', None), 'name', f"{user.first_name} {user.last_name}")
+        custom_options = {**self.credential_type.custom_options, **self.custom_options}
+
+        credential, _ = Credential.objects.update_or_create(
+            user_id=user_id,
+            learning_context_key=self.learning_context_key,
+            credential_type=self.credential_type.name,
+            defaults={
+                'user_full_name': user_full_name,
+                'status': Credential.Status.GENERATING,
+                'generation_task_id': celery_task_id,
+            },
+        )
+
+        try:
+            generation_module_name, generation_func_name = self.credential_type.generation_func.rsplit('.', 1)
+            generation_module = import_module(generation_module_name)
+            generation_func = getattr(generation_module, generation_func_name)
+
+            # Run the functions. We do not validate them here, as they are validated in the model's clean() method.
+            credential.download_url = generation_func(self.learning_context_key, user, credential.uuid, custom_options)
+            credential.status = Credential.Status.AVAILABLE
+            credential.save()
+        except Exception as exc:
+            credential.status = Credential.Status.ERROR
+            credential.save()
+            msg = f'Failed to generate the {credential.uuid=} for {user_id=} with {self.id=}.'
+            raise CredentialGenerationError(msg) from exc
+        else:
+            # TODO: In the future, we want to check this before generating the credential.
+            #       Perhaps we could even include this in a processor to optimize it.
+            if user.is_active and user.has_usable_password():
+                credential.send_email()
+
+
+# noinspection PyUnusedLocal
+@receiver(post_delete, sender=CredentialConfiguration)
+def post_delete_periodic_task(sender, instance, *_args, **_kwargs):  # noqa: ANN001, ARG001
+    """Delete the associated periodic task when the object is deleted."""
+    if instance.periodic_task:
+        instance.periodic_task.delete()
+
+
+class Credential(TimeStampedModel):
+    """
+    Model to represent each credential awarded to a user for a course.
+
+    This model contains information about the related course, the user who earned the credential,
+    the download URL for the credential PDF, and the associated credential generation task.
+
+    .. note:: Credentials are identified by UUIDs rather than integer keys to prevent enumeration attacks
+       or privacy leaks.
+
+    .. pii: The User's name is stored in this model.
+    .. pii_types: id, name
+    .. pii_retirement: retained
+    """
+
+    class Status(models.TextChoices):
+        """Status of the credential generation task."""
+
+        GENERATING = 'generating', _('Generating')
+        AVAILABLE = 'available', _('Available')
+        ERROR = 'error', _('Error')
+        INVALIDATED = 'invalidated', _('Invalidated')
+
+    uuid = models.UUIDField(
+        primary_key=True,
+        default=uuid.uuid4,
+        editable=False,
+        help_text=_('Auto-generated UUID of the credential'),
+    )
+    user_id = models.IntegerField(help_text=_('ID of the user receiving the credential'))
+    user_full_name = models.CharField(max_length=255, help_text=_('User receiving the credential'))
+    learning_context_key = LearningContextKeyField(
+        max_length=255,
+        help_text=_('ID of a learning context (e.g., a course or a Learning Path) for which the credential was issued'),
+    )
+    credential_type = models.CharField(max_length=255, help_text=_('Type of the credential'))
+    status = models.CharField(
+        max_length=32,
+        choices=Status.choices,
+        default=Status.GENERATING,
+        help_text=_('Status of the credential generation task'),
+    )
+    download_url = models.URLField(blank=True, help_text=_('URL of the generated credential PDF (e.g., to S3)'))
+    legacy_id = models.IntegerField(null=True, help_text=_('Legacy ID of the credential imported from another system'))
+    generation_task_id = models.CharField(max_length=255, help_text=_('Task ID from the Celery queue'))
+
+    class Meta:  # noqa: D106
+        unique_together = (('user_id', 'learning_context_key', 'credential_type'),)
+
+    def __str__(self):  # noqa: D105
+        return f"{self.credential_type} for {self.user_full_name} in {self.learning_context_key}"
+
+    def send_email(self):
+        """Send a credential link to the student."""
+        course_name = get_learning_context_name(self.learning_context_key)
+        user = get_user_model().objects.get(id=self.user_id)
+        msg = Message(
+            name="credential_generated",
+            app_label="learning_credentials",
+            recipient=Recipient(lms_user_id=user.id, email_address=user.email),
+            language='en',
+            context={
+                'credential_link': self.download_url,
+                'course_name': course_name,
+                'platform_name': settings.PLATFORM_NAME,
+            },
+        )
+        ace.send(msg)
+
+
+class CredentialAsset(TimeStampedModel):
+    """
+    A set of assets to be used in custom credential templates.
+
+    This model stores assets used during credential generation process, such as PDF templates, images, fonts.
+
+    .. no_pii:
+    """
+
+    def template_assets_path(self, filename: str) -> str:
+        """
+        Delete the file if it already exists and returns the credential template asset file path.
+
+        :param filename: File to upload.
+        :return path: Path of asset file e.g. `credential_template_assets/1/filename`.
+        """
+        name = Path('learning_credentials_template_assets') / str(self.id) / filename
+        fullname = Path(settings.MEDIA_ROOT) / name
+        if fullname.exists():
+            fullname.unlink()
+        return str(name)
+
+    description = models.CharField(
+        max_length=255,
+        null=False,
+        blank=True,
+        help_text=_('Description of the asset.'),
+    )
+    asset = models.FileField(
+        max_length=255,
+        upload_to=template_assets_path,
+        help_text=_('Asset file. It could be a PDF template, image or font file.'),
+    )
+    asset_slug = models.SlugField(
+        max_length=255,
+        unique=True,
+        null=False,
+        help_text=_('Asset\'s unique slug. We can reference the asset in templates using this value.'),
+    )
+
+    class Meta:  # noqa: D106
+        get_latest_by = 'created'
+
+    def __str__(self):  # noqa: D105
+        return f'{self.asset.url}'
+
+    def save(self, *args, **kwargs):
+        """If the object is being created, save the asset first, then save the object."""
+        if self._state.adding:
+            asset_image = self.asset
+            self.asset = None
+            super().save(*args, **kwargs)
+            self.asset = asset_image
+
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_asset_by_slug(cls, asset_slug: str) -> File:
+        """
+        Fetch a credential template asset by its slug from the database.
+
+        :param asset_slug: The slug of the asset to be retrieved.
+        :returns: The file associated with the asset slug.
+        :raises AssetNotFound: If no asset exists with the provided slug in the CredentialAsset database model.
+        """
+        try:
+            template_asset = cls.objects.get(asset_slug=asset_slug)
+            asset = template_asset.asset
+        except cls.DoesNotExist as exc:
+            msg = f'Asset with slug {asset_slug} does not exist.'
+            raise AssetNotFoundError(msg) from exc
+        return asset

learning_credentials/processors.py

@@ -0,0 +1,306 @@
+"""
+This module contains processors for credential criteria.
+
+The functions prefixed with `retrieve_` are automatically detected by the admin page and are used to retrieve the
+IDs of the users that meet the criteria for the credential type.
+
+We will move this module to an external repository (a plugin).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from completion_aggregator.api.v1.views import CompletionDetailView
+from django.contrib.auth import get_user_model
+from learning_paths.models import LearningPath
+from rest_framework.request import Request
+from rest_framework.test import APIRequestFactory
+
+from learning_credentials.compat import (
+    get_course_enrollments,
+    get_course_grade,
+    get_course_grading_policy,
+    prefetch_course_grades,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Callable
+
+    from django.contrib.auth.models import User
+    from opaque_keys.edx.keys import CourseKey, LearningContextKey
+    from rest_framework.views import APIView
+
+
+log = logging.getLogger(__name__)
+
+
+def _process_learning_context(
+    learning_context_key: LearningContextKey,
+    course_processor: Callable[[CourseKey, dict[str, Any]], list[int]],
+    options: dict[str, Any],
+) -> list[int]:
+    """
+    Process a learning context (course or learning path) using the given course processor function.
+
+    For courses, runs the processor directly. For learning paths, runs the processor on each
+    course in the path and returns the intersection of eligible users across all courses.
+
+    Args:
+        learning_context_key: A course key or learning path key to process
+        course_processor: A function that processes a single course and returns eligible user IDs
+        options: Options to pass to the processor
+
+    Returns:
+        A list of eligible user IDs
+    """
+    if learning_context_key.is_course:
+        return course_processor(learning_context_key, options)
+
+    learning_path = LearningPath.objects.get(key=learning_context_key)
+
+    results = None
+    for course in learning_path.steps.all():
+        course_results = set(course_processor(course.course_key, options))
+        if results is None:
+            results = course_results
+        else:
+            results &= course_results
+
+    return list(results) if results else []
+
+
+def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
+    """
+    Retrieve the course grading policy and return the weight of each category.
+
+    :param course_id: The course ID to get the grading policy for.
+    :returns: A dictionary with the weight of each category.
+    """
+    log.debug('Getting the course grading policy.')
+    grading_policy = get_course_grading_policy(course_id)
+    log.debug('Finished getting the course grading policy.')
+
+    # Calculate the total weight of the non-exam categories
+    log.debug(grading_policy)
+
+    category_weight_ratios = {category['type'].lower(): category['weight'] for category in grading_policy}
+
+    log.debug(category_weight_ratios)
+    return category_weight_ratios
+
+
+def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, int]]:
+    """
+    Get the grades for each user, categorized by assignment types.
+
+    :param course_id: The course ID.
+    :param users: The users to get the grades for.
+    :returns: A dictionary with the grades for each user, categorized by assignment types.
+    """
+    log.debug('Getting the grades for each user.')
+
+    grades = {}
+
+    with prefetch_course_grades(course_id, users):
+        for user in users:
+            grades[user.id] = {}
+            course_grade = get_course_grade(user, course_id)
+            for assignment_type, subsections in course_grade.graded_subsections_by_format().items():
+                assignment_earned = 0
+                assignment_possible = 0
+                log.debug(subsections)
+                for subsection in subsections.values():
+                    assignment_earned += subsection.graded_total.earned
+                    assignment_possible += subsection.graded_total.possible
+                grade = (assignment_earned / assignment_possible) * 100 if assignment_possible > 0 else 0
+                grades[user.id][assignment_type.lower()] = grade
+
+    log.debug('Finished getting the grades for each user.')
+    return grades
+
+
+def _are_grades_passing_criteria(
+    user_grades: dict[str, float],
+    required_grades: dict[str, float],
+    category_weights: dict[str, float],
+) -> bool:
+    """
+    Determine whether the user received passing grades in all required categories.
+
+    :param user_grades: The grades of the user, divided by category.
+    :param required_grades: The required grades for each category.
+    :param category_weights: The weight of each category.
+    :returns: Whether the user received passing grades in all required categories.
+    :raises ValueError: If a category weight is not found.
+    """
+    # If user does not have a grade for a category (except for the "total" category), it means that they did not
+    # attempt it. Therefore, they should not be eligible for the credential.
+    if not all(category in user_grades for category in required_grades if category != 'total'):
+        return False
+
+    total_score = 0
+    for category, score in user_grades.items():
+        if score < required_grades.get(category, 0):
+            return False
+
+        if category not in category_weights:
+            msg = "Category weight '%s' was not found in the course grading policy."
+            raise ValueError(msg, category)
+        total_score += score * category_weights[category]
+
+    return total_score >= required_grades.get('total', 0)
+
+
+def _retrieve_course_subsection_grades(course_id: CourseKey, options: dict[str, Any]) -> list[int]:
+    """Implementation for retrieving course grades."""
+    required_grades: dict[str, int] = options['required_grades']
+    required_grades = {key.lower(): value * 100 for key, value in required_grades.items()}
+
+    users = get_course_enrollments(course_id)
+    grades = _get_grades_by_format(course_id, users)
+    log.debug(grades)
+    weights = _get_category_weights(course_id)
+
+    eligible_users = []
+    for user_id, user_grades in grades.items():
+        if _are_grades_passing_criteria(user_grades, required_grades, weights):
+            eligible_users.append(user_id)
+
+    return eligible_users
+
+
+def retrieve_subsection_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
+    """
+    Retrieve the users that have passing grades in all required categories.
+
+    :param learning_context_key: The learning context key (course or learning path).
+    :param options: The custom options for the credential.
+    :returns: The IDs of the users that have passing grades in all required categories.
+
+    Options:
+      - required_grades: A dictionary of required grades for each category, where the keys are the category names and
+        the values are the minimum required grades. The grades are percentages, so they should be in the range [0, 1].
+        See the following example::
+
+          {
+            "required_grades": {
+              "Homework": 0.4,
+              "Exam": 0.9,
+              "Total": 0.8
+            }
+          }
+
+        It means that the user must receive at least 40% in the Homework category and 90% in the Exam category.
+        The "Total" key is a special value used to specify the minimum required grade for all categories in the course.
+        Let's assume that we have the following grading policy (the percentages are the weights of each category):
+        1. Homework: 20%
+        2. Lab: 10%
+        3. Exam: 70%
+        The grades for the Total category will be calculated as follows:
+        total_grade = (homework_grade * 0.2) + (lab_grade * 0.1) + (exam_grade * 0.7)
+    """
+    return _process_learning_context(learning_context_key, _retrieve_course_subsection_grades, options)
+
+
+def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params: dict, url: str) -> APIView:
+    """
+    Prepare a request to the Completion Aggregator API.
+
+    :param course_id: The course ID.
+    :param query_params: The query parameters to use in the request.
+    :param url: The URL to use in the request.
+    :returns: The view with the prepared request.
+    """
+    log.debug('Preparing the request for retrieving the completion.')
+
+    # The URL does not matter, as we do not retrieve any data from the path.
+    django_request = APIRequestFactory().get(url, query_params)
+    django_request.course_id = course_id
+    drf_request = Request(django_request)  # convert django.core.handlers.wsgi.WSGIRequest to DRF request
+
+    view = CompletionDetailView()
+    view.request = drf_request
+
+    # HACK: Bypass the API permissions.
+    staff_user = get_user_model().objects.filter(is_staff=True).first()
+    view._effective_user = staff_user  # noqa: SLF001
+
+    log.debug('Finished preparing the request for retrieving the completion.')
+    return view
+
+
+def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any]) -> list[int]:
+    """Implementation for retrieving course completions."""
+    # If it turns out to be too slow, we can:
+    # 1. Modify the Completion Aggregator to emit a signal/event when a user achieves a certain completion threshold.
+    # 2. Get this data from the `Aggregator` model. Filter by `aggregation name == 'course'`, `course_key`, `percent`.
+
+    required_completion = options.get('required_completion', 0.9)
+
+    url = f'/completion-aggregator/v1/course/{course_id}/'
+    query_params = {'page_size': 1000, 'page': 1}
+
+    # TODO: Extract the logic of this view into an API. The current approach is very hacky.
+    view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
+    completions = []
+
+    while True:
+        # noinspection PyUnresolvedReferences
+        response = view.get(view.request, str(course_id))
+        log.debug(response.data)
+        completions.extend(
+            res['username'] for res in response.data['results'] if res['completion']['percent'] >= required_completion
+        )
+        if not response.data['pagination']['next']:
+            break
+        query_params['page'] += 1
+        view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
+
+    return list(get_user_model().objects.filter(username__in=completions).values_list('id', flat=True))
+
+
+def retrieve_completions(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
+    """
+    Retrieve the course completions for all users through the Completion Aggregator API.
+
+    :param learning_context_key: The learning context key (course or learning path).
+    :param options: The custom options for the credential.
+    :returns: The IDs of the users that have achieved the required completion percentage.
+
+    Options:
+      - required_completion: The minimum required completion percentage. The default value is 0.9.
+    """
+    return _process_learning_context(learning_context_key, _retrieve_course_completions, options)
+
+
+def retrieve_completions_and_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
+    """
+    Retrieve the users that meet both completion and grade criteria.
+
+    This processor combines the functionality of retrieve_course_completions and retrieve_subsection_grades.
+    To be eligible, learners must satisfy both sets of criteria.
+
+    :param learning_context_key: The learning context key (course or learning path).
+    :param options: The custom options for the credential.
+    :returns: The IDs of the users that meet both sets of criteria.
+
+    Options:
+      - required_completion: The minimum required completion percentage (default: 0.9)
+      - required_grades: A dictionary of required grades for each category, where the keys are the category names and
+        the values are the minimum required grades. The grades are percentages in the range [0, 1].
+        Example::
+
+          {
+            "required_grades": {
+              "Homework": 0.4,
+              "Exam": 0.9,
+              "Total": 0.8
+            }
+          }
+    """
+    completion_eligible_users = set(retrieve_completions(learning_context_key, options))
+    grades_eligible_users = set(retrieve_subsection_grades(learning_context_key, options))
+
+    return list(completion_eligible_users & grades_eligible_users)

learning_credentials/settings/__init__.py

@@ -0,0 +1 @@
+"""App-specific settings."""