איך מתחילים לעבוד עם קריטריונים להערכה

rubric הוא תבנית שמורים יכולים להשתמש בה כדי לתת ציונים על עבודות שהתלמידים הגישו. באמצעות Classroom API תוכלו לפעול בשם המורה כדי לנהל את הקריטריונים האלה.

איור 1. דוגמה לקריטריון הערכה במטלה ב-Classroom.

במדריך הזה נסביר את המושגים הבסיסיים ואת הפונקציונליות של Rubrics API. במאמרים הבאים במרכז העזרה מוסבר על המבנה הכללי של קריטריון להערכת מטלה ועל אופן הערכת המטלות לפי קריטריון בממשק המשתמש של Classroom.

דרישות מוקדמות

במדריך הזה אנחנו יוצאים מנקודת הנחה שיש לכם:

• Python 3.8.6 ואילך
• הכלי לניהול חבילות pip
• פרויקט ב-Google Cloud.
• חשבון Google Workspace for Education שבו Google Classroom מופעל.
• כיתה לבדיקה עם לפחות חשבון אחד של תלמיד לבדיקה. אם אין לכם כיתה ב-Classroom שאפשר להשתמש בה לצורך בדיקה, יוצרים כיתה בממשק המשתמש ומוסיפים תלמיד/ה לצורך בדיקה.

מתן הרשאה לפרטי כניסה לאפליקציה למחשב

כדי לבצע אימות כמשתמש קצה ולגשת לנתוני המשתמשים באפליקציה, צריך ליצור מזהה לקוח אחד או יותר ב-OAuth 2.0. מזהה לקוח משמש לזיהוי אפליקציה אחת בשרתי OAuth של Google. אם האפליקציה פועלת בכמה פלטפורמות, צריך ליצור מזהה לקוח נפרד לכל פלטפורמה.

1. נכנסים לדף Credentials ב-Google Cloud במסוף Google Cloud.
2. לוחצים על Create Credentials (יצירת פרטי כניסה) > OAuth client ID (מזהה לקוח OAuth).
3. לוחצים על Application type (סוג האפליקציה) > Desktop app (אפליקציה למחשב).
4. בשדה Name, מקלידים שם לפרטי הכניסה. השם הזה מוצג רק במסוף Google Cloud. לדוגמה, 'Rubrics Preview client'.
5. לוחצים על יצירה. יופיע המסך של לקוח OAuth שנוצר, שבו יוצגו מזהה הלקוח וסוד הלקוח החדשים.
6. לוחצים על הורדת קובץ JSON ואז על אישור. פרטי הכניסה שנוצרו מופיעים בקטע OAuth 2.0 Client IDs.
7. שומרים את קובץ ה-JSON שהורדתם בתור credentials.json ומעבירים אותו לספריית העבודה.
8. לוחצים על Create Credentials (יצירת פרטי כניסה) > API Key (מפתח API) ומתעדים את מפתח ה-API.

מידע נוסף זמין במאמר יצירת פרטי כניסה.

הגדרת היקפי הרשאות של OAuth

בהתאם להיקפי ה-OAuth הקיימים בפרויקט, יכול להיות שתצטרכו להגדיר היקפים נוספים.

1. עוברים אל מסך ההסכמה של OAuth.
2. לוחצים על עריכת האפליקציה > שמירה והמשך כדי להגיע למסך 'היקפי גישה'.
3. לוחצים על הוספה או הסרה של היקפים.
4. מוסיפים את ההיקפים הבאים אם הם עדיין לא קיימים:
   • https://www.googleapis.com/auth/classroom.coursework.students
   • https://www.googleapis.com/auth/classroom.courses
5. לאחר מכן לוחצים על 'עדכון' > שמירה והמשך > שמירה והמשך > חזרה למרכז הבקרה.

למידע נוסף, ראו הגדרת מסך ההסכמה של OAuth.

ההיקף classroom.coursework.students מאפשר גישת קריאה וכתיבה למסמכי הערכה (יחד עם גישה ל-CourseWork), והיקף ההרשאות classroom.courses מאפשר קריאה וכתיבה של קורסים.

ההיקפים הנדרשים לשיטה מסוימת מפורטים במסמכי העזרה של השיטה. לדוגמה, היקפי הרשאה של courses.courseWork.rubrics.create. אפשר לראות את כל היקפי ההרשאות של Classroom במאמר היקפי OAuth 2.0 ל-Google APIs. האפשרות 'קריטריונים' לא מוזכרת כאן כי ה-API עדיין נמצא בתצוגה מקדימה.

הגדרת הדוגמה

בספריית העבודה, מתקינים את ספריית הלקוח של Google ל-Python:

pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib

הערה: השדות והשיטות שקשורים למדריכים לא גלויים בספריות הלקוח הסטנדרטיות, כי ה-CRUD של מדריכים נמצא בתצוגה מקדימה למפתחים. בדוגמה הבאה מצוין התווית DEVELOPER_PREVIEW במהלך יצירת הספרייה כדי לאפשר חשיפה. במאמר גישה ל-Preview API מוסבר בהרחבה איך משתמשים ב-Preview API עם ספריות לקוח.

יוצרים קובץ בשם main.py שמאגר את ספריית הלקוח ומעניק הרשאה למשתמש, באמצעות מפתח ה-API במקום YOUR_API_KEY:

import json
import os.path

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# If modifying these scopes, delete the file token.json.
SCOPES = ['https://www.googleapis.com/auth/classroom.courses',
          'https://www.googleapis.com/auth/classroom.coursework.students']

def build_authenticated_service(api_key):
    """Builds the Classroom service."""
    creds = None
    # The file token.json stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run.
        with open('token.json', 'w') as token:
            token.write(creds.to_json())

    try:
        # Build the Classroom service.
        service = build(
            serviceName="classroom",
            version="v1",
            credentials=creds,
            discoveryServiceUrl=f"https://classroom.googleapis.com/$discovery/rest?labels=DEVELOPER_PREVIEW&key={api_key}")

        return service

    except HttpError as error:
        print('An error occurred: %s' % error)

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

מריצים את הסקריפט באמצעות python main.py. תתבקשו להיכנס לחשבון ולהסכים להיקפי של OAuth.

יצירת מטלה

קריטריון הערכה משויך למטלה, או ל-CourseWork, והוא רלוונטי רק בהקשר של ה-CourseWork הזה. רק משתמשים בפרויקט ב-Google Cloud שבו נוצר פריט ההורה CourseWork יכולים ליצור קריטריונים למתן ציונים. לצורך המדריך הזה, יוצרים מטלה חדשה מסוג CourseWork עם סקריפט.

מוסיפים את הפרטים הבאים ל-main.py:

def get_latest_course(service):
    """Retrieves the last created course."""
    try:
        response = service.courses().list(pageSize=1).execute()
        courses = response.get("courses", [])
        if not courses:
            print("No courses found. Did you remember to create one in the UI?")
            return
        course = courses[0]
        return course

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

def create_coursework(service, course_id):
    """Creates and returns a sample coursework."""
    try:
        coursework = {
            "title": "Romeo and Juliet analysis.",
            "description": """Write a paper arguing that Romeo and Juliet were
                                time travelers from the future.""",
            "workType": "ASSIGNMENT",
            "state": "PUBLISHED",
        }
        coursework = service.courses().courseWork().create(
            courseId=course_id, body=coursework).execute()
        return coursework

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

עכשיו מעדכנים את main.py כדי לאחזר את course_id של כיתה הבדיקה שיצרתם, יוצרים מטלה לדוגמה ומאחזרים את coursework_id של המטלה:

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

    course = get_latest_course(service)
    course_id = course.get("id")
    course_name = course.get("name")
    print(f"'{course_name}' course ID: {course_id}")

    coursework = create_coursework(service, course_id)
    coursework_id = coursework.get("id")
    print(f"Assignment created with ID {coursework_id}")

    #TODO(developer): Save the printed course and coursework IDs.

שומרים את course_id ואת coursework_id. הם נדרשים לכל פעולות ה-CRUD של הקריטריונים.

עכשיו אמורה להופיע דוגמה של CourseWork ב-Classroom.

איור 2. תצוגה של מטלה לדוגמה ב-Classroom.

יצירת קריטריון הערכה

עכשיו אתם מוכנים להתחיל לנהל קריטריונים למתן ציונים.

אפשר ליצור קריטריון הערכה ב-CourseWork באמצעות קריאה ל-Create שמכילה את אובייקט הקריטריון המלא, בלי מאפייני המזהה של הקריטריונים והרמות (הם נוצרים בזמן היצירה).

הערה: מכיוון ש-CRUD של Rubrics נמצא בתצוגה מקדימה למפתחים, קריאות לשירות Rubrics מחזירות שגיאה אם לא צוין previewVersion מתאים. בדוגמה הבאה, ובכל הקריאות הבאות שקשורות לקריטריונים, השדה previewVersion מוגדר כ-V1_20231110_PREVIEW. במאמר גישה לממשקי API בגרסאות טרום-השקה מוסבר איך מציינים גרסאות, ובתוכנית העבודה מפורטות הגרסאות הנתמכות.

מוסיפים את הפונקציה הבאה ל-main.py:

def create_rubric(service, course_id, coursework_id):
    """Creates an example rubric on a coursework."""
    try:
        body = {
            "criteria": [
                {
                    "title": "Argument",
                    "description": "How well structured your argument is.",
                    "levels": [
                        {"title": "Convincing",
                         "description": "A compelling case is made.", "points": 30},
                        {"title": "Passable",
                         "description": "Missing some evidence.", "points": 20},
                        {"title": "Needs Work",
                         "description": "Not enough strong evidence..", "points": 0},
                    ]
                },
                {
                    "title": "Spelling",
                    "description": "How well you spelled all the words.",
                    "levels": [
                        {"title": "Perfect",
                         "description": "No mistakes.", "points": 20},
                        {"title": "Great",
                         "description": "A mistake or two.", "points": 15},
                        {"title": "Needs Work",
                         "description": "Many mistakes.", "points": 5},
                    ]
                },
                {
                    "title": "Grammar",
                    "description": "How grammatically correct your sentences are.",
                    "levels": [
                        {"title": "Perfect",
                         "description": "No mistakes.", "points": 20},
                        {"title": "Great",
                         "description": "A mistake or two.", "points": 15},
                        {"title": "Needs Work",
                         "description": "Many mistakes.", "points": 5},
                    ]
                },
            ]
        }

        rubric = service.courses().courseWork().rubrics().create(
            courseId=course_id, courseWorkId=coursework_id, body=body,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
            ).execute()
        print(f"Rubric created with ID {rubric.get('id')}")
        return rubric

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

לאחר מכן מעדכנים ומריצים את main.py כדי ליצור את מערכת הדירוג לדוגמה, באמצעות המזהים Course ו-CourseWork שציינתם קודם:

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

    rubric = create_rubric(service, YOUR_COURSE_ID, YOUR_COURSEWORK_ID)
    print(json.dumps(rubric, indent=4))

הערה: שימו לב שהקריטריונים המוחזרים מכילים את הערך של previewVersion שצוין בקריאה ל-CREATE. משאבים שמשויכים לקריאה לשיטה של תצוגה מקדימה מכילים גם את הערך של previewVersion ששימש בקריאה, בתור שדה לקריאה בלבד, כדי לעזור לכם להבין באיזו גרסה אתם משתמשים.

כמה נקודות לגבי ייצוג הקריטריון להערכה:

• הסדר של הקריטריונים והרמות משתקף בממשק המשתמש של Classroom.
• רמות עם ניקוד (אלה עם המאפיין points) חייבות להיות ממוינות לפי נקודות בסדר עולה או יורד (אי אפשר למיין אותן באופן אקראי).
• המורים יכולים למיין מחדש את הקריטריונים והרמות עם הציונים (אבל לא את הרמות ללא ציונים) בממשק המשתמש, והסדר שלהם בנתונים ישתנה.

מגבלות – מידע נוסף על מגבלות לגבי מבנה של קריטריונים להערכה.

חזרה לממשק המשתמש, שם מערכת הבקרה אמורה להופיע במטלה.

איור 3. דוגמה לקריטריון הערכה במטלה ב-Classroom.

קריאת קריטריון הערכה

אפשר לקרוא קריטריונים למתן ציונים באמצעות השיטות הסטנדרטיות List ו-Get.

אפשר להשתמש ב-List כדי להוסיף קריטריון הערכה למטלה, אבל לא ניתן להשתמש בו כדי להוסיף יותר מקריטריון הערכה אחד למטלה. אם לא משויך ל-CourseWork קריטריון הערכה, התשובה List תהיה ריקה.

מוסיפים את הפונקציה הבאה ל-main.py:

def get_rubric(service, course_id, coursework_id):
    """
    Get the rubric on a coursework. There can only be at most one.
    Returns null if there is no rubric.
    """
    try:
        response = service.courses().courseWork().rubrics().list(
            courseId=course_id, courseWorkId=coursework_id,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
            ).execute()

        rubrics = response.get("rubrics", [])
        if not rubrics:
            print("No rubric found for this assignment.")
            return
        rubric = rubrics[0]
        return rubric

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

מעדכנים ומריצים את main.py כדי לאחזר את קריטריון ההערכה שהוספתם:

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

    rubric = get_rubric(service, YOUR_COURSE_ID, YOUR_COURSEWORK_ID)
    print(json.dumps(rubric, indent=4))

    #TODO(developer): Save the printed rubric ID.

שימו לב לנכס id בסכימה בשביל השלבים הבאים.

Get פועל היטב כשיש לכם את מזהה כלי הערכה. השימוש ב-Get בפונקציה במקום זאת עשוי להיראות כך:

def get_rubric(service, course_id, coursework_id, rubric_id):
    """
    Get the rubric on a coursework. There can only be at most one.
    Returns a 404 if there is no rubric.
    """
    try:
        rubric = service.courses().courseWork().rubrics().get(
            courseId=course_id,
            courseWorkId=coursework_id,
            id=rubric_id,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
        ).execute()

        return rubric

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

ההטמעה הזו מחזירה שגיאת 404 אם אין קריטריון הערכה.

עדכון של קריטריון הערכה

עדכונים של קריטריונים מתבצעים באמצעות קריאות ל-Patch. בגלל המבנה המורכב של קריטריון הערכה, צריך לבצע עדכונים לפי תבנית קריאה-שינוי-כתיבה, שבה כל נכס criteria מוחלף.

כללי העדכון הם:

1. קריטריונים או רמות שנוספו ללא מזהה נחשבים תוספות.
2. קריטריונים או רמות שאינם מוצגים נחשבים למחקות.
3. קריטריונים או רמות עם מזהה קיים אבל עם נתונים ששונו נחשבים עריכות. מאפיינים שלא שונו יישארו כפי שהם.
4. קריטריונים או רמות שצוינו עם מזהים חדשים או לא מוכרים נחשבים לשגיאות.
5. הסדר של הקריטריונים והרמות החדשים נחשב לסדר החדש בממשק המשתמש (עם המגבלות שצוינו למעלה).

מוסיפים פונקציה לעדכון קריטריון הערכה:

def update_rubric(service, course_id, coursework_id, rubric_id, body):
    """
    Updates the rubric on a coursework.
    """
    try:
        rubric = service.courses().courseWork().rubrics().patch(
            courseId=course_id,
            courseWorkId=coursework_id,
            id=rubric_id,
            body=body,
            updateMask='criteria',
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
        ).execute()

        return rubric

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

בדוגמה הזו, השדה criteria צוין לשינוי באמצעות updateMask.

לאחר מכן משנים את main.py כדי לבצע שינוי בכל אחד מכללי העדכון שצוינו למעלה:

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

    # Get the latest rubric.
    rubric = get_rubric(service, YOUR_COURSE_ID, YOUR_COURSEWORK_ID)
    criteria = rubric.get("criteria")
    """
    The "criteria" property should look like this:
    [
        {
            "id": "NkEyMdMyMzM2Nxkw",
            "title": "Argument",
            "description": "How well structured your argument is.",
            "levels": [
                {
                    "id": "NkEyMdMyMzM2Nxkx",
                    "title": "Convincing",
                    "description": "A compelling case is made.",
                    "points": 30
                },
                {
                    "id": "NkEyMdMyMzM2Nxky",
                    "title": "Passable",
                    "description": "Missing some evidence.",
                    "points": 20
                },
                {
                    "id": "NkEyMdMyMzM2Nxkz",
                    "title": "Needs Work",
                    "description": "Not enough strong evidence..",
                    "points": 0
                }
            ]
        },
        {
            "id": "NkEyMdMyMzM2Nxk0",
            "title": "Spelling",
            "description": "How well you spelled all the words.",
            "levels": [...]
        },
        {
            "id": "NkEyMdMyMzM2Nxk4",
            "title": "Grammar",
            "description": "How grammatically correct your sentences are.",
            "levels": [...]
        }
    ]
    """

    # Make edits. This example will make one of each type of change.

    # Add a new level to the first criteria. Levels must remain sorted by
    # points.
    new_level = {
        "title": "Profound",
        "description": "Truly unique insight.",
        "points": 50
    }
    criteria[0]["levels"].insert(0, new_level)

    # Remove the last criteria.
    del criteria[-1]

    # Update the criteria titles with numeric prefixes.
    for index, criterion in enumerate(criteria):
        criterion["title"] = f"{index}: {criterion['title']}"

    # Resort the levels from descending to ascending points.
    for criterion in criteria:
        criterion["levels"].sort(key=lambda level: level["points"])

    # Update the rubric with a patch call.
    new_rubric = update_rubric(
        service, YOUR_COURSE_ID, YOUR_COURSEWORK_ID, YOUR_RUBRIC_ID, rubric)

    print(json.dumps(new_rubric, indent=4))

השינויים אמורים להופיע עכשיו אצל המורה ב-Classroom.

איור 4. תצוגה של הקריטריון המעודכן.

הערה: כללי העריכה האלה יהיו מוגבלים יותר אחרי שתתחילו לתת ציונים.

הצגת מטלות שהוגשו ונבדקו באמצעות קריטריון הערכה

בשלב הזה, לא ניתן להשתמש ב-API כדי לתת ציונים על עבודות של תלמידים באמצעות קריטריון הערכה, אבל אפשר לקרוא את הציונים לפי קריטריון הערכה בעבודות שהועברו עם קריטריון הערכה בממשק המשתמש של Classroom.

בתור תלמידים בממשק המשתמש של Classroom, מסיימים את המטלה לדוגמה ומגישים אותה. לאחר מכן, המורה יכול לתת ציון למטלה באופן ידני באמצעות קריטריון ההערכה.

איור 5. התצוגה של כלי למתן ציונים למורים במהלך מתן הציונים.

טיפ: כדאי להכיר את הגמישות שיש למורים כשהם משתמשים בקריטריונים. לדוגמה, שימו לב שהמורה יכול לשנות את מספר הנקודות שמקבלים על עמידה בקריטריונים ברמות שבחרתם, את הציון הכולל של המטלה שמחושב על סמך הקריטריונים, ואת האפשרות לבחור רמות בכלל. מידע נוסף זמין בקטע מגבלות.

הגשות של תלמידים שקיבלו ציון באמצעות קריטריון הערכה כוללות שתי מאפיינים חדשים: draftRubricGrades ו-assignedRubricGrades, שמייצגים את הנקודות והרמות שבחר המורה במצבי הערכה של 'טיוטה' ו'הוקצה', בהתאמה.

בנוסף, הגשות של תלמידים עם קריטריון הערכה משויך מכילות את השדה rubricId, גם לפני מתן הציונים. הערך הזה מייצג את מערכת הדירוג האחרונה שמשויכת למטלה CourseWork, והוא עשוי להשתנות אם המורים מוחקים מערכת דירוג ויוצרים אותה מחדש.

אפשר להשתמש בשיטות הקיימות studentSubmissions.Get ו-studentSubmissions.List כדי להציג את המטלות שהתלמידים הגישו וקיבלתם עליהן ציונים.

אזהרה: השדות rubricId, ‏ draftRubricGrades ו-assignedRubricGrades לא חשופים כברירת מחדל ב-Classroom API, וניתן לגשת אליהם רק בתצוגה המקדימה למפתחים. כלומר, צריך להגדיר previewVersion מתאים כדי לאחזר אותם. בניגוד לשירות הדירוגים, קריאות לשירות השליחה לא מחזירות שגיאות כשהגרסה לא מופיעה. השדות האלה מתויגים ככאלה בחומר העזר.

מוסיפים את הפונקציה הבאה ל-main.py כדי להציג את המטלות שהתלמידים הגישו:

def get_latest_submission(service, course_id, coursework_id):
    """Retrieves the last submission for an assignment."""
    try:
        response = service.courses().courseWork().studentSubmissions().list(
            courseId = course_id,
            courseWorkId = coursework_id,
            pageSize=1,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
        ).execute()
        submissions = response.get("studentSubmissions", [])
        if not submissions:
            print(
                """No submissions found. Did you remember to turn in and grade
                   the assignment in the UI?""")
            return
        submission = submissions[0]
        return submission

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

לאחר מכן מעדכנים ומריצים את main.py כדי להציג את הציונים שהתקבלו.

if __name__ == '__main__':
    service = build_authenticated_service(YOUR_API_KEY)

    submission = get_latest_submission(
        service, YOUR_COURSE_ID, YOUR_COURSEWORK_ID)
    print(json.dumps(submission, indent=4))

השדות draftRubricGrades ו-assignedRubricGrades מכילים את הפרטים הבאים:

• הערך של criterionId בקריטריונים המתאימים של כלי הערכה.
• הערך של points שהמורה הקצתה לכל קריטריון. יכול להיות שהיא נובעת מהרמה שנבחרה, אבל יכול להיות גם שהמורה ביצע שינוי.
• הערך של levelId ברמה שנבחרה לכל קריטריון. אם המורה לא בחר רמה, אבל עדיין הקצה נקודות לפי הקריטריון, השדה הזה לא יופיע.

הרשימות האלה מכילות רק רשומות של קריטריונים שבהם המורה בחר רמה או הגדיר נקודות. לדוגמה, אם מורה בוחר לבצע אינטראקציה רק עם קריטריון אחד במהלך מתן הציונים, ב-draftRubricGrades וב-assignedRubricGrades יופיע רק פריט אחד, גם אם לקריטריונים יש הרבה קריטריונים.

טיפ: זה הזמן המתאים להתנסות במאפיינים האלה. כדי לתת שוב ציון למטלה בממשק המשתמש של Classroom, צריך לשלוח אותה מחדש בתור התלמיד/ה, לעבור לחשבון המורה, לבחור באפשרות ניקוי, לבצע בחירות חדשות ולהחזיר את המטלה שוב. לאחר מכן תוכלו להריץ מחדש את סקריפט Python כדי לראות את השינויים באובייקט ההגשה של התלמיד/ה.

מחיקת קריטריון הערכה

אפשר למחוק קריטריון הערכה באמצעות בקשה רגילה מסוג Delete. הקוד הבא מציג פונקציית דוגמה לצורך השלמות, אבל מאחר שההערכה כבר החלה, אי אפשר למחוק את מערכת הדירוג הנוכחית:

def delete_rubric(service, course_id, coursework_id, rubric_id):
    """Deletes the rubric on a coursework."""
    try:
        service.courses().courseWork().rubrics().delete(
            courseId=course_id,
            courseWorkId=coursework_id,
            id=rubric_id,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
        ).execute()

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

ייצוא וייבוא של קריטריונים

אפשר לייצא קריטריונים להערכה באופן ידני ל-Google Sheets כדי שהמורים יוכלו להשתמש בהם שוב.

בנוסף לציון קריטריונים של קריטריונים בקוד, אפשר ליצור ולעדכן קריטריונים מהגיליונות המיוצאים האלה על ידי ציון הערך sourceSpreadsheetId בגוף הקריטריון במקום criteria:

הערה: כדי ליצור (או לעדכן) קריטריון להערכת מטלה מגיליון אלקטרוני של משתמש, האפליקציה צריכה לבקש את ההיקף https://www.googleapis.com/auth/spreadsheets.readonly או https://www.googleapis.com/auth/spreadsheets. כדי לעשות זאת, מוסיפים את אחד מההיקפים לפרויקט כפי שמתואר בקטע בנושא הגדרת OAuth ומעדכנים את המשתנה SCOPES ב-main.py כך שיכלול את ההיקף. מוחקים את token.json כדי שתוכלו להעניק הרשאה מחדש עם ההיקפים החדשים בפעם הבאה שתפעילו את main.py. חשוב לזכור שההיקפים spreadsheets נחשבים רגישים, וייתכן שיהיה צורך לאמת את האפליקציה.

def create_rubric_from_sheet(service, course_id, coursework_id, sheet_id):
    """Creates an example rubric on a coursework."""
    try:
        body = {
            "sourceSpreadsheetId": sheet_id
        }

        rubric = service.courses().courseWork().rubrics().create(
            courseId=course_id, courseWorkId=coursework_id, body=body,
            # Specify the preview version. Rubrics CRUD capabilities are
            # supported in V1_20231110_PREVIEW and later.
            previewVersion="V1_20231110_PREVIEW"
            ).execute()

        print(f"Rubric created with ID {rubric.get('id')}")
        return rubric

    except HttpError as error:
        print(f"An error occurred: {error}")
        return error

משוב

אם נתקלתם בבעיות או שיש לכם משוב, תוכלו לשלוח לנו משוב.