learning-credentials 0.3.0rc4__py3-none-any.whl → 0.3.1rc1__py3-none-any.whl

learning_credentials/generators.py

@@ -19,9 +19,9 @@ from django.core.files.base import ContentFile
 from django.core.files.storage import FileSystemStorage, default_storage
 from pypdf import PdfReader, PdfWriter
 from pypdf.constants import UserAccessPermissions
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.pdfgen import canvas
+from reportlab.pdfbase.pdfmetrics import FontError, FontNotFoundError, registerFont
+from reportlab.pdfbase.ttfonts import TTFError, TTFont
+from reportlab.pdfgen.canvas import Canvas
 
 from .compat import get_default_storage_url, get_learning_context_name, get_localized_credential_date
 from .models import CredentialAsset
@@ -33,6 +33,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
     from django.contrib.auth.models import User
     from opaque_keys.edx.keys import CourseKey
+    from pypdf import PageObject
 
 
 def _get_user_name(user: User) -> str:
@@ -45,25 +46,29 @@ def _get_user_name(user: User) -> str:
     return user.profile.name or f"{user.first_name} {user.last_name}"
 
 
-def _register_font(options: dict[str, Any]) -> str:
+def _register_font(font_name: Any) -> str | None:  # noqa: ANN401
     """
     Register a custom font if specified in options. If not specified, use the default font (Helvetica).
 
-    :param options: A dictionary containing the font.
-    :returns: The font name.
+    :param font_name: The name of the font to register.
+    :returns: The font name if registered successfully, otherwise None.
     """
-    if font := options.get('font'):
-        pdfmetrics.registerFont(TTFont(font, CredentialAsset.get_asset_by_slug(font)))
+    if not font_name:
+        return None
 
-    return font or 'Helvetica'
+    try:
+        registerFont(TTFont(font_name, CredentialAsset.get_asset_by_slug(font_name)))
+    except (FontError, FontNotFoundError, TTFError):
+        log.exception("Error registering font %s", font_name)
+    else:
+        return font_name
 
 
-def _write_text_on_template(template: any, font: str, username: str, context_name: str, options: dict[str, Any]) -> any:
+def _write_text_on_template(template: PageObject, username: str, context_name: str, options: dict[str, Any]) -> Canvas:
     """
     Prepare a new canvas and write the user and course name onto it.
 
     :param template: Pdf template.
-    :param font: Font name.
     :param username: The name of the user to generate the credential for.
     :param context_name: The name of the learning context.
     :param options: A dictionary documented in the `generate_pdf_credential` function.
@@ -86,20 +91,26 @@ def _write_text_on_template(template: any, font: str, username: str, context_nam
         return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
 
     template_width, template_height = template.mediabox[2:]
-    pdf_canvas = canvas.Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+    pdf_canvas = Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+    font = _register_font(options.get('font')) or 'Helvetica'
 
     # Write the learner name.
-    # TODO: Add tests.
-    pdf_canvas.setFont(font, options.get('name_size', 32))
+    if options.get('name_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_NAME_UPPERCASE', False)):
+        username = username.upper()
+
+    name_font = _register_font(options.get('name_font')) or font
+    pdf_canvas.setFont(name_font, options.get('name_size', 32))
     name_color = options.get('name_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(name_color))
 
     name_x = (template_width - pdf_canvas.stringWidth(username)) / 2
     name_y = options.get('name_y', 290)
+
     pdf_canvas.drawString(name_x, name_y, username)
 
     # Write the learning context name.
-    pdf_canvas.setFont(font, options.get('context_name_size', 28))
+    context_name_font = _register_font(options.get('context_name_font')) or font
+    pdf_canvas.setFont(context_name_font, options.get('context_name_size', 28))
     context_name_color = options.get('context_name_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(context_name_color))
 
@@ -114,13 +125,22 @@ def _write_text_on_template(template: any, font: str, username: str, context_nam
 
     # Write the issue date.
     issue_date = get_localized_credential_date()
-    pdf_canvas.setFont(font, 12)
+    if options.get('issue_date_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_UPPERCASE', False)):
+        issue_date = issue_date.upper()
+
+    issue_date_font = _register_font(options.get('issue_date_font')) or font
+    pdf_canvas.setFont(issue_date_font, options.get('issue_date_size', 12))
     issue_date_color = options.get('issue_date_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(issue_date_color))
 
     issue_date_x = (template_width - pdf_canvas.stringWidth(issue_date)) / 2
     issue_date_y = options.get('issue_date_y', 120)
-    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date)
+
+    issue_date_char_space = options.get(
+        'issue_date_char_space', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_CHAR_SPACE', 0)
+    )
+
+    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date, charSpace=issue_date_char_space)
 
     return pdf_canvas
 
@@ -169,7 +189,7 @@ def generate_pdf_credential(
     credential_uuid: UUID,
     options: dict[str, Any],
 ) -> str:
-    """
+    r"""
     Generate a PDF credential.
 
     :param learning_context_key: The ID of the course or learning path the credential is for.
@@ -180,33 +200,48 @@ def generate_pdf_credential(
 
     Options:
       - template: The path to the PDF template file.
-      - template_two_lines: The path to the PDF template file for two-line context names.
-        A two-line context name is specified by using a semicolon as a separator.
-      - font: The name of the font to use.
+      - template_multiline: The path to the PDF template file for multiline context names.
+        A multiline context name is specified by using '\n' or ';' as a separator.
+      - font: The name of the font to use. The default font is Helvetica.
       - name_y: The Y coordinate of the name on the credential (vertical position on the template).
       - name_color: The color of the name on the credential (hexadecimal color code).
       - name_size: The font size of the name on the credential. The default value is 32.
-      - context_name: Specify the custom course or Learning Path name.
+      - name_font: The font of the name on the credential. It overrides the `font` option.
+      - name_uppercase: If set to true (without quotes), the name will be converted to uppercase.
+        The default value is False, unless specified otherwise in the instance settings.
+      - context_name: Specify the custom course or Learning Path name. If not provided, it will be retrieved
+        automatically from the "cert_name_long" or "display_name" fields for courses, or from the Learning Path model.
       - context_name_y: The Y coordinate of the context name on the credential (vertical position on the template).
       - context_name_color: The color of the context name on the credential (hexadecimal color code).
       - context_name_size: The font size of the context name on the credential. The default value is 28.
+      - context_name_font: The font of the context name on the credential. It overrides the `font` option.
       - issue_date_y: The Y coordinate of the issue date on the credential (vertical position on the template).
       - issue_date_color: The color of the issue date on the credential (hexadecimal color code).
+      - issue_date_size: The font size of the issue date on the credential. The default value is 12.
+      - issue_date_font: The font of the issue date on the credential. It overrides the `font` option.
+      - issue_date_char_space: The character spacing of the issue date on the credential
+        (default is 0.0, unless specified otherwise in the instance settings).
+      - issue_date_uppercase: If set to true (without quotes), the issue date will be converted to uppercase.
+        The default value is False, unless specified otherwise in the instance settings.
     """
     log.info("Starting credential generation for user %s", user.id)
 
     username = _get_user_name(user)
     context_name = options.get('context_name') or get_learning_context_name(learning_context_key)
+    template_path = options.get('template')
 
-    # Get template from the CredentialAsset.
-    # HACK: We support two-line strings by using a semicolon as a separator.
-    if ';' in context_name and (template_path := options.get('template_two_lines')):
-        template_file = CredentialAsset.get_asset_by_slug(template_path)
-        context_name = context_name.replace(';', '\n')
-    else:
-        template_file = CredentialAsset.get_asset_by_slug(options['template'])
+    # Handle multiline context name (we support semicolon as a separator to preserve backward compatibility).
+    context_name = context_name.replace(';', '\n').replace(r'\n', '\n')
+    if '\n' in context_name:
+        # `template_two_lines` is kept for backward compatibility.
+        template_path = options.get('template_multiline', options.get('template_two_lines', template_path))
+
+    if not template_path:
+        msg = "Template path must be specified in options."
+        raise ValueError(msg)
 
-    font = _register_font(options)
+    # Get template from the CredentialAsset.
+    template_file = CredentialAsset.get_asset_by_slug(template_path)
 
     # Load the PDF template.
     with template_file.open('rb') as template_file:
@@ -215,7 +250,7 @@ def generate_pdf_credential(
         credential = PdfWriter()
 
         # Create a new canvas, prepare the page and write the data
-        pdf_canvas = _write_text_on_template(template, font, username, context_name, options)
+        pdf_canvas = _write_text_on_template(template, username, context_name, options)
 
         overlay_pdf = PdfReader(io.BytesIO(pdf_canvas.getpdfdata()))
         template.merge_page(overlay_pdf.pages[0])

learning_credentials/models.py

@@ -7,7 +7,7 @@ import logging
 import uuid
 from importlib import import_module
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 import jsonfield
 from django.conf import settings
@@ -112,7 +112,7 @@ class CredentialConfiguration(TimeStampedModel):
         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)
+            schedule, _created = IntervalSchedule.objects.get_or_create(every=10, period=IntervalSchedule.DAYS)
             self.periodic_task = PeriodicTask.objects.create(
                 enabled=False,
                 interval=schedule,
@@ -165,12 +165,11 @@ class CredentialConfiguration(TimeStampedModel):
         filtered_user_ids_set = set(user_ids) - set(users_ids_with_credentials)
         return list(filtered_user_ids_set)
 
-    def _call_retrieval_func(self, user_id: int | None = None) -> list[int] | dict[str, Any]:
+    def get_eligible_user_ids(self) -> list[int]:
         """
-        Call the retrieval function with the given parameters.
+        Get the list of eligible learners for the given course.
 
-        :param user_id: Optional. If provided, will check eligibility for the specific user.
-        :return: Raw result from the retrieval function - list of user IDs or user details dict.
+        :return: A list of user IDs.
         """
         func_path = self.credential_type.retrieval_func
         module_path, func_name = func_path.rsplit('.', 1)
@@ -178,40 +177,7 @@ class CredentialConfiguration(TimeStampedModel):
         func = getattr(module, func_name)
 
         custom_options = {**self.credential_type.custom_options, **self.custom_options}
-        return func(self.learning_context_key, custom_options, user_id=user_id)
-
-    def get_eligible_user_ids(self, user_id: int | None = None) -> list[int]:
-        """
-        Get the list of eligible learners for the given course.
-
-        :param user_id: Optional. If provided, will check eligibility for the specific user.
-        :return: A list of user IDs.
-        """
-        result = self._call_retrieval_func(user_id)
-
-        if user_id is not None:
-            # Single user case: return list with user ID if eligible
-            if isinstance(result, dict) and result.get('is_eligible', False):
-                return [user_id]
-            return []
-
-        # Multiple users case: result should already be a list of user IDs
-        return result if isinstance(result, list) else []
-
-    def get_user_eligibility_details(self, user_id: int) -> dict[str, Any]:
-        """
-        Get detailed eligibility information for a specific user.
-
-        :param user_id: The user ID to check eligibility for.
-        :return: Dictionary containing eligibility details and progress information.
-        """
-        result = self._call_retrieval_func(user_id)
-
-        if isinstance(result, dict):
-            return result
-
-        # Fallback for processors that don't support detailed results
-        return {'is_eligible': False}
+        return func(self.learning_context_key, custom_options)
 
     def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
         """
@@ -328,15 +294,15 @@ class Credential(TimeStampedModel):
         learning_context_name = get_learning_context_name(self.learning_context_key)
         user = get_user_model().objects.get(id=self.user_id)
         msg = Message(
-            name="certificate_generated",  # type: ignore[unknown-argument]
-            app_label="learning_credentials",  # type: ignore[unknown-argument]
-            recipient=Recipient(lms_user_id=user.id, email_address=user.email),  # type: ignore[unknown-argument]
-            language='en',  # type: ignore[unknown-argument]
+            name="certificate_generated",
+            app_label="learning_credentials",
+            recipient=Recipient(lms_user_id=user.id, email_address=user.email),
+            language='en',
             context={
                 'certificate_link': self.download_url,
                 'course_name': learning_context_name,
                 'platform_name': settings.PLATFORM_NAME,
-            },  # type: ignore[unknown-argument]
+            },
         )
         ace.send(msg)
 

learning_credentials/processors.py

@@ -38,63 +38,46 @@ log = logging.getLogger(__name__)
 
 def _process_learning_context(
     learning_context_key: LearningContextKey,
-    course_processor: Callable[[CourseKey, dict[str, Any], int | None], dict[int, dict[str, Any]]],
+    course_processor: Callable[[CourseKey, dict[str, Any]], list[int]],
     options: dict[str, Any],
-    user_id: int | None = None,
-) -> dict[int, 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 with step-specific options (if available), and returns detailed results
-    with step breakdown.
+    course in the path with step-specific options (if available), 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 detailed progress for all users
+        course_processor: A function that processes a single course and returns eligible user IDs
         options: Options to pass to the processor. For learning paths, may contain a "steps" key
                 with step-specific options in the format: {"steps": {"<course_key>": {...}}}
-        user_id: Optional. If provided, will filter to the specific user.
 
     Returns:
-        A dict mapping user_id to detailed progress, with step breakdown for learning paths
+        A list of eligible user IDs
     """
     if learning_context_key.is_course:
-        return course_processor(learning_context_key, options, user_id)  # type: ignore[invalid-argument-type]
+        return course_processor(learning_context_key, options)
 
     learning_path = LearningPath.objects.get(key=learning_context_key)
 
-    step_results_by_course = {}
-    all_user_ids = set()
+    results = None
+    for course in learning_path.steps.all():
+        course_options = options.get("steps", {}).get(str(course.course_key), options)
+        course_results = set(course_processor(course.course_key, course_options))
 
-    # TODO: Use a single Completion Aggregator request when retrieving step results for a single user.
-    for step in learning_path.steps.all():
-        course_options = options.get("steps", {}).get(str(step.course_key), options)
-        step_results = course_processor(step.course_key, course_options, user_id)
-
-        step_results_by_course[str(step.course_key)] = step_results
-        all_user_ids.update(step_results.keys())
+        if results is None:
+            results = course_results
+        else:
+            results &= course_results
 
     # Filter out users who are not enrolled in the Learning Path.
-    all_user_ids &= set(
-        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True)
+    results &= set(
+        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True),
     )
 
-    final_results = {}
-    for uid in all_user_ids:
-        overall_eligible = True
-        user_step_results = {}
-
-        for course_key, step_results in step_results_by_course.items():
-            if uid in step_results:
-                user_step_results[course_key] = step_results[uid]
-                overall_eligible = overall_eligible and step_results[uid].get('is_eligible', False)
-            else:
-                overall_eligible = False
-
-        final_results[uid] = {'is_eligible': overall_eligible, 'steps': user_step_results}
-
-    return final_results
+    return list(results) if results else []
 
 
 def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
@@ -117,7 +100,7 @@ def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
     return category_weight_ratios
 
 
-def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, float]]:
+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.
 
@@ -179,65 +162,30 @@ def _are_grades_passing_criteria(
     return total_score >= required_grades.get('total', 0)
 
 
-def _calculate_grades_progress(
-    user_grades: dict[str, float],
-    required_grades: dict[str, float],
-    category_weights: dict[str, float],
-) -> dict[str, Any]:
-    """
-    Calculate detailed progress information for grade-based criteria.
-
-    :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: Dict with is_eligible, current_grades, and required_grades.
-    """
-    # Calculate total score
-    total_score = 0
-    for category, score in user_grades.items():
-        if category in category_weights:
-            total_score += score * category_weights[category]
-
-    # Add total to user grades
-    user_grades_with_total = {**user_grades, 'total': total_score}
-
-    is_eligible = _are_grades_passing_criteria(user_grades, required_grades, category_weights)
-
-    return {
-        'is_eligible': is_eligible,
-        'current_grades': user_grades_with_total,
-        'required_grades': required_grades,
-    }
-
-
-def _retrieve_course_subsection_grades(
-    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
-) -> dict[int, dict[str, Any]]:
-    """Implementation for retrieving course grades. Always returns detailed progress for all users."""
+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, user_id)
+    users = get_course_enrollments(course_id)
     grades = _get_grades_by_format(course_id, users)
     log.debug(grades)
     weights = _get_category_weights(course_id)
 
-    results = {}
-    for uid, user_grades in grades.items():
-        results[uid] = _calculate_grades_progress(user_grades, required_grades, weights)
+    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 results
+    return eligible_users
 
 
-def retrieve_subsection_grades(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+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.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have passing grades in all required categories.
 
     Options:
@@ -284,16 +232,7 @@ def retrieve_subsection_grades(
             }
           }
     """
-    detailed_results = _process_learning_context(
-        learning_context_key, _retrieve_course_subsection_grades, options, user_id
-    )
-
-    if user_id is not None:
-        if user_id in detailed_results:
-            return detailed_results[user_id]
-        return {'is_eligible': False, 'current_grades': {}, 'required_grades': {}}
-
-    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
+    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:
@@ -313,7 +252,7 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     drf_request = Request(django_request)  # convert django.core.handlers.wsgi.WSGIRequest to DRF request
 
     view = CompletionDetailView()
-    view.request = drf_request  # type: ignore[invalid-assignment]
+    view.request = drf_request
 
     # HACK: Bypass the API permissions.
     staff_user = get_user_model().objects.filter(is_staff=True).first()
@@ -323,10 +262,8 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     return view
 
 
-def _retrieve_course_completions(
-    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
-) -> dict[int, dict[str, Any]]:
-    """Implementation for retrieving course completions. Always returns detailed progress for all users."""
+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`.
@@ -339,47 +276,29 @@ def _retrieve_course_completions(
 
     # 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 = {}
+    completions = []
 
     while True:
         # noinspection PyUnresolvedReferences
         response = view.get(view.request, str(course_id))
         log.debug(response.data)
-        for res in response.data['results']:
-            completions[res['username']] = res['completion']['percent']
+        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)
 
-    # Get all enrolled users and map usernames to user IDs
-    users = get_course_enrollments(course_id, user_id)
-    username_to_id = {user.username: user.id for user in users}  # type: ignore[unresolved-attribute]
-
-    # Always return detailed progress for all users as dict
-    detailed_results = {}
-    for username, current_completion in completions.items():
-        if username in username_to_id:
-            user_id_for_result = username_to_id[username]
-            progress = {
-                'is_eligible': current_completion >= required_completion,
-                'current_completion': current_completion,
-                'required_completion': required_completion,
-            }
-            detailed_results[user_id_for_result] = progress
+    return list(get_user_model().objects.filter(username__in=completions).values_list('id', flat=True))
 
-    return detailed_results
 
-
-def retrieve_completions(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+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.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have achieved the required completion percentage.
 
     Options:
@@ -400,19 +319,10 @@ def retrieve_completions(
             }
           }
     """
-    detailed_results = _process_learning_context(learning_context_key, _retrieve_course_completions, options, user_id)
-
-    if user_id is not None:
-        if user_id in detailed_results:
-            return detailed_results[user_id]
-        return {'is_eligible': False, 'current_completion': 0.0, 'required_completion': 0.9}
+    return _process_learning_context(learning_context_key, _retrieve_course_completions, options)
 
-    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
 
-
-def retrieve_completions_and_grades(
-    learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None
-) -> list[int] | dict[str, Any]:
+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.
 
@@ -421,7 +331,6 @@ def retrieve_completions_and_grades(
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
-    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that meet both sets of criteria.
 
     Options:
@@ -463,23 +372,6 @@ def retrieve_completions_and_grades(
             }
           }
     """
-    if user_id is not None:
-        completion_result = retrieve_completions(learning_context_key, options, user_id)
-        grades_result = retrieve_subsection_grades(learning_context_key, options, user_id)
-
-        if type(grades_result) is not dict or type(completion_result) is not dict:
-            msg = 'Both results must be dictionaries when user_id is provided.'
-            raise ValueError(msg)
-
-        completion_eligible = completion_result.get('is_eligible', False)
-        grades_eligible = grades_result.get('is_eligible', False)
-
-        return {
-            **completion_result,
-            **grades_result,
-            'is_eligible': completion_eligible and grades_eligible,
-        }
-
     completion_eligible_users = set(retrieve_completions(learning_context_key, options))
     grades_eligible_users = set(retrieve_subsection_grades(learning_context_key, options))
 

learning_credentials/settings/common.py

@@ -1,9 +1,12 @@
 """App-specific settings for all environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """Add `django_celery_beat` to `INSTALLED_APPS`."""
     if 'django_celery_beat' not in settings.INSTALLED_APPS:
         settings.INSTALLED_APPS += ('django_celery_beat',)

learning_credentials/settings/production.py

@@ -1,9 +1,12 @@
 """App-specific settings for production environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """
     Use the database scheduler for Celery Beat.
 

learning_credentials/urls.py

@@ -2,6 +2,8 @@
 
 from django.urls import include, path
 
+from .api import urls as api_urls
+
 urlpatterns = [
-    path('api/learning_credentials/', include('learning_credentials.api.urls')),
+    path('api/learning_credentials/', include(api_urls)),
 ]