<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="classroom_v1.html">Google Classroom API</a> . <a href="classroom_v1.courses.html">courses</a> . <a href="classroom_v1.courses.courseWork.html">courseWork</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="classroom_v1.courses.courseWork.studentSubmissions.html">studentSubmissions()</a></code>
</p>
<p class="firstline">Returns the studentSubmissions Resource.</p>

<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#create">create(courseId, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Creates course work. The resulting course work (and corresponding student submissions) are associated with the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to make the request. Classroom API requests to modify course work and student submissions must be made with an OAuth client ID from the associated Developer Console project. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course, create course work in the requested course, share a Drive attachment, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course does not exist. * `FAILED_PRECONDITION` for the following request error: * AttachmentNotVisible</p>
<p class="toc_element">
  <code><a href="#delete">delete(courseId, id, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes a course work. This request must be made by the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to create the corresponding course work item. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting developer project did not create the corresponding course work, if the requesting user is not permitted to delete the requested course or for access errors. * `FAILED_PRECONDITION` if the requested course work has already been deleted. * `NOT_FOUND` if no course exists with the requested ID.</p>
<p class="toc_element">
  <code><a href="#get">get(courseId, id, x__xgafv=None)</a></code></p>
<p class="firstline">Returns course work. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or course work, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course or course work does not exist.</p>
<p class="toc_element">
  <code><a href="#list">list(courseId, courseWorkStates=None, orderBy=None, pageToken=None, pageSize=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns a list of course work that the requester is permitted to view. Course students may only view `PUBLISHED` course work. Course teachers and domain administrators may view all course work. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course does not exist.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#modifyAssignees">modifyAssignees(courseId, id, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Modifies assignee mode and options of a coursework. Only a teacher of the course that contains the coursework may call this method. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or course work or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course or course work does not exist.</p>
<p class="toc_element">
  <code><a href="#patch">patch(courseId, id, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates one or more fields of a course work. See google.classroom.v1.CourseWork for details of which fields may be updated and who may change them. This request must be made by the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to create the corresponding course work item. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting developer project did not create the corresponding course work, if the user is not permitted to make the requested modification to the student submission, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `FAILED_PRECONDITION` if the requested course work has already been deleted. * `NOT_FOUND` if the requested course, course work, or student submission does not exist.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="create">create(courseId, body=None, x__xgafv=None)</code>
  <pre>Creates course work. The resulting course work (and corresponding student submissions) are associated with the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to make the request. Classroom API requests to modify course work and student submissions must be made with an OAuth client ID from the associated Developer Console project. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course, create course work in the requested course, share a Drive attachment, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course does not exist. * `FAILED_PRECONDITION` for the following request error: * AttachmentNotVisible

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  body: object, The request body.
    The object takes the form of:

{ # Course work created by a teacher for students of the course.
  &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
    &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
      &quot;A String&quot;,
    ],
  },
  &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
  &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
  &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
  &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
  &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
    { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
      &quot;form&quot;: { # Google Forms item. # Google Forms material.
        &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
        &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
      },
      &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
        &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
        &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
      },
      &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
        &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
          &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
        },
        &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
      },
      &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
        &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
        &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
      },
    },
  ],
  &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
  &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
  &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
    &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
    &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
  },
  &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
    &quot;choices&quot;: [ # Possible choices.
      &quot;A String&quot;,
    ],
  },
  &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
  &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
  &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
  &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
  &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
  &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
    &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
    &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
    &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
  },
  &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
    &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
      &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
      &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
      &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
    },
  },
  &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
  &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
  &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
  &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
  &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Course work created by a teacher for students of the course.
    &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
      &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
        &quot;A String&quot;,
      ],
    },
    &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
    &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
    &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
    &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
    &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
      { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
        &quot;form&quot;: { # Google Forms item. # Google Forms material.
          &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
          &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
        },
        &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
          &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
        },
        &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
          &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
            &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
            &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
            &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
            &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
          },
          &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
        },
        &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
          &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
        },
      },
    ],
    &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
    &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
    &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
      &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
      &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
      &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
      &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
    },
    &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
      &quot;choices&quot;: [ # Possible choices.
        &quot;A String&quot;,
      ],
    },
    &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
    &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
    &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
    &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
    &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
    &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
      &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
      &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
      &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
    },
    &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
      &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
        &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
      },
    },
    &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
    &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
    &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
    &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
    &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
  }</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(courseId, id, x__xgafv=None)</code>
  <pre>Deletes a course work. This request must be made by the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to create the corresponding course work item. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting developer project did not create the corresponding course work, if the requesting user is not permitted to delete the requested course or for access errors. * `FAILED_PRECONDITION` if the requested course work has already been deleted. * `NOT_FOUND` if no course exists with the requested ID.

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  id: string, Identifier of the course work to delete. This identifier is a Classroom-assigned identifier. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(courseId, id, x__xgafv=None)</code>
  <pre>Returns course work. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or course work, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course or course work does not exist.

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  id: string, Identifier of the course work. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Course work created by a teacher for students of the course.
    &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
      &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
        &quot;A String&quot;,
      ],
    },
    &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
    &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
    &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
    &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
    &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
      { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
        &quot;form&quot;: { # Google Forms item. # Google Forms material.
          &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
          &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
        },
        &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
          &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
        },
        &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
          &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
            &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
            &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
            &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
            &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
          },
          &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
        },
        &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
          &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
        },
      },
    ],
    &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
    &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
    &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
      &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
      &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
      &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
      &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
    },
    &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
      &quot;choices&quot;: [ # Possible choices.
        &quot;A String&quot;,
      ],
    },
    &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
    &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
    &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
    &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
    &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
    &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
      &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
      &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
      &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
    },
    &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
      &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
        &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
      },
    },
    &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
    &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
    &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
    &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
    &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(courseId, courseWorkStates=None, orderBy=None, pageToken=None, pageSize=None, x__xgafv=None)</code>
  <pre>Returns a list of course work that the requester is permitted to view. Course students may only view `PUBLISHED` course work. Course teachers and domain administrators may view all course work. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course does not exist.

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  courseWorkStates: string, Restriction on the work status to return. Only courseWork that matches is returned. If unspecified, items with a work status of `PUBLISHED` is returned. (repeated)
    Allowed values
      COURSE_WORK_STATE_UNSPECIFIED - No state specified. This is never returned.
      PUBLISHED - Status for work that has been published. This is the default state.
      DRAFT - Status for work that is not yet published. Work in this state is visible only to course teachers and domain administrators.
      DELETED - Status for work that was published but is now deleted. Work in this state is visible only to course teachers and domain administrators. Work in this state is deleted after some time.
  orderBy: string, Optional sort ordering for results. A comma-separated list of fields with an optional sort direction keyword. Supported fields are `updateTime` and `dueDate`. Supported direction keywords are `asc` and `desc`. If not specified, `updateTime desc` is the default behavior. Examples: `dueDate asc,updateTime desc`, `updateTime,dueDate desc`
  pageToken: string, nextPageToken value returned from a previous list call, indicating that the subsequent page of results should be returned. The list request must be otherwise identical to the one that resulted in this token.
  pageSize: integer, Maximum number of items to return. Zero or unspecified indicates that the server may assign a maximum. The server may return fewer than the specified number of results.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response when listing course work.
    &quot;courseWork&quot;: [ # Course work items that match the request.
      { # Course work created by a teacher for students of the course.
        &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
          &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
            &quot;A String&quot;,
          ],
        },
        &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
        &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
        &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
        &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
        &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
          { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
            &quot;form&quot;: { # Google Forms item. # Google Forms material.
              &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
              &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
              &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
              &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
            },
            &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
              &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
              &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
              &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
            },
            &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
              &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
                &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
                &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
                &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
                &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
              },
              &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
            },
            &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
              &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
              &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
              &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
              &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
            },
          },
        ],
        &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
        &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
        &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
          &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
          &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
          &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
          &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
        },
        &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
          &quot;choices&quot;: [ # Possible choices.
            &quot;A String&quot;,
          ],
        },
        &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
        &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
        &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
        &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
        &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
        &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
          &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
          &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
          &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
        },
        &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
          &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
            &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
            &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
            &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
          },
        },
        &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
        &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
        &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
        &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
        &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
      },
    ],
    &quot;nextPageToken&quot;: &quot;A String&quot;, # Token identifying the next page of results to return. If empty, no further results are available.
  }</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="modifyAssignees">modifyAssignees(courseId, id, body=None, x__xgafv=None)</code>
  <pre>Modifies assignee mode and options of a coursework. Only a teacher of the course that contains the coursework may call this method. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting user is not permitted to access the requested course or course work or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `NOT_FOUND` if the requested course or course work does not exist.

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  id: string, Identifier of the coursework. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request to modify assignee mode and options of a coursework.
    &quot;assigneeMode&quot;: &quot;A String&quot;, # Mode of the coursework describing whether it will be assigned to all students or specified individual students.
    &quot;modifyIndividualStudentsOptions&quot;: { # Contains fields to add or remove students from a course work or announcement where the `assigneeMode` is set to `INDIVIDUAL_STUDENTS`. # Set which students are assigned or not assigned to the coursework. Must be specified only when `assigneeMode` is `INDIVIDUAL_STUDENTS`.
      &quot;removeStudentIds&quot;: [ # IDs of students to be removed from having access to this coursework/announcement.
        &quot;A String&quot;,
      ],
      &quot;addStudentIds&quot;: [ # IDs of students to be added as having access to this coursework/announcement.
        &quot;A String&quot;,
      ],
    },
  }

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Course work created by a teacher for students of the course.
    &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
      &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
        &quot;A String&quot;,
      ],
    },
    &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
    &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
    &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
    &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
    &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
      { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
        &quot;form&quot;: { # Google Forms item. # Google Forms material.
          &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
          &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
        },
        &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
          &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
        },
        &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
          &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
            &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
            &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
            &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
            &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
          },
          &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
        },
        &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
          &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
        },
      },
    ],
    &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
    &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
    &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
      &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
      &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
      &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
      &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
    },
    &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
      &quot;choices&quot;: [ # Possible choices.
        &quot;A String&quot;,
      ],
    },
    &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
    &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
    &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
    &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
    &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
    &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
      &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
      &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
      &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
    },
    &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
      &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
        &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
      },
    },
    &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
    &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
    &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
    &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
    &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
  }</pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(courseId, id, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates one or more fields of a course work. See google.classroom.v1.CourseWork for details of which fields may be updated and who may change them. This request must be made by the Developer Console project of the [OAuth client ID](https://support.google.com/cloud/answer/6158849) used to create the corresponding course work item. This method returns the following error codes: * `PERMISSION_DENIED` if the requesting developer project did not create the corresponding course work, if the user is not permitted to make the requested modification to the student submission, or for access errors. * `INVALID_ARGUMENT` if the request is malformed. * `FAILED_PRECONDITION` if the requested course work has already been deleted. * `NOT_FOUND` if the requested course, course work, or student submission does not exist.

Args:
  courseId: string, Identifier of the course. This identifier can be either the Classroom-assigned identifier or an alias. (required)
  id: string, Identifier of the course work. (required)
  body: object, The request body.
    The object takes the form of:

{ # Course work created by a teacher for students of the course.
  &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
    &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
      &quot;A String&quot;,
    ],
  },
  &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
  &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
  &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
  &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
  &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
    { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
      &quot;form&quot;: { # Google Forms item. # Google Forms material.
        &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
        &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
      },
      &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
        &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
        &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
      },
      &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
        &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
          &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
        },
        &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
      },
      &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
        &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
        &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
        &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
      },
    },
  ],
  &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
  &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
  &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
    &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
    &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
  },
  &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
    &quot;choices&quot;: [ # Possible choices.
      &quot;A String&quot;,
    ],
  },
  &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
  &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
  &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
  &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
  &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
  &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
    &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
    &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
    &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
  },
  &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
    &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
      &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
      &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
      &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
    },
  },
  &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
  &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
  &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
  &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
  &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
}

  updateMask: string, Mask that identifies which fields on the course work to update. This field is required to do an update. The update fails if invalid fields are specified. If a field supports empty values, it can be cleared by specifying it in the update mask and not in the CourseWork object. If a field that does not support empty values is included in the update mask and not set in the CourseWork object, an `INVALID_ARGUMENT` error is returned. The following fields may be specified by teachers: * `title` * `description` * `state` * `due_date` * `due_time` * `max_points` * `scheduled_time` * `submission_modification_mode` * `topic_id`
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Course work created by a teacher for students of the course.
    &quot;individualStudentsOptions&quot;: { # Assignee details about a coursework/announcement. This field is set if and only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. # Identifiers of students with access to the coursework. This field is set only if `assigneeMode` is `INDIVIDUAL_STUDENTS`. If the `assigneeMode` is `INDIVIDUAL_STUDENTS`, then only students specified in this field are assigned the coursework.
      &quot;studentIds&quot;: [ # Identifiers for the students that have access to the coursework/announcement.
        &quot;A String&quot;,
      ],
    },
    &quot;workType&quot;: &quot;A String&quot;, # Type of this course work. The type is set when the course work is created and cannot be changed.
    &quot;submissionModificationMode&quot;: &quot;A String&quot;, # Setting to determine when students are allowed to modify submissions. If unspecified, the default value is `MODIFIABLE_UNTIL_TURNED_IN`.
    &quot;creatorUserId&quot;: &quot;A String&quot;, # Identifier for the user that created the coursework. Read-only.
    &quot;updateTime&quot;: &quot;A String&quot;, # Timestamp of the most recent change to this course work. Read-only.
    &quot;materials&quot;: [ # Additional materials. CourseWork must have no more than 20 material items.
      { # Material attached to course work. When creating attachments, setting the `form` field is not supported.
        &quot;form&quot;: { # Google Forms item. # Google Forms material.
          &quot;formUrl&quot;: &quot;A String&quot;, # URL of the form.
          &quot;title&quot;: &quot;A String&quot;, # Title of the Form. Read-only.
          &quot;responseUrl&quot;: &quot;A String&quot;, # URL of the form responses document. Only set if respsonses have been recorded and only when the requesting user is an editor of the form. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Form. Read-only.
        },
        &quot;link&quot;: { # URL item. # Link material. On creation, this is upgraded to a more appropriate type if possible, and this is reflected in the response.
          &quot;url&quot;: &quot;A String&quot;, # URL to link to. This must be a valid UTF-8 string containing between 1 and 2024 characters.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the target URL. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the target of the URL. Read-only.
        },
        &quot;driveFile&quot;: { # Drive file that is used as material for course work. # Google Drive file material.
          &quot;driveFile&quot;: { # Representation of a Google Drive file. # Drive file details.
            &quot;title&quot;: &quot;A String&quot;, # Title of the Drive item. Read-only.
            &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
            &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive item. Read-only.
            &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the Drive item. Read-only.
          },
          &quot;shareMode&quot;: &quot;A String&quot;, # Mechanism by which students access the Drive item.
        },
        &quot;youtubeVideo&quot;: { # YouTube video item. # YouTube video material.
          &quot;id&quot;: &quot;A String&quot;, # YouTube API resource ID.
          &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to view the YouTube video. Read-only.
          &quot;thumbnailUrl&quot;: &quot;A String&quot;, # URL of a thumbnail image of the YouTube video. Read-only.
          &quot;title&quot;: &quot;A String&quot;, # Title of the YouTube video. Read-only.
        },
      },
    ],
    &quot;description&quot;: &quot;A String&quot;, # Optional description of this course work. If set, the description must be a valid UTF-8 string containing no more than 30,000 characters.
    &quot;creationTime&quot;: &quot;A String&quot;, # Timestamp when this course work was created. Read-only.
    &quot;dueTime&quot;: { # Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`. # Optional time of day, in UTC, that submissions for this course work are due. This must be specified if `due_date` is specified.
      &quot;nanos&quot;: 42, # Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
      &quot;seconds&quot;: 42, # Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
      &quot;hours&quot;: 42, # Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value &quot;24:00:00&quot; for scenarios like business closing time.
      &quot;minutes&quot;: 42, # Minutes of hour of day. Must be from 0 to 59.
    },
    &quot;multipleChoiceQuestion&quot;: { # Additional details for multiple-choice questions. # Multiple choice question details. For read operations, this field is populated only when `work_type` is `MULTIPLE_CHOICE_QUESTION`. For write operations, this field must be specified when creating course work with a `work_type` of `MULTIPLE_CHOICE_QUESTION`, and it must not be set otherwise.
      &quot;choices&quot;: [ # Possible choices.
        &quot;A String&quot;,
      ],
    },
    &quot;id&quot;: &quot;A String&quot;, # Classroom-assigned identifier of this course work, unique per course. Read-only.
    &quot;title&quot;: &quot;A String&quot;, # Title of this course work. The title must be a valid UTF-8 string containing between 1 and 3000 characters.
    &quot;maxPoints&quot;: 3.14, # Maximum grade for this course work. If zero or unspecified, this assignment is considered ungraded. This must be a non-negative integer value.
    &quot;scheduledTime&quot;: &quot;A String&quot;, # Optional timestamp when this course work is scheduled to be published.
    &quot;associatedWithDeveloper&quot;: True or False, # Whether this course work item is associated with the Developer Console project making the request. See CreateCourseWork for more details. Read-only.
    &quot;dueDate&quot;: { # Represents a whole or partial calendar date, e.g. a birthday. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the Proleptic Gregorian Calendar. This can represent: * A full date, with non-zero year, month and day values * A month and day value, with a zero year, e.g. an anniversary * A year on its own, with zero month and day values * A year and month value, with a zero day, e.g. a credit card expiration date Related types are google.type.TimeOfDay and `google.protobuf.Timestamp`. # Optional date, in UTC, that submissions for this course work are due. This must be specified if `due_time` is specified.
      &quot;month&quot;: 42, # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
      &quot;day&quot;: 42, # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a year by itself or a year and month where the day is not significant.
      &quot;year&quot;: 42, # Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
    },
    &quot;assignment&quot;: { # Additional details for assignments. # Assignment details. This is populated only when `work_type` is `ASSIGNMENT`. Read-only.
      &quot;studentWorkFolder&quot;: { # Representation of a Google Drive folder. # Drive folder where attachments from student submissions are placed. This is only populated for course teachers and administrators.
        &quot;id&quot;: &quot;A String&quot;, # Drive API resource ID.
        &quot;title&quot;: &quot;A String&quot;, # Title of the Drive folder. Read-only.
        &quot;alternateLink&quot;: &quot;A String&quot;, # URL that can be used to access the Drive folder. Read-only.
      },
    },
    &quot;courseId&quot;: &quot;A String&quot;, # Identifier of the course. Read-only.
    &quot;alternateLink&quot;: &quot;A String&quot;, # Absolute link to this course work in the Classroom web UI. This is only populated if `state` is `PUBLISHED`. Read-only.
    &quot;state&quot;: &quot;A String&quot;, # Status of this course work. If unspecified, the default state is `DRAFT`.
    &quot;assigneeMode&quot;: &quot;A String&quot;, # Assignee mode of the coursework. If unspecified, the default value is `ALL_STUDENTS`.
    &quot;topicId&quot;: &quot;A String&quot;, # Identifier for the topic that this coursework is associated with. Must match an existing topic in the course.
  }</pre>
</div>

</body></html>