liftwing_event_lifecycle.py

"""
This manim script creates an animated video illustrating the life cycle of a LiftWing event as implemented in the article-country model-server:
https://wikitech.wikimedia.org/wiki/File:Life_cycle_of_a_LiftWing_event.webm

Run the script using:
$ pip install manim
$ manim -pql liftwing_event_lifecycle.py LifeCycleScene
"""
from manim import Arrow, Create, Rectangle, Scene, SurroundingRectangle, Text, Write
from manim.utils.color import BLUE, GREEN, ORANGE, PURPLE, RED, YELLOW
from manim.constants import BOLD, DOWN, LEFT, ORIGIN, RIGHT, UP


class LifeCycleScene(Scene):
    """
    Manim Scene to demonstrate the life cycle of a LiftWing event with several slides illustrating each step.
    """

    def construct(self):
        # Slide 0 – Overview of the Life cycle of a LiftWing event
        self.slide0()
        self.wait(1)
        self.clear()

        # Slide 1 – Event is produced when a Wikipedia article is edited/created
        self.slide1()
        self.wait(1)
        self.clear()

        # Slide 2 – The event is stored in Kafka topic (e.g mediawiki.page_change.v1)
        self.slide2()
        self.wait(1)
        self.clear()

        # Slide 3 – Changeprop listens to Kafka topics and sends events to model-servers
        self.slide3()
        self.wait(1)
        self.clear()

        # Slide 4 – LiftWing receives events, produces predictions and generates output events
        self.slide4()
        self.wait(1)
        self.clear()

        # Slide 5 – EventGate receives events from LiftWing and sends them to Kafka
        self.slide5()
        self.wait(1)
        self.clear()

        # Final Slide – The End! :)
        self.final_slide()

    def slide0(self):
        """
        Displays an overview of the entire architecture lifecycle.
        """
        title = Text("Life cycle of a LiftWing event", font_size=36, weight=BOLD)
        title.to_edge(UP)

        flow = Text(
            "Wikipedia ➔ Kafka ➔ Changeprop ➔ LiftWing ➔ EventGate ➔ Kafka",
            font_size=24,
        )
        flow.move_to(ORIGIN)

        self.play(Write(title))
        self.play(Write(flow))
        self.wait(3)

    def final_slide(self):
        """
        Displays the closing slide with a closing message.
        """
        closing_text = Text("Fin! 😊", font_size=48, weight=BOLD)
        self.play(Write(closing_text))
        self.wait(3)

    def slide1(self):
        """
        Illustrates the first step, where an event is produced from a Wikipedia article change.
        """
        title = Text("Wikipedia article change", weight=BOLD, font_size=36)
        title.to_edge(UP)
        step1 = Text(
            "Step 1:\nA Wikipedia article is edited or created\n→ An event is produced",
            font_size=28,
        )
        step1.move_to(ORIGIN)
        box = SurroundingRectangle(step1, color=BLUE)
        self.play(Write(title))
        self.wait(0.5)
        self.play(Write(step1), Create(box))
        self.wait(3)

    def slide2(self):
        """
        Explains how the event is stored in Kafka under a specific topic.
        """
        title = Text("Step 2: Event stored in Kafka", font_size=36)
        title.to_edge(UP)

        event_box = Rectangle(width=4, height=2, color=BLUE)
        event_box.move_to(LEFT * 3)
        event_text = Text("Event Produced", font_size=24).move_to(
            event_box.get_center()
        )

        kafka_box = Rectangle(width=4, height=2, color=YELLOW)
        kafka_box.move_to(RIGHT * 3)
        kafka_text = Text(
            "Kafka Stream\n(mediawiki.page_change.v1)", font_size=20
        ).move_to(kafka_box.get_center())

        arrow = Arrow(start=event_box.get_right(), end=kafka_box.get_left(), buff=0.2)

        self.play(Write(title))
        self.play(Create(event_box), Write(event_text))
        self.play(Create(kafka_box), Write(kafka_text))
        self.play(Create(arrow))
        self.wait(3)

    def slide3(self):
        """
        Shows how Changeprop forwards events from Kafka to model-servers.
        """
        title = Text(
            "Step 3: changeprop forwards events\nfrom Kafka to model-servers",
            font_size=30,
        )
        title.to_edge(UP)

        cp_box = Rectangle(width=7, height=5, color=GREEN)
        cp_box.shift(LEFT * 2.5)

        staging_box = Rectangle(width=5, height=1.5, color=PURPLE)
        staging_box.next_to(cp_box.get_top(), DOWN, buff=0.8)
        staging_text = Text(
            "Staging:\nliftwing.test-article-country-events", font_size=16
        ).move_to(staging_box.get_center())

        prod_box = Rectangle(width=5, height=1.5, color=ORANGE)
        prod_box.next_to(staging_box, DOWN, buff=0.5)
        prod_text = Text("Production:\nmediawiki.page_change.v1", font_size=16).move_to(
            prod_box.get_center()
        )

        cp_text = Text("changeprop", font_size=18).move_to(
            cp_box.get_top() + DOWN * 0.6
        )

        lw_box = Rectangle(width=3, height=1.5, color=BLUE)
        lw_box.shift(RIGHT * 3)
        lw_text = Text("LiftWing", font_size=18).move_to(lw_box.get_center())

        arrow_staging = Arrow(
            start=staging_box.get_right(), end=lw_box.get_left(), buff=0.15
        )
        arrow_prod = Arrow(start=prod_box.get_right(), end=lw_box.get_left(), buff=0.15)

        self.play(Write(title))
        self.play(Create(cp_box), Write(cp_text))
        self.play(Create(staging_box), Write(staging_text))
        self.play(Create(prod_box), Write(prod_text))
        self.play(Create(lw_box), Write(lw_text))
        self.play(Create(arrow_staging), Create(arrow_prod))
        self.wait(3)

    def slide4(self):
        """
        Describes how LiftWing produces predictions and generates output events.
        """
        title = Text(
            "Step 4: LiftWing produces predictions\nand generates output events",
            font_size=30,
        )
        title.to_edge(UP)

        lw_box = Rectangle(width=8, height=5, color=BLUE)
        lw_box.shift(LEFT * 2.5)

        staging_box = Rectangle(width=6, height=1.5, color=PURPLE)
        staging_box.next_to(lw_box.get_top(), DOWN, buff=0.8)
        staging_text = Text(
            "Staging:\n• mediawiki.page_prediction_change.rc0\n• mediawiki.cirrussearch.page_weighted_tags_change.rc0",
            font_size=14,
        ).move_to(staging_box.get_center())

        prod_box = Rectangle(width=6, height=1.5, color=ORANGE)
        prod_box.next_to(staging_box, DOWN, buff=0.5)
        prod_text = Text(
            "Production:\n• mediawiki.article_country_prediction_change.v1\n• mediawiki.cirrussearch.page_weighted_tags_change.rc0",
            font_size=14,
        ).move_to(prod_box.get_center())

        lw_text = Text("LiftWing", font_size=18).move_to(lw_box.get_top() + DOWN * 0.6)

        eg_box = Rectangle(width=3, height=1.5, color=RED)
        eg_box.shift(RIGHT * 3.5)
        eg_text = Text("EventGate", font_size=18).move_to(eg_box.get_center())

        arrow_staging = Arrow(
            start=staging_box.get_right(), end=eg_box.get_left(), buff=0.15
        )
        arrow_prod = Arrow(start=prod_box.get_right(), end=eg_box.get_left(), buff=0.15)

        self.play(Write(title))
        self.play(Create(lw_box), Write(lw_text))
        self.play(Create(staging_box), Write(staging_text))
        self.play(Create(prod_box), Write(prod_text))
        self.play(Create(eg_box), Write(eg_text))
        self.play(Create(arrow_staging), Create(arrow_prod))
        self.wait(3)

    def slide5(self):
        """
        Illustrates how EventGate receives events from LiftWing and sends them to Kafka.
        """
        title = Text("Step 5: EventGate forwards events\nto Kafka", font_size=28)
        title.to_edge(UP)

        lw_box = Rectangle(width=3, height=1.5, color=BLUE)
        lw_box.shift(LEFT * 3)
        lw_text = Text("LiftWing", font_size=18).move_to(lw_box.get_center())

        eventgate_box = Rectangle(width=3, height=1.5, color=RED)
        eventgate_box.move_to(RIGHT * 1)
        eventgate_text = Text("EventGate", font_size=18).move_to(
            eventgate_box.get_center()
        )

        kafka_box = Rectangle(width=3, height=1.5, color=YELLOW)
        kafka_box.next_to(eventgate_box, RIGHT, buff=0.8)
        kafka_text = Text("Kafka", font_size=18).move_to(kafka_box.get_center())

        arrow_lw_to_eg = Arrow(
            start=lw_box.get_right(), end=eventgate_box.get_left(), buff=0.15
        )
        arrow_eg_to_kafka = Arrow(
            start=eventgate_box.get_right(), end=kafka_box.get_left(), buff=0.15
        )

        self.play(Write(title))
        self.play(Create(lw_box), Write(lw_text))
        self.play(Create(eventgate_box), Write(eventgate_text))
        self.play(Create(kafka_box), Write(kafka_text))
        self.play(Create(arrow_lw_to_eg), Create(arrow_eg_to_kafka))
        self.wait(3)