| import json |
| import os |
| import tempfile |
| import uuid |
| from datetime import date, datetime |
| from pathlib import Path |
| from typing import Any |
|
|
| import gradio as gr |
| from PIL import Image, ImageDraw, ImageFont |
| from datasets import load_dataset |
| from huggingface_hub import upload_file |
|
|
|
|
| BASE_DIR = Path(__file__).resolve().parent |
| TEMPLATE_PATH = BASE_DIR / "templates" / "certificate.png" |
| REGULAR_FONT_PATH = BASE_DIR / "Quattrocento-Regular.ttf" |
|
|
| VALIDATION_DATASET_ID = "diffusers/mvp-candidates" |
| PUSH_TOKEN = os.getenv("VALIDATION_DATASET_TOKEN") |
|
|
| CERTIFICATES_DATASET_REPO = "diffusers/mvp-certificates" |
| CERTIFICATES_DATASET_SUBDIR = Path("certificates") |
| CERTIFICATES_METADATA_SUBDIR = Path("metadata") |
|
|
|
|
| def _normalize_username(value: Any) -> str: |
| return str(value or "").strip().lower() |
|
|
|
|
| def _normalize_pr(value: Any) -> str: |
| return str(value or "").strip() |
|
|
| dataset = load_dataset(VALIDATION_DATASET_ID, split="train", token=PUSH_TOKEN) |
| _VALIDATION_INDEX = { |
| ( |
| _normalize_username(record.get("github_username")), |
| _normalize_pr(record.get("pr_number")), |
| ): record |
| for record in dataset |
| } |
|
|
| def generate_certificate(name: str, output_path: str | os.PathLike[str] | None = None): |
| """Generate certificate image and PDF.""" |
|
|
| im = Image.open(TEMPLATE_PATH) |
| d = ImageDraw.Draw(im) |
|
|
| name_font = ImageFont.truetype(str(REGULAR_FONT_PATH), 100) |
| date_font = ImageFont.truetype(str(REGULAR_FONT_PATH), 48) |
|
|
| formatted_name = name.title() |
| d.text((1000, 740), formatted_name, fill="black", anchor="mm", font=name_font) |
| d.text((1480, 1170), str(date.today()), fill="black", anchor="mm", font=date_font) |
|
|
| pdf_path = Path(output_path) if output_path else BASE_DIR / "certificate.pdf" |
| pdf_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| pdf = im.convert("RGB") |
| pdf.save(pdf_path) |
|
|
| return im, str(pdf_path) |
|
|
|
|
| def _require_validation_record(github_username: str, pr_number: str) -> dict[str, Any]: |
| key = (_normalize_username(github_username), _normalize_pr(pr_number)) |
| print(f"{_VALIDATION_INDEX=}, {key=}") |
| record = _VALIDATION_INDEX.get(key) |
| if record is None: |
| raise gr.Error( |
| "No matching entry was found. Make sure a maintainer has recognized your PR or issue " |
| "comment, and that your GitHub handle is correct." |
| ) |
| return record |
|
|
|
|
| def _build_metadata( |
| *, |
| github_username: str, |
| pr_number: str, |
| profile: gr.OAuthProfile, |
| record: dict[str, Any], |
| display_name: str, |
| ) -> dict[str, Any]: |
| return { |
| "github_username": github_username.strip(), |
| "pr_number": pr_number, |
| "issued_at": datetime.now().isoformat() + "Z", |
| "display_name": display_name, |
| "huggingface": { |
| "username": profile.username, |
| "name": profile.name, |
| "profile_url": profile.profile, |
| "avatar": profile.picture, |
| }, |
| "validation_record": record, |
| } |
|
|
|
|
| def _upload_certificate( |
| pdf_path: Path, metadata: dict[str, Any], token: str | None = None |
| ) -> str: |
| if not CERTIFICATES_DATASET_REPO: |
| raise gr.Error( |
| "Set CERTIFICATES_DATASET_REPO so the app knows where to store certificates." |
| ) |
| issued_at = datetime.now().strftime("%Y%m%dT%H%M%S") |
| unique_suffix = uuid.uuid4().hex[:8] |
| pdf_filename = f"certificate-{issued_at}-{unique_suffix}.pdf" |
| metadata_filename = pdf_filename.replace(".pdf", ".json") |
|
|
| pdf_remote_path = CERTIFICATES_DATASET_SUBDIR / pdf_filename |
| metadata_remote_path = CERTIFICATES_METADATA_SUBDIR / metadata_filename |
|
|
| with tempfile.TemporaryDirectory() as tmpdir: |
| metadata_path = Path(tmpdir) / metadata_filename |
| metadata_path.write_text(json.dumps(metadata, indent=2), encoding="utf-8") |
|
|
| upload_file( |
| path_or_fileobj=str(pdf_path), |
| path_in_repo=str(pdf_remote_path), |
| repo_id=CERTIFICATES_DATASET_REPO, |
| repo_type="dataset", |
| token=PUSH_TOKEN |
| ) |
| upload_file( |
| path_or_fileobj=str(metadata_path), |
| path_in_repo=str(metadata_remote_path), |
| repo_id=CERTIFICATES_DATASET_REPO, |
| repo_type="dataset", |
| token=PUSH_TOKEN |
| ) |
|
|
| return ( |
| "https://huggingface.co/datasets/" |
| f"{CERTIFICATES_DATASET_REPO}/resolve/main/{pdf_remote_path}" |
| ) |
|
|
|
|
| def issue_certificate( |
| github_username: str, |
| pr_number: str, |
| name: str, |
| profile: gr.OAuthProfile | None, |
| ) -> str: |
| if not github_username.strip() or not pr_number: |
| raise gr.Error("Both GitHub username and PR or issue number are required.") |
|
|
| if not name.strip(): |
| raise gr.Error("Please provide the full name for the certificate.") |
|
|
| if profile is None: |
| raise gr.Error("Please sign in with your Hugging Face account to continue.") |
|
|
| record = _require_validation_record(github_username, pr_number) |
|
|
| normalized_pr = _normalize_pr(pr_number) |
| sanitized_username = _normalize_username(github_username).replace("/", "-") |
|
|
| with tempfile.TemporaryDirectory() as tmpdir: |
| pdf_path = Path(tmpdir) / f"{sanitized_username}-pr{normalized_pr}.pdf" |
| _, generated_pdf_path = generate_certificate(name, output_path=str(pdf_path)) |
| pdf_path = Path(generated_pdf_path) |
|
|
| metadata = _build_metadata( |
| github_username=github_username, |
| pr_number=normalized_pr, |
| profile=profile, |
| record=record, |
| display_name=name.title(), |
| ) |
|
|
| certificate_url = _upload_certificate( |
| pdf_path=pdf_path, |
| metadata=metadata, |
| ) |
|
|
| return f"[Open certificate ↗]({certificate_url})" |
|
|
|
|
| with gr.Blocks(title="MVP Certificate Generator") as demo: |
| gr.Markdown( |
| """ |
| # MVP Certificate Generator |
| |
| Sign in with your Hugging Face account, enter the PR or issue you were recognized for, and mint a certificate. |
| """ |
| ) |
|
|
| gr.LoginButton() |
|
|
| with gr.Row(): |
| github_username_input = gr.Textbox( |
| label="GitHub Username", |
| placeholder="huggingface", |
| autofocus=True, |
| ) |
| pr_number_input = gr.Textbox(label="PR or issue number", placeholder="42") |
| name_input = gr.Textbox(label="Name on Certificate", placeholder="Jane Doe") |
|
|
| generate_button = gr.Button("Generate certificate", variant="primary") |
| certificate_output = gr.Markdown( |
| value="_Certificate link will appear here after successful verification._", |
| elem_id="certificate-link-output", |
| ) |
|
|
| generate_button.click( |
| fn=issue_certificate, |
| inputs=[github_username_input, pr_number_input, name_input], |
| outputs=certificate_output, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| demo.launch() |
|
|
