Open edX events

edX pydantic models.

`base` ¶

Base event model definitions.

`AbstractBaseEventField (BaseModelWithConfig)` `pydantic-model` ¶

Pydantic model for core event fields.

The base model does not have any attributes as event field does not have common sub-fields.

Source code in ralph/models/edx/base.py

class AbstractBaseEventField(BaseModelWithConfig):
    """Pydantic model for core `event` fields.

    The base model does not have any attributes as event field does not have common
    sub-fields.
    """

`BaseContextField (BaseModelWithConfig)` `pydantic-model` ¶

Pydantic model for core context field.

Attributes:

Name	Type	Description
`course_user_tags`	`Dict of str`	Content from `user_api_usercoursetag` table. Retrieved with: `dict( UserCourseTag.objects.filter( user=request.user.pk, course_id=course_key ).values_list('key', 'value') )` Note: Is only present when a course page is requested. Is an empty dictionary when the user is not logged in or not found in the `user_api_usercoursetag` table.
`user_id`	`int or str or None`	Consists of the ID of the authenticated user. Retrieved with: `request.user.pk` querying the `auth_user` table. Note: Is an integer when the user is found in the `auth_user` table. Is an empty string when an exception is raised while retrieving the ID. Is `None` when the user is not logged in.
`org_id`	`str`	Consists of the organization name that lists the course. Retrieved with: `course_id.org` where `course_id` is an `opaque_keys.edx.locator.CourseLocator` which is created using the URL of the requested page. Note: Is an empty string when the requested page is not a course page.
`course_id`	`str`	Consists of the unique identifier for the visited course page. Retrieved with: `course_id.to_deprecated_string()` where `course_id` is an `opaque_keys.edx.locator.CourseLocator` which is created using the URL of the requested page. Note: Is an empty string when the requested page is not a course page.
`path`	`Path`	Consist of the relative URL (without the hostname) of the requested page. Retrieved with: `request.META['PATH_INFO']`

Source code in ralph/models/edx/base.py

class BaseContextField(BaseModelWithConfig):
    """Pydantic model for core `context` field.

    Attributes:
        course_user_tags (Dict of str): Content from `user_api_usercoursetag` table.
            Retrieved with:
                `dict(
                    UserCourseTag.objects.filter(
                        user=request.user.pk, course_id=course_key
                    ).values_list('key', 'value')
                )`
            Note:
                Is only present when a course page is requested.
                Is an empty dictionary when the user is not logged in or not found in
                the `user_api_usercoursetag` table.
        user_id (int or str or None): Consists of the ID of the authenticated user.
            Retrieved with:
                `request.user.pk` querying the `auth_user` table.
            Note:
                Is an integer when the user is found in the `auth_user` table.
                Is an empty string when an exception is raised while retrieving the ID.
                Is `None` when the user is not logged in.
        org_id (str): Consists of the organization name that lists the course.
            Retrieved with:
                `course_id.org` where `course_id` is an
                `opaque_keys.edx.locator.CourseLocator` which is created using the URL
                of the requested page.
            Note:
                Is an empty string when the requested page is not a course page.
        course_id (str): Consists of the unique identifier for the visited course page.
            Retrieved with:
                `course_id.to_deprecated_string()` where `course_id` is an
                `opaque_keys.edx.locator.CourseLocator` which is created using the URL
                of the requested page.
            Note:
                Is an empty string when the requested page is not a course page.
        path (Path): Consist of the relative URL (without the hostname) of the
            requested page.
            Retrieved with:
                `request.META['PATH_INFO']`
    """

    course_id: constr(regex=r"^$|^course-v1:.+\+.+\+.+$")  # noqa:F722
    course_user_tags: Optional[Dict[str, str]]
    module: Optional[ContextModuleField]
    org_id: str
    path: Path
    user_id: Union[int, Literal[""], None]

`BaseEdxModel (BaseModelWithConfig)` `pydantic-model` ¶

Pydantic model for core statement.

WARNING: it does not define the event, event_type and event_source fields.

Attributes:

Name	Type	Description
`username`	`str`	Consists of the unique username identifying the logged in user. Retrieved with: `request.user.username` querying the `auth_user` table. Note: Is an empty string when the user is not logged in. If an exception is raised when retrieving the username from the table then the value is `anonymous`. Usernames are made of 2-30 ASCII letters / numbers / underscores (_) / hyphens (-)
`ip`	`IPv4Address or str`	Consists of the public IPv4 address of the user. Retrieved with: `get_ip(request)` cf. https://github.com/un33k/django-ipware/tree/1.1.0 Note: Can be an empty string if the IP address is not found.
`agent`	`str`	Consists of the `User-Agent` HTTP request header. Retrieved with: `request.META[HTTP_USER_AGENT]` Note: Can be an empty string if the header is not present in the request. Contains information about: Browser name and version Operating system name and version Default language
`host`	`str`	Consists of the hostname of the server. Retrieved with: `request.META[SERVER_NAME]`
`referer`	`Path`	Consists of the `Referer` HTTP request header. Retrieved with: `request.META[HTTP_REFERER]` Note: Can be an empty string if the header is not present in the request. Contains the referring URL (previous URL visited by the user).
`accept_language`	`str`	Consists of the `Accept-Language` HTTP request header. Retrieved with: `request.META[HTTP_ACCEPT_LANGUAGE]` Note: Can be an empty string if the header is not present in the request. Contains the default language settings of the user.
`context`	`BaseContextField`	see BaseContextField.
`time`	`datetime`	Consists of the UTC time in ISO format at which the event was emitted. Retrieved with: `datetime.datetime.utcnow()`
`page`	`None`	Consists of the value `None` Note: In JSON the value is `null` instead of `None`.

Source code in ralph/models/edx/base.py

class BaseEdxModel(BaseModelWithConfig):
    """Pydantic model for core statement.

    WARNING: it does not define the `event`, `event_type` and `event_source` fields.

    Attributes:
        username (str): Consists of the unique username identifying the logged in user.
            Retrieved with:
                `request.user.username` querying the `auth_user` table.
            Note:
                Is an empty string when the user is not logged in.
                If an exception is raised when retrieving the username from the table
                then the value is `anonymous`.
                Usernames are made of 2-30 ASCII letters / numbers / underscores (_) /
                hyphens (-)
        ip (IPv4Address or str): Consists of the public IPv4 address of the user.
            Retrieved with:
                `get_ip(request)` cf. https://github.com/un33k/django-ipware/tree/1.1.0
            Note:
                Can be an empty string if the IP address is not found.
        agent (str): Consists of the `User-Agent` HTTP request header.
            Retrieved with:
                `request.META[HTTP_USER_AGENT]`
            Note:
                Can be an empty string if the header is not present in the request.
                Contains information about:
                    Browser name and version
                    Operating system name and version
                    Default language
        host (str): Consists of the hostname of the server.
            Retrieved with:
                `request.META[SERVER_NAME]`
        referer (Path): Consists of the `Referer` HTTP request header.
            Retrieved with:
                `request.META[HTTP_REFERER]`
            Note:
                Can be an empty string if the header is not present in the request.
                Contains the referring URL (previous URL visited by the user).
        accept_language (str): Consists of the `Accept-Language` HTTP request header.
            Retrieved with:
                `request.META[HTTP_ACCEPT_LANGUAGE]`
            Note:
                Can be an empty string if the header is not present in the request.
                Contains the default language settings of the user.
        context (BaseContextField): see BaseContextField.
        time (datetime): Consists of the UTC time in ISO format at which the event was
            emitted.
            Retrieved with:
                `datetime.datetime.utcnow()`
        page (None): Consists of the value `None`
            Note:
                In JSON the value is `null` instead of `None`.
    """

    username: Union[constr(min_length=2, max_length=30), Literal[""]]
    ip: Union[IPv4Address, Literal[""]]
    agent: str
    host: str
    referer: Union[AnyHttpUrl, Literal[""]]
    accept_language: str
    context: BaseContextField
    time: datetime
    page: None

`BaseModelWithConfig (BaseModel)` `pydantic-model` ¶

Pydantic model for base configuration shared among all models.

Source code in ralph/models/edx/base.py

class BaseModelWithConfig(BaseModel):
    """Pydantic model for base configuration shared among all models."""

    class Config:  # pylint: disable=missing-class-docstring # noqa: D106
        extra = "forbid"

`ContextModuleField (BaseModelWithConfig)` `pydantic-model` ¶

Pydantic model for context.module field.

Attributes:

Name	Type	Description
`usage_key`	`str`	Consists of a block ID of the current component.
`display_name`	`str`	Consists of a short description or title of the component.

Source code in ralph/models/edx/base.py

class ContextModuleField(BaseModelWithConfig):
    """Pydantic model for `context`.`module` field.

    Attributes:
        usage_key (str): Consists of a block ID of the current component.
        display_name (str): Consists of a short description or title of the component.
    """

    usage_key: constr(regex=r"^block-v1:.+\+.+\+.+type@.+@[a-f0-9]{32}$")  # noqa:F722
    display_name: str
    original_usage_key: Optional[
        constr(
            regex=r"^block-v1:.+\+.+\+.+type@problem\+block@[a-f0-9]{32}$"  # noqa:F722
        )
    ]
    original_usage_version: Optional[str]

`browser` ¶

Browser event model definitions.

`BaseBrowserModel (BaseEdxModel)` `pydantic-model` ¶

Pydantic model for core browser statements.

This type of event is triggered on (XHR) POST/GET requests to the /event URL.

Attributes:

Name	Type	Description
`event_source`	`str`	Consists of the value `browser`.
`page`	`AnyUrl`	Consists of the URL (with hostname) of the visited page. Retrieved with: `window.location.href` from the JavaScript front-end.
`session`	`str`	Consists of the md5 encrypted Django session key or an empty string.

Source code in ralph/models/edx/browser.py

class BaseBrowserModel(BaseEdxModel):
    """Pydantic model for core browser statements.

    This type of event is triggered on (XHR) POST/GET requests to the `/event` URL.

    Attributes:
        event_source (str): Consists of the value `browser`.
        page (AnyUrl): Consists of the URL (with hostname) of the visited page.
            Retrieved with:
                `window.location.href` from the JavaScript front-end.
        session (str): Consists of the md5 encrypted Django session key or an empty
            string.
    """

    event_source: Literal["browser"]
    page: AnyUrl
    session: Union[constr(regex=r"^[a-f0-9]{32}$"), Literal[""]]  # noqa: F722

`converters` `special` ¶

`xapi` `special` ¶

edX to xAPI conversion sets.

`base` ¶

Base xAPI Converter.

`BaseXapiConverter (BaseConversionSet)` ¶

Base xAPI Converter.

WARNING: The converter may not include the following edX fields: - context.org_id: When org_id is an empty string. - context.course_id: When course_id is an empty string.

WARNING: The converter should not include the following edX fields as they may contain sensitive data: username, referer, event, event_source, ip, agent, accept_language:, context.course_user_tags.

Source code in ralph/models/edx/converters/xapi/base.py

class BaseXapiConverter(BaseConversionSet):
    """Base xAPI Converter.

    WARNING: The converter may not include the following edX fields:
    - context.org_id: When `org_id` is an empty string.
    - context.course_id: When `course_id` is an empty string.

    WARNING: The converter should not include the following edX fields as they may
    contain sensitive data: `username`, `referer`, `event`, `event_source`, `ip`,
    `agent`, `accept_language:`, `context.course_user_tags`.
    """

    def __init__(self, uuid_namespace: str, platform_url: str):
        """Initializes BaseXapiConverter."""
        self.platform_url = platform_url
        try:
            self.uuid_namespace = UUID(uuid_namespace)
        except (TypeError, ValueError, AttributeError) as err:
            raise ConfigurationException("Invalid UUID namespace") from err
        super().__init__()

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        return {
            ConversionItem(
                "id",
                None,
                lambda event_str: str(uuid5(self.uuid_namespace, event_str)),
                True,
            ),
            ConversionItem(
                "actor__account__homePage", transformers=lambda _: self.platform_url
            ),
            ConversionItem(
                "actor__account__name",
                "context__user_id",
                lambda user_id: str(user_id) if user_id else "anonymous",
            ),
            ConversionItem(
                "object__definition__extensions__" + CONTEXT_EXTENSION_SCHOOL_ID,
                "context__org_id",
            ),
            ConversionItem(
                "object__definition__extensions__" + CONTEXT_EXTENSION_COURSE_ID,
                "context__course_id",
                (self.parse_course_id, lambda x: x["course"]),
            ),
            ConversionItem(
                "object__definition__extensions__" + CONTEXT_EXTENSION_MODULE_ID,
                "context__course_id",
                (self.parse_course_id, lambda x: x["module"]),
            ),
            ConversionItem("timestamp", "time"),
        }

    @staticmethod
    def parse_course_id(course_id: str):
        """Parses edX event's `context`.`course_id`.

        Returns a dictionary with `course` and `module`.
        """
        match = re.match(r"^course-v1:.+\+(.+)\+(.+)$", course_id)
        if not match:
            return {"course": None, "module": None}
        return {"course": match.group(1), "module": match.group(2)}

`init(self, uuid_namespace, platform_url)` `special` ¶

Initializes BaseXapiConverter.

Source code in ralph/models/edx/converters/xapi/base.py

def __init__(self, uuid_namespace: str, platform_url: str):
    """Initializes BaseXapiConverter."""
    self.platform_url = platform_url
    try:
        self.uuid_namespace = UUID(uuid_namespace)
    except (TypeError, ValueError, AttributeError) as err:
        raise ConfigurationException("Invalid UUID namespace") from err
    super().__init__()

`parse_course_id(course_id)` `staticmethod` ¶

Parses edX event’s context.course_id.

Returns a dictionary with course and module.

Source code in ralph/models/edx/converters/xapi/base.py

@staticmethod
def parse_course_id(course_id: str):
    """Parses edX event's `context`.`course_id`.

    Returns a dictionary with `course` and `module`.
    """
    match = re.match(r"^course-v1:.+\+(.+)\+(.+)$", course_id)
    if not match:
        return {"course": None, "module": None}
    return {"course": match.group(1), "module": match.group(2)}

`navigational` ¶

Navigational event xAPI Converter.

`UIPageCloseToPageTerminated (BaseXapiConverter)` ¶

Converts a common edX page_close event to xAPI.

Example Statement: John terminated https://www.fun-mooc.fr/ page.

WARNING: The converter does not use the self.platform_url in the object__id because the platform_url is present in the edX’s event page field.

Source code in ralph/models/edx/converters/xapi/navigational.py

class UIPageCloseToPageTerminated(BaseXapiConverter):
    """Converts a common edX `page_close` event to xAPI.

    Example Statement: John terminated https://www.fun-mooc.fr/ page.

    WARNING: The converter does not use the `self.platform_url` in the `object__id`
    because the `platform_url` is present in the edX's event `page` field.
    """

    __src__ = UIPageClose
    __dest__ = PageTerminated

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union({ConversionItem("object__id", "page")})

`dest (BaseXapiStatement)` `pydantic-model` ¶

Pydantic model for page terminated statement.

Example: John terminated the https://www.fun-mooc.fr/ page.

Attributes:

Name	Type	Description
`object`	`dict`	See PageActivity.
`verb`	`dict`	See TerminatedVerb.

Source code in ralph/models/edx/converters/xapi/navigational.py

class PageTerminated(BaseXapiStatement):
    """Pydantic model for page terminated statement.

    Example: John terminated the https://www.fun-mooc.fr/ page.

    Attributes:
       object (dict): See PageActivity.
       verb (dict): See TerminatedVerb.
    """

    __selector__ = selector(
        object__definition__type="http://activitystrea.ms/schema/1.0/page",
        verb__id="http://adlnet.gov/expapi/verbs/terminated",
    )

    object: PageActivity
    verb: TerminatedVerb = TerminatedVerb()

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for page_close statement.

The browser emits this statement when the user navigates to the next page or closes the browser window (when the JavaScript window.onunload event is called).

Attributes:

Name	Type	Description
`event`	`str`	Consists of the string value `{}`.
`event_type`	`str`	Consists of the value `page_close`.
`name`	`str`	Consists of the value `page_close`.

Source code in ralph/models/edx/converters/xapi/navigational.py

class UIPageClose(BaseBrowserModel):
    """Pydantic model for `page_close` statement.

    The browser emits this statement when the user navigates to the next page
    or closes the browser window (when the JavaScript `window.onunload` event
    is called).

    Attributes:
        event (str): Consists of the string value `{}`.
        event_type (str): Consists of the value `page_close`.
        name (str): Consists of the value `page_close`.
    """

    __selector__ = selector(event_source="browser", event_type="page_close")

    # pylint: disable=unsubscriptable-object
    event: Literal["{}"]
    event_type: Literal["page_close"]
    name: Literal["page_close"]

`server` ¶

Server event xAPI Converter.

`ServerEventToPageViewed (BaseXapiConverter)` ¶

Converts a common edX server event to xAPI.

Example Statement: John viewed https://www.fun-mooc.fr/ page.

Source code in ralph/models/edx/converters/xapi/server.py

class ServerEventToPageViewed(BaseXapiConverter):
    """Converts a common edX server event to xAPI.

    Example Statement: John viewed https://www.fun-mooc.fr/ page.
    """

    __src__ = Server
    __dest__ = PageViewed

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "object__id",
                    "event_type",
                    lambda event_type: self.platform_url + event_type,
                ),
            }
        )

`dest (BaseXapiStatement)` `pydantic-model` ¶

Pydantic model for page viewed statement.

Example: John viewed the https://www.fun-mooc.fr/ page.

Attributes:

Name	Type	Description
`object`	`dict`	See PageActivity.
`verb`	`dict`	See ViewedVerb.

Source code in ralph/models/edx/converters/xapi/server.py

class PageViewed(BaseXapiStatement):
    """Pydantic model for page viewed statement.

    Example: John viewed the https://www.fun-mooc.fr/ page.

    Attributes:
       object (dict): See PageActivity.
       verb (dict): See ViewedVerb.
    """

    __selector__ = selector(
        object__definition__type="http://activitystrea.ms/schema/1.0/page",
        verb__id="http://id.tincanapi.com/verb/viewed",
    )

    object: PageActivity
    verb: ViewedVerb = ViewedVerb()

`src (BaseServerModel)` `pydantic-model` ¶

Pydantic model for common server statement.

This type of event is triggered from the django middleware on each request excluding: /event, login, heartbeat, /segmentio/event and /performance.

Attributes:

Name	Type	Description
`event_type`	`str`	Consist of the relative URL (without the hostname) of the requested page. Retrieved with: `request.META['PATH_INFO']`
`event`	`str`	Consist of a JSON string holding the content of the GET or POST request. Retrieved with: `json.dumps( { 'GET': dict(request.GET), 'POST': dict(request.POST) } )[:512]` Note: Values for [‘password’, ‘newpassword’, ‘new_password’, ‘oldpassword’, ‘old_password’, ‘new_password1’, ‘new_password2’] are replaced by `********`. The JSON string is truncated at 512 characters resulting in invalid JSON.

Source code in ralph/models/edx/converters/xapi/server.py

class Server(BaseServerModel):
    """Pydantic model for common server statement.

    This type of event is triggered from the django middleware on each request
    excluding: `/event`, `login`, `heartbeat`, `/segmentio/event` and `/performance`.

    Attributes:
        event_type (str): Consist of the relative URL (without the hostname) of the
            requested page.
            Retrieved with:
                `request.META['PATH_INFO']`
        event (str): Consist of a JSON string holding the content of the GET or POST
            request.
            Retrieved with:
                ```json.dumps(
                    {
                        'GET': dict(request.GET),
                        'POST': dict(request.POST)
                    }
                )[:512]```
            Note:
                Values for ['password', 'newpassword', 'new_password', 'oldpassword',
                'old_password', 'new_password1', 'new_password2'] are replaced by
                `********`.
                The JSON string is truncated at 512 characters resulting in invalid
                JSON.
    """

    __selector__ = selector(
        event_source="server", event_type=LazyModelField("context__path")
    )

    # pylint: disable=unsubscriptable-object
    event_type: Path
    event: Union[Json[ServerEventField], ServerEventField]

`video` ¶

Video event xAPI Converter.

`UILoadVideoToVideoInitialized (VideoBaseXapiConverter)` ¶

Converts a common edX load_video event to xAPI.

Source code in ralph/models/edx/converters/xapi/video.py

class UILoadVideoToVideoInitialized(VideoBaseXapiConverter):
    """Converts a common edX `load_video` event to xAPI."""

    __src__ = UILoadVideo
    __dest__ = VideoInitialized

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_LENGTH,
                    None,
                    # Set the video length to null by default.
                    # This information is mandatory in the xAPI template
                    # and does not exist in the edX `load_video` event model.
                    lambda _: 0.0,
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_USER_AGENT, "agent"
                ),
            },
        )

`dest (BaseVideoStatement)` `pydantic-model` ¶

Pydantic model for video initialized statement.

Example: A video has been fully initialized.

Attributes:

Name	Type	Description
`verb`	`dict`	See InitializedVerb.
`context`	`dict`	See VideoInitializedContext.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoInitialized(BaseVideoStatement):
    """Pydantic model for video initialized statement.

    Example: A video has been fully initialized.

    Attributes:
        verb (dict): See InitializedVerb.
        context (dict): See VideoInitializedContext.
    """

    __selector__ = selector(
        object__definition__type="https://w3id.org/xapi/video/activity-type/video",
        verb__id="http://adlnet.gov/expapi/verbs/initialized",
    )

    verb: InitializedVerb = InitializedVerb()
    context: VideoInitializedContext

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for load_video statement.

The browser emits this statement when the video is fully rendered and ready to play.

Attributes:

Name	Type	Description
`event`	`VideoBaseEventField`	See VideoBaseEventField.
`event_type`	`str`	Consists of the value `load_video`.
`name`	`str`	Consists either of the value `load_video` or `edx.video.loaded`.

Source code in ralph/models/edx/converters/xapi/video.py

class UILoadVideo(BaseBrowserModel):
    """Pydantic model for `load_video` statement.

    The browser emits this statement when the video is fully rendered and ready to
    play.

    Attributes:
        event (VideoBaseEventField): See VideoBaseEventField.
        event_type (str): Consists of the value `load_video`.
        name (str): Consists either of the value `load_video` or `edx.video.loaded`.
    """

    __selector__ = selector(event_source="browser", event_type="load_video")

    event: Union[
        Json[VideoBaseEventField],  # pylint: disable=unsubscriptable-object
        VideoBaseEventField,
    ]
    event_type: Literal["load_video"]
    name: Literal["load_video", "edx.video.loaded"]

`UIPauseVideoToVideoPaused (VideoBaseXapiConverter)` ¶

Converts a common edX pause_video event to xAPI.

Source code in ralph/models/edx/converters/xapi/video.py

class UIPauseVideoToVideoPaused(VideoBaseXapiConverter):
    """Converts a common edX `pause_video` event to xAPI."""

    __src__ = UIPauseVideo
    __dest__ = VideoPaused

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_TIME,
                    "event__currentTime",
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_LENGTH,
                    None,
                    # Set the video length to null by default.
                    # This information is mandatory in the xAPI template
                    # and does not exist in the edX `pause_video` event model.
                    lambda _: 0.0,
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
            },
        )

`dest (BaseVideoStatement)` `pydantic-model` ¶

Pydantic model for video paused statement.

Example: John paused the video or clicked the pause button.

Attributes:

Name	Type	Description
`verb`	`dict`	See PausedVerb.
`result`	`dict`	See VideoPausedResult.
`context`	`dict`	See VideoPausedContext.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoPaused(BaseVideoStatement):
    """Pydantic model for video paused statement.

    Example: John paused the video or clicked the pause button.

    Attributes:
        verb (dict): See PausedVerb.
        result (dict): See VideoPausedResult.
        context (dict): See VideoPausedContext.
    """

    __selector__ = selector(
        object__definition__type="https://w3id.org/xapi/video/activity-type/video",
        verb__id="https://w3id.org/xapi/video/verbs/paused",
    )

    verb: PausedVerb = PausedVerb()
    result: VideoPausedResult
    context: VideoPausedContext

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for pause_video statement.

The browser emits this statement when a user selects the video player’s pause control.

Attributes:

Name	Type	Description
`event`	`PauseVideoEventField`	See PauseVideoEventField.
`event_type`	`str`	Consists of the value `pause_video`.
`name`	`str`	Consists either of the value `pause_video` or `edx.video.paused`.

Source code in ralph/models/edx/converters/xapi/video.py

class UIPauseVideo(BaseBrowserModel):
    """Pydantic model for `pause_video` statement.

    The browser emits this statement when a user selects the video player's pause
    control.

    Attributes:
        event (PauseVideoEventField): See PauseVideoEventField.
        event_type (str): Consists of the value `pause_video`.
        name (str): Consists either of the value `pause_video` or `edx.video.paused`.
    """

    __selector__ = selector(event_source="browser", event_type="pause_video")

    event: Union[
        Json[PauseVideoEventField],  # pylint: disable=unsubscriptable-object
        PauseVideoEventField,
    ]
    event_type: Literal["pause_video"]
    name: Optional[Literal["pause_video", "edx.video.paused"]]

`UIPlayVideoToVideoPlayed (VideoBaseXapiConverter)` ¶

Converts a common edX play_video event to xAPI.

Source code in ralph/models/edx/converters/xapi/video.py

class UIPlayVideoToVideoPlayed(VideoBaseXapiConverter):
    """Converts a common edX `play_video` event to xAPI."""

    __src__ = UIPlayVideo
    __dest__ = VideoPlayed

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_TIME,
                    "event__currentTime",
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
            },
        )

`dest (BaseVideoStatement)` `pydantic-model` ¶

Pydantic model for video played statement.

Example: John played the video or clicked the play button.

Attributes:

Name	Type	Description
`verb`	`dict`	See PlayedVerb.
`result`	`dict`	See VideoPlayedResult.
`context`	`dict`	See VideoPlayedContext.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoPlayed(BaseVideoStatement):
    """Pydantic model for video played statement.

    Example: John played the video or clicked the play button.

    Attributes:
        verb (dict): See PlayedVerb.
        result (dict): See VideoPlayedResult.
        context (dict): See VideoPlayedContext.
    """

    __selector__ = selector(
        object__definition__type="https://w3id.org/xapi/video/activity-type/video",
        verb__id="https://w3id.org/xapi/video/verbs/played",
    )

    verb: PlayedVerb = PlayedVerb()
    result: VideoPlayedResult
    context: Optional[VideoPlayedContext]

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for play_video statement.

The browser emits this statement when a user selects the video player’s play control.

Attributes:

Name	Type	Description
`event`	`PlayVideoEventField`	See PlayVideoEventField.
`event_type`	`str`	Consists of the value `play_video`.
`name`	`str`	Consists either of the value `play_video` or `edx.video.played`.

Source code in ralph/models/edx/converters/xapi/video.py

class UIPlayVideo(BaseBrowserModel):
    """Pydantic model for `play_video` statement.

    The browser emits this statement when a user selects the video player's play
    control.

    Attributes:
        event (PlayVideoEventField): See PlayVideoEventField.
        event_type (str): Consists of the value `play_video`.
        name (str): Consists either of the value `play_video` or `edx.video.played`.
    """

    __selector__ = selector(event_source="browser", event_type="play_video")

    event: Union[
        Json[PlayVideoEventField],  # pylint: disable=unsubscriptable-object
        PlayVideoEventField,
    ]
    event_type: Literal["play_video"]
    name: Optional[Literal["play_video", "edx.video.played"]]

`UISeekVideoToVideoSeeked (VideoBaseXapiConverter)` ¶

Converts a common edX seek_video event to xAPI.

Source code in ralph/models/edx/converters/xapi/video.py

class UISeekVideoToVideoSeeked(VideoBaseXapiConverter):
    """Converts a common edX `seek_video` event to xAPI."""

    __src__ = UISeekVideo
    __dest__ = VideoSeeked

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_TIME_FROM,
                    "event__old_time",
                ),
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_TIME_TO,
                    "event__new_time",
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
            },
        )

`dest (BaseVideoStatement)` `pydantic-model` ¶

Pydantic model for video seeked statement.

!!! example “John moved the progress bar forward or backward to a specific time in the” video.

Attributes:

Name	Type	Description
`verb`	`dict`	See SeekedVerb.
`result`	`dict`	See VideoSeekedResult.
`context`	`dict`	See VideoSeekedContext.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoSeeked(BaseVideoStatement):
    """Pydantic model for video seeked statement.

    Example: John moved the progress bar forward or backward to a specific time in the
        video.

    Attributes:
        verb (dict): See SeekedVerb.
        result (dict): See VideoSeekedResult.
        context (dict): See VideoSeekedContext.
    """

    __selector__ = selector(
        object__definition__type="https://w3id.org/xapi/video/activity-type/video",
        verb__id="https://w3id.org/xapi/video/verbs/seeked",
    )

    verb: SeekedVerb = SeekedVerb()
    result: VideoSeekedResult
    context: Optional[VideoSeekedContext]

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for seek_video statement.

The browser emits this statement when a user selects a user interface control to go to a different point in the video file.

Attributes:

Name	Type	Description
`event`	`SeekVideoEventField`	See SeekVideoEventField.
`event_type`	`str`	Consists of the value `seek_video`.
`name`	`str`	Consists either of the value `seek_video` or `edx.video.position.changed`.

Source code in ralph/models/edx/converters/xapi/video.py

class UISeekVideo(BaseBrowserModel):
    """Pydantic model for `seek_video` statement.

    The browser emits this statement when a user selects a user interface control to go
    to a different point in the video file.

    Attributes:
        event (SeekVideoEventField): See SeekVideoEventField.
        event_type (str): Consists of the value `seek_video`.
        name (str): Consists either of the value `seek_video` or
            `edx.video.position.changed`.
    """

    __selector__ = selector(event_source="browser", event_type="seek_video")

    event: Union[
        Json[SeekVideoEventField],  # pylint: disable=unsubscriptable-object
        SeekVideoEventField,
    ]
    event_type: Literal["seek_video"]
    name: Optional[Literal["seek_video", "edx.video.position.changed"]]

`UIStopVideoToVideoTerminated (VideoBaseXapiConverter)` ¶

Converts a common edX stop_video event to xAPI.

Source code in ralph/models/edx/converters/xapi/video.py

class UIStopVideoToVideoTerminated(VideoBaseXapiConverter):
    """Converts a common edX `stop_video` event to xAPI."""

    __src__ = UIStopVideo
    __dest__ = VideoTerminated

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_TIME,
                    "event__currentTime",
                ),
                ConversionItem(
                    "result__extensions__" + RESULT_EXTENSION_PROGRESS,
                    None,
                    # Set the video progress to null by default.
                    # This information is mandatory in the xAPI template
                    # and does not exist in the edX `stop_video` event model.
                    lambda _: 0.0,
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_LENGTH,
                    None,
                    # Set the video length to null by default.
                    # This information is mandatory in the xAPI template
                    # and does not exist in the edX `stop_video` event model.
                    lambda _: 0.0,
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
            },
        )

`dest (BaseVideoStatement)` `pydantic-model` ¶

Pydantic model for video terminated statement.

Example: John ended a video (quit the player).

Attributes:

Name	Type	Description
`verb`	`dict`	See TerminatedVerb.
`result`	`dict`	See VideoTerminatedResult.
`context`	`dict`	See VideoTerminatedContext.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoTerminated(BaseVideoStatement):
    """Pydantic model for video terminated statement.

    Example: John ended a video (quit the player).

    Attributes:
        verb (dict): See TerminatedVerb.
        result (dict): See VideoTerminatedResult.
        context (dict): See VideoTerminatedContext.
    """

    __selector__ = selector(
        object__definition__type="https://w3id.org/xapi/video/activity-type/video",
        verb__id="http://adlnet.gov/expapi/verbs/terminated",
    )

    verb: TerminatedVerb = TerminatedVerb()
    result: VideoTerminatedResult
    context: VideoTerminatedContext

`src (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for stop_video statement.

The browser emits this statement when the video player reaches the end of the video file and play automatically stops.

Attributes:

Name	Type	Description
`event`	`StopVideoEventField`	See StopVideoEventField.
`event_type`	`str`	Consists of the value `stop_video`.
`name`	`str`	Consists either of the value `stop_video` or `edx.video.stopped`.

Source code in ralph/models/edx/converters/xapi/video.py

class UIStopVideo(BaseBrowserModel):
    """Pydantic model for `stop_video` statement.

    The browser emits this statement when the video player reaches the end of the video
    file and play automatically stops.

    Attributes:
        event (StopVideoEventField): See StopVideoEventField.
        event_type (str): Consists of the value `stop_video`.
        name (str): Consists either of the value `stop_video` or `edx.video.stopped`.
    """

    __selector__ = selector(event_source="browser", event_type="stop_video")

    event: Union[
        Json[StopVideoEventField],  # pylint: disable=unsubscriptable-object
        StopVideoEventField,
    ]
    event_type: Literal["stop_video"]
    name: Optional[Literal["stop_video", "edx.video.stopped"]]

`VideoBaseXapiConverter (BaseXapiConverter)` ¶

Base Video xAPI Converter.

Source code in ralph/models/edx/converters/xapi/video.py

class VideoBaseXapiConverter(BaseXapiConverter):
    """Base Video xAPI Converter."""

    def _get_conversion_items(self):
        """Returns a set of ConversionItems used for conversion."""
        conversion_items = super()._get_conversion_items()
        return conversion_items.union(
            {
                ConversionItem(
                    "object__definition__name",
                    "event__id",
                    lambda id: {LANG_EN_US_DISPLAY: id},
                ),
                ConversionItem(
                    "object__id",
                    None,
                    lambda event: self.platform_url
                    + "/xblock/block-v1:"
                    + event["context"]["course_id"]
                    + "-course-v1:+type@video+block@"
                    + event["event"]["id"],
                ),
                ConversionItem(
                    "context__extensions__" + CONTEXT_EXTENSION_SESSION_ID,
                    "session",
                ),
            },
        )

`enrollment` `special` ¶

`fields` `special` ¶

`contexts` ¶

Enrollment event models context fields definitions.

`EdxCourseEnrollmentUpgradeClickedContextField (BaseContextField)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.upgrade_clicked.context field.

In addition to the common context member fields, this statement also comprises the mode context member field.

Attributes:

Name	Type	Description
`mode`	`str`	Consists of either the `audit` or `honor` value. It identifies the enrollment mode when the user clicked `Challenge Yourself`.

Source code in ralph/models/edx/enrollment/fields/contexts.py

class EdxCourseEnrollmentUpgradeClickedContextField(BaseContextField):
    """Pydantic model for `edx.course.enrollment.upgrade_clicked`.`context` field.

    In addition to the common context member fields, this statement also comprises the
    `mode` context member field.

    Attributes:
        mode (str): Consists of either the `audit` or `honor` value. It identifies the
            enrollment mode when the user clicked <kbd>Challenge Yourself</kbd>.
    """

    mode: Union[Literal["audit"], Literal["honor"]]

`EdxCourseEnrollmentUpgradeSucceededContextField (BaseContextField)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.upgrade.succeeded.context field.

In addition to the common context member fields, this statement also comprises the mode context member field.

Attributes:

Name	Type	Description
`mode`	`str`	Consists of the `verified` value.

Source code in ralph/models/edx/enrollment/fields/contexts.py

class EdxCourseEnrollmentUpgradeSucceededContextField(BaseContextField):
    """Pydantic model for `edx.course.enrollment.upgrade.succeeded`.`context` field.

    In addition to the common context member fields, this statement also comprises the
    `mode` context member field.

    Attributes:
        mode (str): Consists of the `verified` value.
    """

    mode: Literal["verified"]

`events` ¶

Enrollment models event field definition.

`EnrollmentEventField (AbstractBaseEventField)` `pydantic-model` ¶

Pydantic model for enrollment event field.

Note: Only server enrollment statements require an event field.

Attributes:

Name	Type	Description
`course_id`	`str`	Consists in the course in which the student was enrolled or unenrolled.
`mode`	`str`	Takes either `audit`, `honor`, `professional` or `verified` value. It identifies the student’s enrollment mode.
`user_id`	`int`	Identifies the student who was enrolled or unenrolled.

Source code in ralph/models/edx/enrollment/fields/events.py

class EnrollmentEventField(AbstractBaseEventField):
    """Pydantic model for enrollment `event` field.

    Note: Only server enrollment statements require an `event` field.

    Attributes:
        course_id (str): Consists in the course in which the student was enrolled or
            unenrolled.
        mode (str): Takes either `audit`, `honor`, `professional` or `verified` value.
            It identifies the student’s enrollment mode.
        user_id (int): Identifies the student who was enrolled or unenrolled.
    """

    course_id: str
    mode: Union[
        Literal["audit"], Literal["honor"], Literal["professional"], Literal["verified"]
    ]
    user_id: Union[int, Literal[""], None]

`statements` ¶

Enrollment event model definitions.

`EdxCourseEnrollmentActivated (BaseServerModel)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.activated statement.

The server emits this statement when a student enrolls in a course.

Attributes:

Name	Type	Description
`event`	`EnrollmentEventField`	See EnrollmentEventField.
`event_type`	`str`	Consists of the value `edx.course.enrollment.activated`.
`name`	`str`	Consists of the value `edx.course.enrollment.activated`.

Source code in ralph/models/edx/enrollment/statements.py

class EdxCourseEnrollmentActivated(BaseServerModel):
    """Pydantic model for `edx.course.enrollment.activated` statement.

    The server emits this statement when a student enrolls in a course.

    Attributes:
        event (EnrollmentEventField): See EnrollmentEventField.
        event_type (str): Consists of the value `edx.course.enrollment.activated`.
        name (str): Consists of the value `edx.course.enrollment.activated`.
    """

    __selector__ = selector(
        event_source="server", event_type="edx.course.enrollment.activated"
    )

    event: Union[
        Json[EnrollmentEventField],  # pylint: disable=unsubscriptable-object
        EnrollmentEventField,
    ]
    event_type: Literal["edx.course.enrollment.activated"]
    name: Literal["edx.course.enrollment.activated"]

`EdxCourseEnrollmentDeactivated (BaseServerModel)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.deactivated statement.

The server emits this statement when a student unenrolls from a course.

Attributes:

Name	Type	Description
`event`	`EnrollmentEventField`	See EnrollmentEventField.
`event_type`	`str`	Consists of the value `edx.course.enrollment.deactivated`.
`name`	`str`	Consists of the value `edx.course.enrollment.deactivated`.

Source code in ralph/models/edx/enrollment/statements.py

class EdxCourseEnrollmentDeactivated(BaseServerModel):
    """Pydantic model for `edx.course.enrollment.deactivated` statement.

    The server emits this statement when a student unenrolls from a course.

    Attributes:
        event (EnrollmentEventField): See EnrollmentEventField.
        event_type (str): Consists of the value `edx.course.enrollment.deactivated`.
        name (str): Consists of the value `edx.course.enrollment.deactivated`.
    """

    __selector__ = selector(
        event_source="server", event_type="edx.course.enrollment.deactivated"
    )

    event: Union[
        Json[EnrollmentEventField],  # pylint: disable=unsubscriptable-object
        EnrollmentEventField,
    ]
    event_type: Literal["edx.course.enrollment.deactivated"]
    name: Literal["edx.course.enrollment.deactivated"]

`EdxCourseEnrollmentModeChanged (BaseServerModel)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.mode_changed statement.

The server emits this statement when the process of changing a student’s student_courseenrollment.mode to a different mode is complete.

Attributes:

Name	Type	Description
`event`	`EnrollmentEventField`	See EnrollmentEventField.
`event_type`	`str`	Consists of the value `edx.course.enrollment.mode_changed`.
`name`	`str`	Consists of the value `edx.course.enrollment.mode_changed`.

Source code in ralph/models/edx/enrollment/statements.py

class EdxCourseEnrollmentModeChanged(BaseServerModel):
    """Pydantic model for `edx.course.enrollment.mode_changed` statement.

    The server emits this statement when the process of changing a student’s
    student_courseenrollment.mode to a different mode is complete.

    Attributes:
        event (EnrollmentEventField): See EnrollmentEventField.
        event_type (str): Consists of the value `edx.course.enrollment.mode_changed`.
        name (str): Consists of the value `edx.course.enrollment.mode_changed`.
    """

    __selector__ = selector(
        event_source="server", event_type="edx.course.enrollment.mode_changed"
    )

    event: Union[
        Json[EnrollmentEventField],  # pylint: disable=unsubscriptable-object
        EnrollmentEventField,
    ]
    event_type: Literal["edx.course.enrollment.mode_changed"]
    name: Literal["edx.course.enrollment.mode_changed"]

`EdxCourseEnrollmentUpgradeSucceeded (BaseServerModel)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.upgrade.succeeded statement.

The server emits this statement when the process of upgrading a student’s student_courseenrollment.mode from audit or honor to verified is complete.

Attributes:

Name	Type	Description
`context`	`EdxCourseEnrollmentUpgradeSucceededContextField`	See EdxCourseEnrollmentUpgradeSucceededContextField.
`event_type`	`str`	Consists of the value `edx.course.enrollment.upgrade.succeeded`.
`name`	`str`	Consists of the value `edx.course.enrollment.upgrade.succeeded`.

Source code in ralph/models/edx/enrollment/statements.py

class EdxCourseEnrollmentUpgradeSucceeded(BaseServerModel):
    """Pydantic model for `edx.course.enrollment.upgrade.succeeded` statement.

    The server emits this statement when the process of upgrading a student’s
    student_courseenrollment.mode from `audit` or `honor` to `verified` is complete.

    Attributes:
        context (EdxCourseEnrollmentUpgradeSucceededContextField):
            See EdxCourseEnrollmentUpgradeSucceededContextField.
        event_type (str): Consists of the value
            `edx.course.enrollment.upgrade.succeeded`.
        name (str): Consists of the value `edx.course.enrollment.upgrade.succeeded`.
    """

    __selector__ = selector(
        event_source="server", event_type="edx.course.enrollment.upgrade.succeeded"
    )

    context: EdxCourseEnrollmentUpgradeSucceededContextField
    event_type: Literal["edx.course.enrollment.upgrade.succeeded"]
    name: Literal["edx.course.enrollment.upgrade.succeeded"]

`UIEdxCourseEnrollmentUpgradeClicked (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for edx.course.enrollment.upgrade_clicked statement.

The browser emits this statement when a student clicks ChallengeYourself option, and the process of upgrading the student_courseenrollment.mode for the student to verified begins.

Attributes:

Name	Type	Description
`context`	`EdxCourseEnrollmentUpgradeClickedContextField`	See EdxCourseEnrollmentUpgradeClickedContextField.
`event_type`	`str`	Consists of the value `edx.course.enrollment.upgrade_clicked`.
`name`	`str`	Consists of the value `edx.course.enrollment.upgrade_clicked`.

Source code in ralph/models/edx/enrollment/statements.py

class UIEdxCourseEnrollmentUpgradeClicked(BaseBrowserModel):
    """Pydantic model for `edx.course.enrollment.upgrade_clicked` statement.

    The browser emits this statement when a student clicks <kbd>ChallengeYourself</kbd>
    option, and the process of upgrading the student_courseenrollment.mode for the
    student to `verified` begins.

    Attributes:
        context (EdxCourseEnrollmentUpgradeClickedContextField):
            See EdxCourseEnrollmentUpgradeClickedContextField.
        event_type (str): Consists of the value `edx.course.enrollment.upgrade_clicked`.
        name (str): Consists of the value `edx.course.enrollment.upgrade_clicked`.
    """

    __selector__ = selector(
        event_source="browser", event_type="edx.course.enrollment.upgrade_clicked"
    )

    context: EdxCourseEnrollmentUpgradeClickedContextField
    event_type: Literal["edx.course.enrollment.upgrade_clicked"]
    name: Literal["edx.course.enrollment.upgrade_clicked"]

`navigational` `special` ¶

`fields` `special` ¶

`events` ¶

Navigational event field definition.

`NavigationalEventField (AbstractBaseEventField)` `pydantic-model` ¶

Pydantic model for navigational event field.

Note: All navigational statements are emitted from the browser.

Attributes:

Name	Type	Description
`id`	`str`	Consists of the edX ID of the sequence.
`old`	`int`	For `seq_goto`, it consists of the index of the unit being jumped to. For `seq_next` and `seq_prev`, it consists of the index of the unit being navigated to.
`new`	`int`	For `seq_goto`, it consists of the index of the unit being jumped from. For `seq_next` and `seq_prev`, it consists of the index of the unit being navigated away from.

Source code in ralph/models/edx/navigational/fields/events.py

class NavigationalEventField(AbstractBaseEventField):
    """Pydantic model for navigational `event` field.

    Note: All navigational statements are emitted from the browser.

    Attributes:
        id (str): Consists of the edX ID of the sequence.
        old (int): For `seq_goto`, it consists of the index of the unit being jumped to.
            For `seq_next` and `seq_prev`, it consists of the index of the unit being
            navigated to.
        new (int): For `seq_goto`, it consists of the index of the unit being jumped
            from. For `seq_next` and `seq_prev`, it consists of the index of the unit
            being navigated away from.
    """

    id: constr(
        regex=(
            r"^block-v1:[^\/+]+(\/|\+)[^\/+]+(\/|\+)[^\/?]+type"  # noqa : F722
            r"@sequential\+block@[a-f0-9]{32}$"  # noqa : F722
        )
    )
    new: int
    old: int

`statements` ¶

Navigational event model definitions.

`UIPageClose (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for page_close statement.

The browser emits this statement when the user navigates to the next page or closes the browser window (when the JavaScript window.onunload event is called).

Attributes:

Name	Type	Description
`event`	`str`	Consists of the string value `{}`.
`event_type`	`str`	Consists of the value `page_close`.
`name`	`str`	Consists of the value `page_close`.

Source code in ralph/models/edx/navigational/statements.py

class UIPageClose(BaseBrowserModel):
    """Pydantic model for `page_close` statement.

    The browser emits this statement when the user navigates to the next page
    or closes the browser window (when the JavaScript `window.onunload` event
    is called).

    Attributes:
        event (str): Consists of the string value `{}`.
        event_type (str): Consists of the value `page_close`.
        name (str): Consists of the value `page_close`.
    """

    __selector__ = selector(event_source="browser", event_type="page_close")

    # pylint: disable=unsubscriptable-object
    event: Literal["{}"]
    event_type: Literal["page_close"]
    name: Literal["page_close"]

`UISeqGoto (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for seq_goto statement.

The browser emits this statement when a user jumps between units in a sequence.

Attributes:

Name	Type	Description
`event`	`obj`	Consists of member fields that identify specifics triggered event.
`event_type`	`str`	Consists of the value `seq_goto`.
`name`	`str`	Consists of the value `seq_goto`.

Source code in ralph/models/edx/navigational/statements.py

class UISeqGoto(BaseBrowserModel):
    """Pydantic model for `seq_goto` statement.

    The browser emits this statement when a user jumps between units in a sequence.

    Attributes:
        event (obj): Consists of member fields that identify specifics triggered event.
        event_type (str): Consists of the value `seq_goto`.
        name (str): Consists of the value `seq_goto`.
    """

    __selector__ = selector(event_source="browser", event_type="seq_goto")

    # pylint: disable=unsubscriptable-object
    event: Union[Json[NavigationalEventField], NavigationalEventField]
    event_type: Literal["seq_goto"]
    name: Literal["seq_goto"]

`UISeqNext (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for seq_next statement.

The browser emits this statement when a user navigates to the next unit in a sequence.

Attributes:

Name	Type	Description
`event`	`obj`	Consists of member fields that identify specifics triggered event.
`event_type`	`str`	Consists of the value `seq_next`.
`name`	`str`	Consists of the value `seq_next`.

Source code in ralph/models/edx/navigational/statements.py

class UISeqNext(BaseBrowserModel):
    """Pydantic model for `seq_next` statement.

    The browser emits this statement when a user navigates to the next unit in a
    sequence.

    Attributes:
        event (obj): Consists of member fields that identify specifics triggered event.
        event_type (str): Consists of the value `seq_next`.
        name (str): Consists of the value `seq_next`.
    """

    __selector__ = selector(event_source="browser", event_type="seq_next")

    # pylint: disable=unsubscriptable-object
    event: Union[Json[NavigationalEventField], NavigationalEventField]
    event_type: Literal["seq_next"]
    name: Literal["seq_next"]

    @validator("event")
    @classmethod
    def validate_next_jump_event_field(cls, value):
        """Checks that event.new is equal to event.old + 1."""
        if value.new != value.old + 1:
            raise ValueError("event.new - event.old should be equal to 1")

        return value

`validate_next_jump_event_field(value)` `classmethod` ¶

Checks that event.new is equal to event.old + 1.

Source code in ralph/models/edx/navigational/statements.py

@validator("event")
@classmethod
def validate_next_jump_event_field(cls, value):
    """Checks that event.new is equal to event.old + 1."""
    if value.new != value.old + 1:
        raise ValueError("event.new - event.old should be equal to 1")

    return value

`UISeqPrev (BaseBrowserModel)` `pydantic-model` ¶

Pydantic model for seq_prev statement.

The browser emits this statement when a user navigates to the previous unit in a sequence.

Attributes:

Name	Type	Description
`event`	`obj`	Consists of member fields that identify specifics triggered event.
`event_type`	`str`	Consists of the value `seq_prev`.
`name`	`str`	Consists of the value `seq_prev`.

Source code in ralph/models/edx/navigational/statements.py

class UISeqPrev(BaseBrowserModel):
    """Pydantic model for `seq_prev` statement.

    The browser emits this statement when a user navigates to the previous unit in a
    sequence.

    Attributes:
        event (obj): Consists of member fields that identify specifics triggered event.
        event_type (str): Consists of the value `seq_prev`.
        name (str): Consists of the value `seq_prev`.

    """

    __selector__ = selector(event_source="browser", event_type="seq_prev")

    # pylint: disable=unsubscriptable-object
    event: Union[Json[NavigationalEventField], NavigationalEventField]
    event_type: Literal["seq_prev"]
    name: Literal["seq_prev"]

    @validator("event")
    @classmethod
    def validate_prev_jump_event_field(cls, value):
        """Checks that event.new is equal to event.old - 1."""
        if value.new != value.old - 1:
            raise ValueError("event.old - event.new should be equal to 1")

        return value

`validate_prev_jump_event_field(value)` `classmethod` ¶

Checks that event.new is equal to event.old - 1.

Source code in ralph/models/edx/navigational/statements.py

@validator("event")
@classmethod
def validate_prev_jump_event_field(cls, value):
    """Checks that event.new is equal to event.old - 1."""
    if value.new != value.old - 1:
        raise ValueError("event.old - event.new should be equal to 1")

    return value

`problem_interaction` `special` ¶

`fields` `special` ¶

`events` ¶

Problem interaction events model event fields definitions.