Skip to content

API Reference

CanvasClient

canvasconnector.CanvasClient

Courses

canvasconnector.get_courses_raw(client)

Get courses as a list of dictionaries.

This function retrieves all courses for the authenticated user from the
Canvas API and returns them as raw Python dictionaries with selected fields.

Args:
    client (CanvasClient): The Canvas API client instance.

Returns:
    list[dict]: A list of course dictionaries with the following keys:
        - id (int): Course ID
        - name (str): Course name
        - course_code (str): Course code (e.g., "BUS 301")
        - term_id (int): Term ID
        - term_name (str): Term name (e.g., "Winter 2025")
        - term_start_at (str): Term start date (ISO 8601 format)
        - term_end_at (str): Term end date (ISO 8601 format)
        - enrollment_type (str): Type of enrollment (student, teacher, ta, observer)

Example:

python client = CanvasClient( api_key="your_token", canvas_url="https://byui.instructure.com" ) courses = get_courses_raw(client) print(courses[0]['name']) # "Adv Writing in Pro Contexts"

canvasconnector.get_courses_polars(client, current_only)

Get courses as a Polars DataFrame.

This function retrieves all courses for the authenticated user from the
Canvas API and returns them as a Polars DataFrame for easy analysis.

Args:
    client (CanvasClient): The Canvas API client instance.
    current_only (bool): If True, only return courses from current term.

Returns:
    pl.DataFrame: A Polars DataFrame with course data.

Example:

python client = CanvasClient( api_key="your_token", canvas_url="https://byui.instructure.com" ) courses_df = get_courses_polars(client, current_only=True) print(courses_df.head())

Assignments

canvasconnector.get_assignments(client, course_code, assignment_weights=False)

canvasconnector.get_assignments_all_courses(client, course_list, max_workers=5)

Get assignments for all courses in parallel.

canvasconnector.get_assignment_group(client, course_code)

canvasconnector.get_upcoming_assignments(client, course_ids, days=7, exclude_submitted=True)

Get assignments due within a specified number of days.

Retrieves assignments from the Canvas LMS API that are due within the next days days, with optional filtering to exclude already-submitted assignments.

Parameters:

Name Type Description Default
client CanvasClient

An authenticated CanvasClient instance.

 required
course_ids Series

A Polars Series containing course IDs to fetch assignments from.

 required
days int

Number of days to look ahead for due assignments. Defaults to 7.

 7
exclude_submitted bool

Whether to filter out assignments that have already been submitted. Defaults to True.

 True

Returns:

Type Description

A Polars DataFrame containing upcoming assignments with columns including

due_at, submitted_at, and other assignment metadata.

Examples:

>>> df_courses = get_courses_polars(client, current_only=True)
>>> upcoming = get_assignments_due(client, df_courses['course_id'], days=5)
>>> upcoming_all = get_assignments_due(client, df_courses['course_id'],
...                                    days=14, exclude_submitted=False)

canvasconnector.get_assignment_details(client, course_id, assignment_id, details_only=False)

Submissions

canvasconnector.submit_assignment(client, course_id, assignment_id, body=None, submission_url=None, file_path=None)

Comments

canvasconnector.get_submission_comments(client, course_id, assignment_id)

canvasconnector.post_submission_comment(client, course_id, assignment_id, comment)

Peers

canvasconnector.get_peers(client, course_code) 

Get all users enrolled in a Canvas course as a Polars DataFrame.

This function retrieves all users (students, teachers, TAs, etc.) from a
specified Canvas course, handling pagination automatically to ensure all
users are retrieved.

Args:
    client (CanvasClient): The Canvas API client instance with authentication.
    course_code (int): The Canvas course ID to retrieve users from.

Returns:
    pl.DataFrame: A Polars DataFrame with the following columns:
        - course_id (int): The course ID
        - user_id (int): Unique user identifier
        - user_name (str): Full name of the user
        - user_date (date): Date when the user's Canvas account was created
        - user_type (str): Enrollment type (e.g., 'StudentEnrollment',
          'TeacherEnrollment', 'TaEnrollment')

Raises:
    PermissionError: If you don't have permission to access the course users.
        This typically occurs when you're not enrolled in the course.
    ValueError: If the course ID doesn't exist.
    Exception: For other API-related errors.

Example:

python client = CanvasClient( api_key="your_token", canvas_url="https://byui.instructure.com" ) peers_df = get_peers(client, 396812) print(peers_df)

Note:
    - Each user appears only once in the returned DataFrame, even if they
      have multiple enrollment types in the course.
    - The function automatically handles API pagination to retrieve all users.
    - You can typically only retrieve users from courses you're enrolled in.

canvasconnector.get_all_peers(client, course_list, max_workers=2, unique_per_course=True)

Get peers from multiple courses concurrently.

Parameters:

Name Type Description Default
client CanvasClient

CanvasClient instance

 required
course_list Series

Polars Series containing course IDs

 required
max_workers int

Maximum number of concurrent threads (default: 2)

 2
unique_per_course bool

If True (default), each user appears once per course they're in. If False, each user appears only once total.

 True

Returns:

Type Description

pl.DataFrame: Combined DataFrame of all peers from all courses

canvasconnector.get_best_friends(client, peers_df, top_n=10, students_only=False)

Find the people you share the most classes with.

        This function analyzes peer data to identify which users appear in the
        most courses with you, helping you identify your "best friends" or most
        frequent classmates.

        Args:
            peers_df (pl.DataFrame): DataFrame from get_all_peers() containing peer data.
            client (CanvasClient): Canvas client instance (used to exclude yourself).
            top_n (int): Number of top results to return (default: 10).
            students_only (bool): Whether or not to exclude teachers and TAs from the count.

        Returns:
            pl.DataFrame: A DataFrame with columns:
                - user_name (str): Name of the peer
                - shared_courses (int): Number of courses shared with this person
                Sorted by shared_courses in descending order.

        Example:

python peers_df = get_all_peers(client, course_list) best_friends = get_best_friends(peers_df, client, top_n=5) print(best_friends)

Discussions

canvasconnector.get_discussions(client, course_id)

canvasconnector.get_discussion_entries(client, course_id, discussion_id)

canvasconnector.get_discussion_replies(client, course_id, discussion_id, entry_id)

canvasconnector.get_all_discussion_posts(client, course_id, discussion_id)

canvasconnector.post_discussion_entry(client, course_id, discussion_id, message)

canvasconnector.post_discussion_reply(client, course_id, discussion_id, entry_id, message)

canvasconnector.like_discussion_post(client, course_id, discussion_id, post_id)

Needs course_id, disscussion_id, and post_id. Post_id can be a entry_id or a reply_id. It works the same for either

canvasconnector.like_all_discussion_posts(client, posts, probability=0.25)