learning-credentials 0.3.1rc2__py3-none-any.whl → 0.4.0__py3-none-any.whl

learning_credentials/generators.py

@@ -9,8 +9,10 @@ We will move this module to an external repository (a plugin).
 
 from __future__ import annotations
 
+import copy
 import io
 import logging
+import re
 import secrets
 from typing import TYPE_CHECKING, Any
 
@@ -24,6 +26,7 @@ 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 .exceptions import AssetNotFoundError
 from .models import CredentialAsset
 
 log = logging.getLogger(__name__)
@@ -36,6 +39,48 @@ if TYPE_CHECKING:  # pragma: no cover
     from pypdf import PageObject
 
 
+def _get_defaults() -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
+    """
+    Get default styling and text element configurations.
+
+    Evaluated lazily to avoid accessing Django settings at import time.
+
+    :returns: A tuple of (default_styling, default_text_elements).
+    """
+    default_styling = {
+        'font': 'Helvetica',
+        'color': '#000',
+        'size': 12,
+        'char_space': 0,
+        'uppercase': False,
+        'line_height': 1.1,
+    }
+
+    default_text_elements = {
+        'name': {
+            'text': '{name}',
+            'y': 290,
+            'size': 32,
+            'uppercase': getattr(settings, 'LEARNING_CREDENTIALS_NAME_UPPERCASE', False),
+        },
+        'context': {
+            'text': '{context_name}',
+            'y': 220,
+            'size': 28,
+            'line_height': 1.1,
+        },
+        'date': {
+            'text': '{issue_date}',
+            'y': 120,
+            'size': 12,
+            'uppercase': getattr(settings, 'LEARNING_CREDENTIALS_DATE_UPPERCASE', False),
+            'char_space': getattr(settings, 'LEARNING_CREDENTIALS_DATE_CHAR_SPACE', 0),
+        },
+    }
+
+    return default_styling, default_text_elements
+
+
 def _get_user_name(user: User) -> str:
     """
     Retrieve the user's name.
@@ -46,102 +91,193 @@ def _get_user_name(user: User) -> str:
     return user.profile.name or f"{user.first_name} {user.last_name}"
 
 
-def _register_font(font_name: str) -> str | None:
+def _register_font(pdf_canvas: Canvas, font_name: str) -> str:
     """
-    Register a custom font if specified in options. If not specified, use the default font (Helvetica).
+    Register a custom font if not already available.
+
+    Built-in fonts (like Helvetica) are already available and don't need registration.
+    Custom fonts are loaded from CredentialAsset.
 
+    :param pdf_canvas: The canvas to check available fonts on.
     :param font_name: The name of the font to register.
-    :returns: The font name if registered successfully, otherwise None.
+    :returns: The font name if available, otherwise use 'Helvetica' as fallback.
     """
-    if not font_name:
-        return None
+    # Check if font is already available (built-in or previously registered).
+    if font_name in pdf_canvas.getAvailableFonts():
+        return font_name
 
     try:
         registerFont(TTFont(font_name, CredentialAsset.get_asset_by_slug(font_name)))
+    except AssetNotFoundError:
+        log.warning("Font asset not found: %s", font_name)
     except (FontError, FontNotFoundError, TTFError):
         log.exception("Error registering font %s", font_name)
     else:
         return font_name
 
+    return 'Helvetica'
+
 
-def _write_text_on_template(template: PageObject, username: str, context_name: str, options: dict[str, Any]) -> Canvas:
+def _hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
     """
-    Prepare a new canvas and write the user and course name onto it.
+    Convert a hexadecimal color code to an RGB tuple with floating-point values.
 
-    :param template: Pdf template.
-    :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.
-    :returns: A canvas with written data.
+    :param hex_color: A hexadecimal color string, which can start with '#' and be either 3 or 6 characters long.
+    :returns: A tuple representing the RGB color as (red, green, blue), with each value ranging from 0.0 to 1.0.
     """
+    hex_color = hex_color.lstrip('#')
+    # Expand shorthand form (e.g. "158" to "115588")
+    if len(hex_color) == 3:
+        hex_color = ''.join([c * 2 for c in hex_color])
 
-    def hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
-        """
-        Convert a hexadecimal color code to an RGB tuple with floating-point values.
+    # noinspection PyTypeChecker
+    return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
 
-        :param hex_color: A hexadecimal color string, which can start with '#' and be either 3 or 6 characters long.
-        :returns: A tuple representing the RGB color as (red, green, blue), with each value ranging from 0.0 to 1.0.
-        """
-        hex_color = hex_color.lstrip('#')
-        # Expand shorthand form (e.g. "158" to "115588")
-        if len(hex_color) == 3:
-            hex_color = ''.join([c * 2 for c in hex_color])
 
-        # noinspection PyTypeChecker
-        return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
+def _substitute_placeholders(text: str, placeholders: dict[str, str]) -> str:
+    """
+    Substitute placeholders in text using {placeholder} syntax.
 
-    template_width, template_height = template.mediabox[2:]
-    pdf_canvas = Canvas(io.BytesIO(), pagesize=(template_width, template_height))
-    font = _register_font(options.get('font')) or 'Helvetica'
+    Supports escaping with {{ for literal braces.
 
-    # Write the learner name.
-    if options.get('name_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_NAME_UPPERCASE', False)):
-        username = username.upper()
+    :param text: The text containing placeholders.
+    :param placeholders: A dictionary mapping placeholder names to their values.
+    :returns: The text with placeholders substituted.
+    """
 
-    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))
+    def replace_placeholder(match: re.Match) -> str:
+        key = match.group(1)
+        return placeholders.get(key, match.group(0))
 
-    name_x = (template_width - pdf_canvas.stringWidth(username)) / 2
-    name_y = options.get('name_y', 290)
+    # Use negative lookbehind to skip escaped braces ({{).
+    # Match {word} but not {{word}.
+    text = re.sub(r'(?<!\{)\{(\w+)\}', replace_placeholder, text)
 
-    pdf_canvas.drawString(name_x, name_y, username)
+    # Replace escaped braces with literal braces.
+    return text.replace('{{', '{').replace('}}', '}')
 
-    # Write the learning context name.
-    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))
 
-    context_name_y = options.get('context_name_y', 220)
-    context_name_line_height = 28 * 1.1
+def _build_text_elements(options: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    """
+    Build the final text elements configuration by merging defaults with user options.
 
-    # Split the learning context name into lines and write each of them in the center of the template.
-    for line_number, line in enumerate(context_name.split('\n')):
-        line_x = (template_width - pdf_canvas.stringWidth(line)) / 2
-        line_y = context_name_y - (line_number * context_name_line_height)
-        pdf_canvas.drawString(line_x, line_y, line)
+    Standard elements (name, context, date) use defaults that are deep-merged with user overrides.
+    Custom elements (any other key) must provide at least 'text' and 'y'.
 
-    # Write the issue date.
-    issue_date = get_localized_credential_date()
-    if options.get('issue_date_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_UPPERCASE', False)):
-        issue_date = issue_date.upper()
+    :param options: The options dictionary from the credential configuration.
+    :returns: A dictionary of element configurations ready for rendering.
+    """
+    default_styling, default_text_elements = _get_defaults()
+    user_elements = options.get('text_elements', {})
+    defaults_config = {**default_styling, **options.get('defaults', {})}
+    result = {}
 
-    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))
+    # Process standard elements (they have defaults).
+    for key, default_config in default_text_elements.items():
+        user_config = user_elements.get(key, {})
 
-    issue_date_x = (template_width - pdf_canvas.stringWidth(issue_date)) / 2
-    issue_date_x += options.get('issue_date_x', 0)
-    issue_date_y = options.get('issue_date_y', 120)
+        if user_config is False:
+            continue
 
-    issue_date_char_space = options.get(
-        'issue_date_char_space', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_CHAR_SPACE', 0)
-    )
+        # Merge: element defaults -> global defaults -> user config.
+        element_config = {**copy.deepcopy(default_config), **defaults_config, **user_config}
+        result[key] = element_config
+
+    # Process custom elements (non-standard keys).
+    for key, user_config in user_elements.items():
+        if key in default_text_elements:
+            continue
 
-    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date, charSpace=issue_date_char_space)
+        # Skip disabled elements.
+        if user_config is False:
+            continue
+
+        if not isinstance(user_config, dict):
+            log.warning("Invalid custom element configuration for key '%s': expected dict", key)
+            continue
+
+        # Custom elements must have 'text' and 'y'.
+        if 'text' not in user_config or 'y' not in user_config:
+            log.warning("Custom element '%s' must have 'text' and 'y' properties", key)
+            continue
+
+        # Merge with global defaults only.
+        element_config = {**defaults_config, **user_config}
+        result[key] = element_config
+
+    return result
+
+
+def _render_text_element(
+    pdf_canvas: Canvas,
+    template_width: float,
+    config: dict[str, Any],
+    placeholders: dict[str, str],
+) -> None:
+    """
+    Render a single text element on the canvas.
+
+    :param pdf_canvas: The canvas to draw on.
+    :param template_width: Width of the template for centering.
+    :param config: The element configuration (all defaults are already merged).
+    :param placeholders: Dictionary of placeholder values.
+    """
+    text = _substitute_placeholders(config['text'], placeholders)
+
+    if config['uppercase']:
+        text = text.upper()
+
+    font_name = _register_font(pdf_canvas, config['font'])
+    pdf_canvas.setFont(font_name, config['size'])
+
+    pdf_canvas.setFillColorRGB(*_hex_to_rgb(config['color']))
+
+    y = config['y']
+    char_space = config['char_space']
+    line_height = config['line_height']
+    size = config['size']
+
+    # Handle multiline text (for context element).
+    lines = text.split('\n')
+    for line_number, line in enumerate(lines):
+        text_width = pdf_canvas.stringWidth(line) + (char_space * max(0, len(line) - 1))
+        line_x = (template_width - text_width) / 2
+        line_y = y - (line_number * size * line_height)
+        pdf_canvas.drawString(line_x, line_y, line, charSpace=char_space)
+
+
+def _write_text_on_template(
+    template: PageObject,
+    username: str,
+    context_name: str,
+    issue_date: str,
+    options: dict[str, Any],
+) -> Canvas:
+    """
+    Prepare a new canvas and write text elements onto it.
+
+    :param template: PDF template.
+    :param username: The name of the user to generate the credential for.
+    :param context_name: The name of the learning context.
+    :param issue_date: The formatted issue date string.
+    :param options: A dictionary documented in the ``generate_pdf_credential`` function.
+    :returns: A canvas with written data.
+    """
+    template_width, template_height = template.mediabox[2:]
+    pdf_canvas = Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+
+    # Build placeholder values.
+    placeholders = {
+        'name': username,
+        'context_name': context_name,
+        'issue_date': issue_date,
+    }
+
+    # Build and render text elements.
+    elements = _build_text_elements(options)
+
+    for config in elements.values():
+        _render_text_element(pdf_canvas, template_width, config, placeholders)
 
     return pdf_canvas
 
@@ -200,44 +336,56 @@ def generate_pdf_credential(
     :returns: The URL of the saved credential.
 
     Options:
-      - template: The path to the PDF template file.
-      - 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.
-      - 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_x: The horizontal offset for the issue date from its centered position
-        (positive values move right, negative values move left; default is 0).
-      - 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.
+
+      - template (required): The slug of the PDF template asset.
+      - template_multiline: Alternative template for multiline context names (when using '\n').
+      - defaults: Global defaults for all text elements.
+          - font: Font name (asset slug). Default: Helvetica.
+          - color: Hex color code. Default: #000.
+          - size: Font size in points. Default: 12.
+          - char_space: Character spacing. Default: 0.
+          - uppercase: Convert text to uppercase. Default: false.
+          - line_height: Line height multiplier for multiline text. Default: 1.1.
+      - text_elements: Configuration for text elements. Standard elements (name, context, date) have
+          defaults and render automatically. Set to false to hide.
+          Custom elements require 'text' and 'y' properties.
+          Element properties:
+          - text: Text content with {placeholder} substitution. Available: {name}, {context_name}, {issue_date}.
+          - y: Vertical position (PDF coordinates from bottom).
+          - size: Font size (inherited from defaults.size).
+          - font: Font name (inherited from defaults.font).
+          - color: Hex color (inherited from defaults.color).
+          - char_space: Character spacing (inherited from defaults.char_space).
+          - uppercase: Convert text to uppercase (inherited from defaults.uppercase).
+          - line_height: Line height multiplier for multiline text (inherited from defaults.line_height).
+
+    Example::
+
+      {
+        "template": "certificate-template",
+        "defaults": {"font": "CustomFont", "color": "#333"},
+        "text_elements": {
+          "name": {"y": 300, "uppercase": true},
+          "context": {"text": "Custom Course Name"},
+          "date": false,
+          "award_line": {"text": "Awarded on {issue_date}", "y": 140, "size": 14}
+        }
+      }
     """
     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')
 
-    # 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))
+    # Handle multiline context name.
+    context_name = get_learning_context_name(learning_context_key)
+    custom_context_name = ''
+    custom_context_text_element = options.get('text_elements', {}).get('context', {})
+    if isinstance(custom_context_text_element, dict):
+        custom_context_name = custom_context_text_element.get('text', '')
+
+    template_path = options.get('template')
+    if '\n' in context_name or '\n' in custom_context_name:
+        template_path = options.get('template_multiline', template_path)
 
     if not template_path:
         msg = "Template path must be specified in options."
@@ -246,14 +394,17 @@ def generate_pdf_credential(
     # Get template from the CredentialAsset.
     template_file = CredentialAsset.get_asset_by_slug(template_path)
 
+    # Get the issue date.
+    issue_date = get_localized_credential_date()
+
     # Load the PDF template.
     with template_file.open('rb') as template_file:
         template = PdfReader(template_file).pages[0]
 
         credential = PdfWriter()
 
-        # Create a new canvas, prepare the page and write the data
-        pdf_canvas = _write_text_on_template(template, username, context_name, options)
+        # Create a new canvas, prepare the page and write the data.
+        pdf_canvas = _write_text_on_template(template, username, context_name, issue_date, options)
 
         overlay_pdf = PdfReader(io.BytesIO(pdf_canvas.getpdfdata()))
         template.merge_page(overlay_pdf.pages[0])

learning_credentials/migrations/0007_migrate_to_text_elements_format.py

@@ -0,0 +1,138 @@
+"""Migration to convert credential options from flat format to text_elements format."""
+
+from django.db import migrations
+
+# Mapping from old option names to new text_elements structure.
+# Format: (old_key, element_key, property_name)
+_OPTION_MAPPINGS = [
+    # Name element mappings.
+    ('name_y', 'name', 'y'),
+    ('name_color', 'name', 'color'),
+    ('name_size', 'name', 'size'),
+    ('name_font', 'name', 'font'),
+    ('name_uppercase', 'name', 'uppercase'),
+    # Context element mappings.
+    ('context_name', 'context', 'text'),
+    ('context_name_y', 'context', 'y'),
+    ('context_name_color', 'context', 'color'),
+    ('context_name_size', 'context', 'size'),
+    ('context_name_font', 'context', 'font'),
+    # Date element mappings.
+    ('issue_date_y', 'date', 'y'),
+    ('issue_date_color', 'date', 'color'),
+    ('issue_date_size', 'date', 'size'),
+    ('issue_date_font', 'date', 'font'),
+    ('issue_date_char_space', 'date', 'char_space'),
+    ('issue_date_uppercase', 'date', 'uppercase'),
+]
+
+
+def _convert_to_text_elements(options):
+    """
+    Convert old flat options format to new text_elements format in-place.
+
+    :param options: The options dictionary to convert.
+    """
+    if not options:
+        return
+
+    # If already in new format, skip conversion.
+    if 'text_elements' in options or 'defaults' in options:
+        return
+
+    text_elements = {}
+
+    # Handle template_two_lines -> template_multiline rename.
+    if 'template_two_lines' in options:
+        template_two_lines = options.pop('template_two_lines')
+        # Only set template_multiline if it doesn't already exist.
+        if 'template_multiline' not in options:
+            options['template_multiline'] = template_two_lines
+
+    # Handle global font -> defaults.font.
+    if 'font' in options:
+        options['defaults'] = {'font': options.pop('font')}
+
+    # Convert element-specific options by popping them from the options dict.
+    for old_key, element_key, prop_name in _OPTION_MAPPINGS:
+        if old_key in options:
+            if element_key not in text_elements:
+                text_elements[element_key] = {}
+            text_elements[element_key][prop_name] = options.pop(old_key)
+
+    # Only add text_elements if we have any.
+    if text_elements:
+        options['text_elements'] = text_elements
+
+
+def _convert_to_flat_format(options):
+    """
+    Convert new text_elements format back to old flat options format in-place.
+
+    :param options: The options dictionary to convert.
+    """
+    if not options:
+        return
+
+    # If not in new format, skip conversion.
+    if 'text_elements' not in options and 'defaults' not in options:
+        return
+
+    # Handle template_multiline -> template_two_lines for backward compatibility.
+    if 'template_multiline' in options:
+        options['template_two_lines'] = options.pop('template_multiline')
+
+    # Handle defaults.font -> font.
+    defaults = options.pop('defaults', {})
+    if 'font' in defaults:
+        options['font'] = defaults['font']
+
+    # Convert text_elements back to flat format.
+    text_elements = options.pop('text_elements', {})
+
+    for old_key, element_key, prop_name in _OPTION_MAPPINGS:
+        element_config = text_elements.get(element_key, {})
+        if isinstance(element_config, dict) and prop_name in element_config:
+            options[old_key] = element_config[prop_name]
+
+
+def _migrate_all_options(apps, convert_func):
+    """
+    Apply a conversion function to all credential configurations.
+
+    :param apps: Django apps registry.
+    :param convert_func: Function to apply to each custom_options dict.
+    """
+    CredentialType = apps.get_model('learning_credentials', 'CredentialType')
+    CredentialConfiguration = apps.get_model('learning_credentials', 'CredentialConfiguration')
+
+    for credential_type in CredentialType.objects.all():
+        if credential_type.custom_options:
+            convert_func(credential_type.custom_options)
+            credential_type.save()
+
+    for config in CredentialConfiguration.objects.all():
+        if config.custom_options:
+            convert_func(config.custom_options)
+            config.save()
+
+
+def _migrate_forward(apps, schema_editor):
+    """Convert all credential configurations to the new text_elements format."""
+    _migrate_all_options(apps, _convert_to_text_elements)
+
+
+def _migrate_backward(apps, schema_editor):
+    """Convert all credential configurations back to the old flat format."""
+    _migrate_all_options(apps, _convert_to_flat_format)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('learning_credentials', '0006_cleanup_openedx_certificates_tables'),
+    ]
+
+    operations = [
+        migrations.RunPython(_migrate_forward, _migrate_backward),
+    ]

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
+from typing import TYPE_CHECKING, Self
 
 import jsonfield
 from django.conf import settings
@@ -33,6 +33,25 @@ if TYPE_CHECKING:  # pragma: no cover
 log = logging.getLogger(__name__)
 
 
+def _deep_merge(base: dict, override: dict) -> dict:
+    """
+    Deep merge two dictionaries.
+
+    Values from `override` take precedence. Nested dictionaries are merged recursively.
+
+    :param base: The base dictionary.
+    :param override: The dictionary with overriding values.
+    :return: A new dictionary with merged values.
+    """
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
 class CredentialType(TimeStampedModel):
     """
     Model to store global credential configurations for each type.
@@ -128,9 +147,8 @@ class CredentialConfiguration(TimeStampedModel):
         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]:
+    def get_enabled_configurations(cls) -> QuerySet[Self]:
         """
         Get the list of enabled configurations.
 
@@ -176,7 +194,7 @@ class CredentialConfiguration(TimeStampedModel):
         module = import_module(module_path)
         func = getattr(module, func_name)
 
-        custom_options = {**self.credential_type.custom_options, **self.custom_options}
+        custom_options = _deep_merge(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):
@@ -195,7 +213,7 @@ class CredentialConfiguration(TimeStampedModel):
         # 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}
+        custom_options = _deep_merge(self.credential_type.custom_options, self.custom_options)
 
         credential, _ = Credential.objects.update_or_create(
             user_id=user_id,

{learning_credentials-0.3.1rc2.dist-info → learning_credentials-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.3.1rc2
+Version: 0.4.0
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -11,6 +11,7 @@ Keywords: Python,edx,credentials,django
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
@@ -176,6 +177,21 @@ Unreleased
 
 *
 
+0.4.0 - 2026-01-28
+******************
+
+Added
+=====
+
+* New ``text_elements`` format for PDF credential generation with flexible text positioning and placeholder support.
+* Support for custom text elements with ``{name}``, ``{context_name}``, and ``{issue_date}`` placeholders.
+* Global ``defaults`` configuration for font, color, and character spacing.
+
+Modified
+========
+
+* Migrated generator options from flat format (``name_y``, ``context_name_color``, etc.) to structured ``text_elements`` format.
+
 0.3.1 - 2025-12-15
 ******************
 

{learning_credentials-0.3.1rc2.dist-info → learning_credentials-0.4.0.dist-info}/RECORD

@@ -3,8 +3,8 @@ learning_credentials/admin.py,sha256=ynK3tVJwLsIeV7Jk66t1FAVyVsU1G-KRIAdRkycVTmA
 learning_credentials/apps.py,sha256=trdQxe-JRhUdUaOQoQWiGL1sn6I1sfDiTvdCwy8yGuw,1037
 learning_credentials/compat.py,sha256=bTAB6bTh99ZyhUqOsDtM_BuIPzFxCjySFtfvc-_fCd4,4731
 learning_credentials/exceptions.py,sha256=UaqBVXFMWR2Iob7_LMb3j4NNVmWQFAgLi_MNMRUvGsI,290
-learning_credentials/generators.py,sha256=Ya0TbBD0-T0AWmp6VMQTtBmtgi2obs78vYX38SUmQX8,11696
-learning_credentials/models.py,sha256=J_SCNiu42yhdi12eDMLsxNCTkJK7_vqneQjyGYG5KJ4,16048
+learning_credentials/generators.py,sha256=gaw3zoEzVhSjo96QM6Q6K70e_iK44LxCuQIQ05p7lP0,14895
+learning_credentials/models.py,sha256=Nltf7cN6z2lUQM1L9eh4QRC8RSz3u59-Spf2_piAC1M,16581
 learning_credentials/processors.py,sha256=LkdjmkLBnXc9qeMcksB1T8AQ5ZhYaECyQO__KfHB_aU,15212
 learning_credentials/tasks.py,sha256=byoFEUvN_ayVaU5K5SlEiA7vu9BRPaSSmKnB9g5toec,1927
 learning_credentials/urls.py,sha256=gO_c930rzMylP-riQ9SGHXH9JIMF7ajySDT2Tc-E8x4,188
@@ -21,6 +21,7 @@ learning_credentials/migrations/0003_rename_certificates_to_credentials.py,sha25
 learning_credentials/migrations/0004_replace_course_keys_with_learning_context_keys.py,sha256=5KaXvASl69qbEaHX5_Ty_3Dr7K4WV6p8VWOx72yJnTU,1919
 learning_credentials/migrations/0005_rename_processors_and_generators.py,sha256=5UCqjq-CBJnRo1qBAoWs91ngyEuSMN8_tQtfzsuR5SI,5271
 learning_credentials/migrations/0006_cleanup_openedx_certificates_tables.py,sha256=aJs_gOP4TmW9J-Dmr21m94jBfLQxzjAu6-ua7x4uYLE,727
+learning_credentials/migrations/0007_migrate_to_text_elements_format.py,sha256=_olkaxPPuRys2c2X5fnyQIFVvqEfdoYu-JlApmXuHEM,4758
 learning_credentials/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_credentials/settings/__init__.py,sha256=tofc5eg3Q2lV13Ff_jjg1ggGgWpKYoeESkP1qxl3H_A,29
 learning_credentials/settings/common.py,sha256=Cck-nyFt11G1NLiz-bHfKJp8MV6sDZGqTwdbC8_1WE0,360
@@ -31,9 +32,9 @@ learning_credentials/templates/learning_credentials/edx_ace/certificate_generate
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/from_name.txt,sha256=-n8tjPSwfwAfeOSZ1WhcCTrpOah4VswzMZ5mh63Pxow,20
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/head.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/subject.txt,sha256=S7Hc5T_sZSsSBXm5_H5HBNNv16Ohl0oZn0nVqqeWL0g,132
-learning_credentials-0.3.1rc2.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
-learning_credentials-0.3.1rc2.dist-info/METADATA,sha256=fHxCRRyDHCO3lP4GOMR4qW4zBcrPPuATFjPJQ0iESmU,7756
-learning_credentials-0.3.1rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-learning_credentials-0.3.1rc2.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
-learning_credentials-0.3.1rc2.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
-learning_credentials-0.3.1rc2.dist-info/RECORD,,
+learning_credentials-0.4.0.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
+learning_credentials-0.4.0.dist-info/METADATA,sha256=bmCj26iPdnz7Q0y_u9wCrmUz6QgUtZOxGgkn_42WPYE,8294
+learning_credentials-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+learning_credentials-0.4.0.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
+learning_credentials-0.4.0.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
+learning_credentials-0.4.0.dist-info/RECORD,,

{learning_credentials-0.3.1rc2.dist-info → learning_credentials-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any