Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# Source code for nodriver.cdp.animation

    # DO NOT EDIT THIS FILE!
    #
    # This file is generated from the CDP specification. If you need to make
    # changes, edit the generator and regenerate all of the modules.
    #
    # CDP domain: Animation (experimental)

    from __future__ import annotations
    import enum
    import typing
    from dataclasses import dataclass
    from .util import event_class, T_JSON_DICT

    from . import dom
    from . import runtime

    @dataclass
    class Animation:
        '''
        Animation instance.
        '''
        #: ``Animation``'s id.
        id_: str

        #: ``Animation``'s name.
        name: str

        #: ``Animation``'s internal paused state.
        paused_state: bool

        #: ``Animation``'s play state.
        play_state: str

        #: ``Animation``'s playback rate.
        playback_rate: float

        #: ``Animation``'s start time.
        #: Milliseconds for time based animations and
        #: percentage [0 - 100] for scroll driven animations
        #: (i.e. when viewOrScrollTimeline exists).
        start_time: float

        #: ``Animation``'s current time.
        current_time: float

        #: Animation type of ``Animation``.
        type_: str

        #: ``Animation``'s source animation node.
        source: typing.Optional[AnimationEffect] = None

        #: A unique ID for ``Animation`` representing the sources that triggered this CSS
        #: animation/transition.
        css_id: typing.Optional[str] = None

        #: View or scroll timeline
        view_or_scroll_timeline: typing.Optional[ViewOrScrollTimeline] = None

        def to_json(self) -> T_JSON_DICT:
            json: T_JSON_DICT = dict()
            json['id'] = self.id_
            json['name'] = self.name
            json['pausedState'] = self.paused_state
            json['playState'] = self.play_state
            json['playbackRate'] = self.playback_rate
            json['startTime'] = self.start_time
            json['currentTime'] = self.current_time
            json['type'] = self.type_
            if self.source is not None:
                json['source'] = self.source.to_json()
            if self.css_id is not None:
                json['cssId'] = self.css_id
            if self.view_or_scroll_timeline is not None:
                json['viewOrScrollTimeline'] = self.view_or_scroll_timeline.to_json()
            return json

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> Animation:
            return cls(
                id_=str(json['id']),
                name=str(json['name']),
                paused_state=bool(json['pausedState']),
                play_state=str(json['playState']),
                playback_rate=float(json['playbackRate']),
                start_time=float(json['startTime']),
                current_time=float(json['currentTime']),
                type_=str(json['type']),
                source=AnimationEffect.from_json(json['source']) if json.get('source', None) is not None else None,
                css_id=str(json['cssId']) if json.get('cssId', None) is not None else None,
                view_or_scroll_timeline=ViewOrScrollTimeline.from_json(json['viewOrScrollTimeline']) if json.get('viewOrScrollTimeline', None) is not None else None,
            )

    @dataclass
    class ViewOrScrollTimeline:
        '''
        Timeline instance
        '''
        #: Orientation of the scroll
        axis: dom.ScrollOrientation

        #: Scroll container node
        source_node_id: typing.Optional[dom.BackendNodeId] = None

        #: Represents the starting scroll position of the timeline
        #: as a length offset in pixels from scroll origin.
        start_offset: typing.Optional[float] = None

        #: Represents the ending scroll position of the timeline
        #: as a length offset in pixels from scroll origin.
        end_offset: typing.Optional[float] = None

        #: The element whose principal box's visibility in the
        #: scrollport defined the progress of the timeline.
        #: Does not exist for animations with ScrollTimeline
        subject_node_id: typing.Optional[dom.BackendNodeId] = None

        def to_json(self) -> T_JSON_DICT:
            json: T_JSON_DICT = dict()
            json['axis'] = self.axis.to_json()
            if self.source_node_id is not None:
                json['sourceNodeId'] = self.source_node_id.to_json()
            if self.start_offset is not None:
                json['startOffset'] = self.start_offset
            if self.end_offset is not None:
                json['endOffset'] = self.end_offset
            if self.subject_node_id is not None:
                json['subjectNodeId'] = self.subject_node_id.to_json()
            return json

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> ViewOrScrollTimeline:
            return cls(
                axis=dom.ScrollOrientation.from_json(json['axis']),
                source_node_id=dom.BackendNodeId.from_json(json['sourceNodeId']) if json.get('sourceNodeId', None) is not None else None,
                start_offset=float(json['startOffset']) if json.get('startOffset', None) is not None else None,
                end_offset=float(json['endOffset']) if json.get('endOffset', None) is not None else None,
                subject_node_id=dom.BackendNodeId.from_json(json['subjectNodeId']) if json.get('subjectNodeId', None) is not None else None,
            )

    @dataclass
    class AnimationEffect:
        '''
        AnimationEffect instance
        '''
        #: ``AnimationEffect``'s delay.
        delay: float

        #: ``AnimationEffect``'s end delay.
        end_delay: float

        #: ``AnimationEffect``'s iteration start.
        iteration_start: float

        #: ``AnimationEffect``'s iterations.
        iterations: float

        #: ``AnimationEffect``'s iteration duration.
        #: Milliseconds for time based animations and
        #: percentage [0 - 100] for scroll driven animations
        #: (i.e. when viewOrScrollTimeline exists).
        duration: float

        #: ``AnimationEffect``'s playback direction.
        direction: str

        #: ``AnimationEffect``'s fill mode.
        fill: str

        #: ``AnimationEffect``'s timing function.
        easing: str

        #: ``AnimationEffect``'s target node.
        backend_node_id: typing.Optional[dom.BackendNodeId] = None

        #: ``AnimationEffect``'s keyframes.
        keyframes_rule: typing.Optional[KeyframesRule] = None

        def to_json(self) -> T_JSON_DICT:
            json: T_JSON_DICT = dict()
            json['delay'] = self.delay
            json['endDelay'] = self.end_delay
            json['iterationStart'] = self.iteration_start
            json['iterations'] = self.iterations
            json['duration'] = self.duration
            json['direction'] = self.direction
            json['fill'] = self.fill
            json['easing'] = self.easing
            if self.backend_node_id is not None:
                json['backendNodeId'] = self.backend_node_id.to_json()
            if self.keyframes_rule is not None:
                json['keyframesRule'] = self.keyframes_rule.to_json()
            return json

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> AnimationEffect:
            return cls(
                delay=float(json['delay']),
                end_delay=float(json['endDelay']),
                iteration_start=float(json['iterationStart']),
                iterations=float(json['iterations']),
                duration=float(json['duration']),
                direction=str(json['direction']),
                fill=str(json['fill']),
                easing=str(json['easing']),
                backend_node_id=dom.BackendNodeId.from_json(json['backendNodeId']) if json.get('backendNodeId', None) is not None else None,
                keyframes_rule=KeyframesRule.from_json(json['keyframesRule']) if json.get('keyframesRule', None) is not None else None,
            )

    @dataclass
    class KeyframesRule:
        '''
        Keyframes Rule
        '''
        #: List of animation keyframes.
        keyframes: typing.List[KeyframeStyle]

        #: CSS keyframed animation's name.
        name: typing.Optional[str] = None

        def to_json(self) -> T_JSON_DICT:
            json: T_JSON_DICT = dict()
            json['keyframes'] = [i.to_json() for i in self.keyframes]
            if self.name is not None:
                json['name'] = self.name
            return json

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> KeyframesRule:
            return cls(
                keyframes=[KeyframeStyle.from_json(i) for i in json['keyframes']],
                name=str(json['name']) if json.get('name', None) is not None else None,
            )

    @dataclass
    class KeyframeStyle:
        '''
        Keyframe Style
        '''
        #: Keyframe's time offset.
        offset: str

        #: ``AnimationEffect``'s timing function.
        easing: str

        def to_json(self) -> T_JSON_DICT:
            json: T_JSON_DICT = dict()
            json['offset'] = self.offset
            json['easing'] = self.easing
            return json

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> KeyframeStyle:
            return cls(
                offset=str(json['offset']),
                easing=str(json['easing']),
            )

    def disable() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Disables animation domain notifications.
        '''
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.disable',
        }
        json = yield cmd_dict

    def enable() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Enables animation domain notifications.
        '''
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.enable',
        }
        json = yield cmd_dict

    def get_current_time(
            id_: str
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,float]:
        '''
        Returns the current time of the an animation.

        :param id_: Id of animation.
        :returns: Current time of the page.
        '''
        params: T_JSON_DICT = dict()
        params['id'] = id_
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.getCurrentTime',
            'params': params,
        }
        json = yield cmd_dict
        return float(json['currentTime'])

    def get_playback_rate() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,float]:
        '''
        Gets the playback rate of the document timeline.

        :returns: Playback rate for animations on page.
        '''
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.getPlaybackRate',
        }
        json = yield cmd_dict
        return float(json['playbackRate'])

    def release_animations(
            animations: typing.List[str]
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Releases a set of animations to no longer be manipulated.

        :param animations: List of animation ids to seek.
        '''
        params: T_JSON_DICT = dict()
        params['animations'] = [i for i in animations]
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.releaseAnimations',
            'params': params,
        }
        json = yield cmd_dict

    def resolve_animation(
            animation_id: str
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,runtime.RemoteObject]:
        '''
        Gets the remote object of the Animation.

        :param animation_id: Animation id.
        :returns: Corresponding remote object.
        '''
        params: T_JSON_DICT = dict()
        params['animationId'] = animation_id
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.resolveAnimation',
            'params': params,
        }
        json = yield cmd_dict
        return runtime.RemoteObject.from_json(json['remoteObject'])

    def seek_animations(
            animations: typing.List[str],
            current_time: float
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Seek a set of animations to a particular time within each animation.

        :param animations: List of animation ids to seek.
        :param current_time: Set the current time of each animation.
        '''
        params: T_JSON_DICT = dict()
        params['animations'] = [i for i in animations]
        params['currentTime'] = current_time
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.seekAnimations',
            'params': params,
        }
        json = yield cmd_dict

    def set_paused(
            animations: typing.List[str],
            paused: bool
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Sets the paused state of a set of animations.

        :param animations: Animations to set the pause state of.
        :param paused: Paused state to set to.
        '''
        params: T_JSON_DICT = dict()
        params['animations'] = [i for i in animations]
        params['paused'] = paused
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.setPaused',
            'params': params,
        }
        json = yield cmd_dict

    def set_playback_rate(
            playback_rate: float
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Sets the playback rate of the document timeline.

        :param playback_rate: Playback rate for animations on page
        '''
        params: T_JSON_DICT = dict()
        params['playbackRate'] = playback_rate
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.setPlaybackRate',
            'params': params,
        }
        json = yield cmd_dict

    def set_timing(
            animation_id: str,
            duration: float,
            delay: float
        ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
        '''
        Sets the timing of an animation node.

        :param animation_id: Animation id.
        :param duration: Duration of the animation.
        :param delay: Delay of the animation.
        '''
        params: T_JSON_DICT = dict()
        params['animationId'] = animation_id
        params['duration'] = duration
        params['delay'] = delay
        cmd_dict: T_JSON_DICT = {
            'method': 'Animation.setTiming',
            'params': params,
        }
        json = yield cmd_dict

    @event_class('Animation.animationCanceled')
    @dataclass
    class AnimationCanceled:
        '''
        Event for when an animation has been cancelled.
        '''
        #: Id of the animation that was cancelled.
        id_: str

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> AnimationCanceled:
            return cls(
                id_=str(json['id'])
            )

    @event_class('Animation.animationCreated')
    @dataclass
    class AnimationCreated:
        '''
        Event for each animation that has been created.
        '''
        #: Id of the animation that was created.
        id_: str

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> AnimationCreated:
            return cls(
                id_=str(json['id'])
            )

    @event_class('Animation.animationStarted')
    @dataclass
    class AnimationStarted:
        '''
        Event for animation that has been started.
        '''
        #: Animation that was started.
        animation: Animation

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> AnimationStarted:
            return cls(
                animation=Animation.from_json(json['animation'])
            )

    @event_class('Animation.animationUpdated')
    @dataclass
    class AnimationUpdated:
        '''
        Event for animation that has been updated.
        '''
        #: Animation that was updated.
        animation: Animation

        @classmethod
        def from_json(cls, json: T_JSON_DICT) -> AnimationUpdated:
            return cls(
                animation=Animation.from_json(json['animation'])
            )