[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a new scene named 'MyScene'.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pass


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a circle with radius 2 and center at the origin to the scene.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2, color=BLUE)
		self.add(circle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a text object saying 'Hello, World!' and add it to the scene.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		text = Text('Hello, World!')
		self.add(text)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Animate the circle to move 2 units to the right in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2, color=BLUE)
		self.add(circle)
		self.play(circle.animate.shift(RIGHT * 2), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a square with side length 3 and add it to the scene.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=3, color=RED)
		self.add(square)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the square by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=3, color=RED)
		self.add(square)
		self.play(square.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a triangle with vertices at (-1, 0), (1, 0), and (0, 2) and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2), color=YELLOW)
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the triangle by 90 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2), color=YELLOW)
		self.add(triangle)
		self.play(triangle.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 4 and height 2, centered at (0, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2, color=BLUE)
		rectangle.move_to((0, 0))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'A' at the coordinates (-2, 1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2, color=BLUE)
		label = Text('A').move_to((-2, 1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a square with side length 2 and a circle with radius 1 to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=RED)
		circle = Circle(radius=1, color=GREEN)
		vgroup = VGroup(square, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees clockwise.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=RED)
		circle = Circle(radius=1, color=GREEN)
		vgroup = VGroup(square, circle)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an axis with x-axis ranging from -5 to 5 and y-axis ranging from -3 to 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		axes = Axes(x_range=(-5, 5), y_range=(-3, 3))
		self.add(axes)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Plot a graph of the function y = sin(x) on the axis.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		axes = Axes(x_range=(-5, 5), y_range=(-1, 1))
		graph = axes.get_graph(lambda
		x:
		np.sin(x), color=PURPLE)
		self.add(axes, graph)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add an arrow pointing downwards at the coordinates (-2, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		arrow = Arrow(start=(-2, 1), end=(-2, 0), color=YELLOW)
		self.add(arrow)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an ellipse with major axis 2 and minor axis 1.5.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=2, height=1.5, color=ORANGE)
		self.add(ellipse)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the ellipse clockwise by 90 degrees over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=2, height=1.5, color=ORANGE)
		self.add(ellipse)
		self.play(ellipse.animate.rotate(90 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2.5 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the pentagon to the right by 3 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)
		self.play(pentagon.animate.shift(RIGHT * 3), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2.5 and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2.5, color=YELLOW)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 120 degrees counterclockwise over 3 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2.5, color=YELLOW)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-120 * DEGREES), run_time=3)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a text object saying 'Hello, Manim!' and position it at (0, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		text = Text('Hello, Manim!')
		text.move_to((0, 2))
		self.add(text)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add an arc with radius 3 and angle of 90 degrees centered at (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		arc = Arc(radius=3, start_angle=0, angle=90 * DEGREES, color=PINK)
		arc.move_to((-1, -1))
		self.add(arc)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 3 and color it green.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=3, color=GREEN)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the heptagon by 60 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=3, color=GREEN)
		self.add(heptagon)
		self.play(heptagon.animate.rotate(-60 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (1, 1) and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((1, 1), color=RED)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a bezier curve with control points (-1, 0), (0, 2), and (2, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		points = [(-1, 0), (0, 2), (2, 1)]
		curve = VMobject()
		curve.set_points_smoothly(points)
		self.add(curve)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 2 and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=PURPLE)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the octagon by a factor of 1.5 in 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=PURPLE)
		self.add(octagon)
		self.play(octagon.animate.scale(1.5), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment connecting points (-1, -1) and (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (2, 2))
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a triangle with vertices at (-1, 0), (1, 0), and (0, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the triangle by 90 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		self.add(triangle)
		self.play(triangle.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 4 and height 2, centered at (0, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		rectangle.move_to((0, 0))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'A' at the coordinates (-2, 1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		label = Text('A').move_to((-2, 1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a square with side length 2 and a circle with radius 1 to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2)
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees clockwise.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2)
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2.5 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the pentagon to the right by 3 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)
		self.play(pentagon.animate.shift(RIGHT * 3), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2.5 and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2.5, color=YELLOW)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 120 degrees counterclockwise over 3 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2.5, color=YELLOW)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-120 * DEGREES), run_time=3)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a text object saying 'Hello, Manim!' and position it at (0, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		text = Text('Hello, Manim!')
		text.move_to((0, 2))
		self.add(text)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add an arc with radius 3 and angle of 90 degrees centered at (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		arc = Arc(radius=3, start_angle=0, angle=90 * DEGREES)
		arc.move_to((-1, -1))
		self.add(arc)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a triangle with vertices at (-1, 0), (1, 0), and (0, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the triangle by 90 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		self.add(triangle)
		self.play(triangle.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular decagon with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=PINK)
		self.add(decagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the decagon by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=PINK)
		self.add(decagon)
		self.play(decagon.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment connecting points (-2, 1) and (2, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, 1), (2, -1))
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a triangle and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		circle = Circle(radius=1)
		vgroup = VGroup(triangle, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 30 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1, 0), (1, 0), (0, 2))
		circle = Circle(radius=1)
		vgroup = VGroup(triangle, circle)
		self.add(vgroup)
		self.play(vgroup.animate.rotate(30 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 2 and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=TEAL)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the nonagon to the right by 3 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=TEAL)
		self.add(nonagon)
		self.play(nonagon.animate.shift(RIGHT * 3), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an arc with radius 2, angle of 180 degrees, and centered at (1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		arc = Arc(radius=2, start_angle=0, angle=180 * DEGREES)
		arc.move_to((1, 1))
		self.add(arc)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezoid with base lengths 2 and 4, and height 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezoid = Polygon((-2, -1.5), (2, -1.5), (1, 1.5), (-1, 1.5))
		self.add(trapezoid)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (2, 2) and color it blue.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((2, 2), color=BLUE)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=ORANGE)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 60 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=ORANGE)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-60 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 2, centered at (0, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=2)
		rectangle.move_to((0, 0))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'B' at the coordinates (2, -1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=2)
		label = Text('B').move_to((2, -1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a line segment and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, 1), (2, -1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, 1), (2, -1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular dodecagon with side length 2 and color it brown.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=BROWN)
		self.add(dodecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the dodecagon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=BROWN)
		self.add(dodecagon)
		self.play(dodecagon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment connecting points (-1, 1) and (1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, 1), (1, -1))
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a rectangle and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=2)
		circle = Circle(radius=1)
		vgroup = VGroup(rectangle, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 60 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=2)
		circle = Circle(radius=1)
		vgroup = VGroup(rectangle, circle)
		self.add(vgroup)
		self.play(vgroup.animate.rotate(60 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2.5 and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=PURPLE)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the heptagon to the right by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=PURPLE)
		self.add(heptagon)
		self.play(heptagon.animate.shift(RIGHT * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an arc with radius 3, angle of 180 degrees, and centered at (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		arc = Arc(radius=3, start_angle=0, angle=180 * DEGREES)
		arc.move_to((-1, -1))
		self.add(arc)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezoid with base lengths 3 and 5, and height 4.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezoid = Polygon((-2.5, -2), (2.5, -2), (3, 2), (-3, 2))
		self.add(trapezoid)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (0, 0) and color it green.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((0, 0), color=GREEN)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 3 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=3, color=RED)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the octagon by 90 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=3, color=RED)
		self.add(octagon)
		self.play(octagon.animate.rotate(-90 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 4 and height 2, centered at (-1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		rectangle.move_to((-1, 1))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'C' at the coordinates (0, -1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		label = Text('C').move_to((0, -1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a square and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2)
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 30 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2)
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		vgroup.rotate(-30 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular tetragon with side length 2 and color it gray.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		tetragon = RegularPolygon(n=4, radius=2, color=GRAY)
		self.add(tetragon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the tetragon to the right by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		tetragon = RegularPolygon(n=4, radius=2, color=GRAY)
		self.add(tetragon)
		self.play(tetragon.animate.shift(RIGHT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a parallelogram with base lengths 4 and 2, and height 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		parallelogram = Polygon((-2, -1.5), (2, -1.5), (4, 1.5), (0, 1.5))
		self.add(parallelogram)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (1, -1) and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((1, -1), color=YELLOW)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2.5 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the pentagon by 120 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2.5, color=CYAN)
		self.add(pentagon)
		self.play(pentagon.animate.rotate(-120 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 5 and height 3, centered at (1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=3)
		rectangle.move_to((1, -1))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'D' at the coordinates (2, 1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=3)
		label = Text('D').move_to((2, 1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a triangle and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Triangle()
		circle = Circle(radius=1)
		vgroup = VGroup(triangle, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Triangle()
		circle = Circle(radius=1)
		vgroup = VGroup(triangle, circle)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 3.5 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3.5, color=PINK)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the nonagon to the right by 4 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3.5, color=PINK)
		self.add(nonagon)
		self.play(nonagon.animate.shift(RIGHT * 4), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a sector with radius 2, angle of 120 degrees, and centered at (1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		sector = Sector(radius=2, start_angle=0, angle=120 * DEGREES)
		sector.move_to((1, 1))
		self.add(sector)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezium with base lengths 2 and 4, and height 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezium = Polygon((-2, -1.5), (2, -1.5), (4, 1.5), (-4, 1.5))
		self.add(trapezium)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (-1, 2) and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((-1, 2), color=ORANGE)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=TEAL)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 60 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=TEAL)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-60 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 5, centered at (-2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=5)
		rectangle.move_to((-2, 2))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'E' at the coordinates (-1, -1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=5)
		label = Text('E').move_to((-1, -1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a line segment and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 90 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		vgroup.rotate(-90 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2.5 and color it lavender.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=LAVENDER)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the heptagon to the right by 3.5 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=LAVENDER)
		self.add(heptagon)
		self.play(heptagon.animate.shift(RIGHT * 3.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a sector with radius 2.5, angle of 60 degrees, and centered at (-1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		sector = Sector(radius=2.5, start_angle=0, angle=60 * DEGREES)
		sector.move_to((-1, 1))
		self.add(sector)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezoid with base lengths 2 and 5, and height 4.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezoid = Polygon((-2.5, -2), (2.5, -2), (3.5, 2), (-3.5, 2))
		self.add(trapezoid)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (2, -2) and color it magenta.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((2, -2), color=MAGENTA)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 3 and color it brown.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=3, color=BROWN)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the octagon by 90 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=3, color=BROWN)
		self.add(octagon)
		self.play(octagon.animate.rotate(-90 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 4 and height 2, centered at (-1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		rectangle.move_to((-1, 1))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'F' at the coordinates (0, -1) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=4, height=2)
		label = Text('F').move_to((0, -1))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a square and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square()
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 30 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square()
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		vgroup.rotate(-30 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 2 and color it olive.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=OLIVE)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the nonagon to the right by 2.5 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=OLIVE)
		self.add(nonagon)
		self.play(nonagon.animate.shift(RIGHT * 2.5), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a sector with radius 3, angle of 90 degrees, and centered at (0, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		sector = Sector(radius=3, start_angle=0, angle=90 * DEGREES)
		sector.move_to((0, 0))
		self.add(sector)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezium with base lengths 2 and 6, and height 4.5.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezium = Polygon((-3, -2.25), (3, -2.25), (4, 2.25), (-4, 2.25))
		self.add(trapezium)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (-2, -2) and color it gray.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((-2, -2), color=GRAY)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 3 and color it maroon.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=3, color=MAROON)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 45 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=3, color=MAROON)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-45 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 5 and height 2, centered at (1, -2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=2)
		rectangle.move_to((1, -2))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'G' at the coordinates (2, 0) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=2)
		label = Text('G').move_to((2, 0))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a line segment and a square to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		square = Square(side_length=2)
		vgroup = VGroup(line, square)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 60 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		square = Square(side_length=2)
		vgroup = VGroup(line, square)
		vgroup.rotate(-60 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2.5 and color it navy.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=NAVY)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the heptagon to the right by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2.5, color=NAVY)
		self.add(heptagon)
		self.play(heptagon.animate.shift(RIGHT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a sector with radius 2.5, angle of 120 degrees, and centered at (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		sector = Sector(radius=2.5, start_angle=0, angle=120 * DEGREES)
		sector.move_to((-1, -1))
		self.add(sector)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezoid with base lengths 3 and 7, and height 5.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezoid = Polygon((-4, -2.5), (4, -2.5), (5, 2.5), (-5, 2.5))
		self.add(trapezoid)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (3, -3) and color it indigo.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((3, -3), color=INDIGO)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 4 and color it aqua.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=4, color=AQUA)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the octagon by 120 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=4, color=AQUA)
		self.add(octagon)
		self.play(octagon.animate.rotate(-120 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 6 and height 3, centered at (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=6, height=3)
		rectangle.move_to((2, 2))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'H' at the coordinates (3, 3) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=6, height=3)
		label = Text('H').move_to((3, 3))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a line segment and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		circle = Circle(radius=1)
		vgroup = VGroup(line, circle)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 3 and color it olive.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3, color=OLIVE)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the nonagon to the right by 4 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3, color=OLIVE)
		self.add(nonagon)
		self.play(nonagon.animate.shift(RIGHT * 4), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a sector with radius 3, angle of 90 degrees, and centered at (1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		sector = Sector(radius=3, start_angle=0, angle=90 * DEGREES)
		sector.move_to((1, 1))
		self.add(sector)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a trapezoid with base lengths 2 and 6, and height 4.5.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		trapezoid = Polygon((-3, -2.25), (3, -2.25), (4, 2.25), (-4, 2.25))
		self.add(trapezoid)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (-2, -2) and color it gray.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((-2, -2), color=GRAY)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 3 and color it maroon.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=3, color=MAROON)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 45 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=3, color=MAROON)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-45 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 5 and height 2, centered at (1, -2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=2)
		rectangle.move_to((1, -2))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'I' at the coordinates (2, 0) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=5, height=2)
		label = Text('I').move_to((2, 0))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a square and a circle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square()
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 30 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square()
		circle = Circle(radius=1)
		vgroup = VGroup(square, circle)
		vgroup.rotate(-30 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a circle with radius 2 and center at the origin.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2)
		self.add(circle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the circle to the right by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2)
		self.add(circle)
		self.play(circle.animate.shift(RIGHT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a square with side length 4 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=4, color=RED)
		self.add(square)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the square by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=4, color=RED)
		self.add(square)
		self.play(square.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a triangle with side lengths 3, 4, and 5.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1.5, -2), (1.5, -2), (0, 2), color=YELLOW)
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the triangle by 90 degrees counterclockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = Polygon((-1.5, -2), (1.5, -2), (0, 2), color=YELLOW)
		self.add(triangle)
		self.play(triangle.animate.rotate(-90 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -1) to (2, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -1), (2, 1), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment upward by 2 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -1), (2, 1), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(UP * 2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=3, color=BLUE)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the pentagon to the left by 4 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=3, color=BLUE)
		self.add(pentagon)
		self.play(pentagon.animate.shift(LEFT * 4), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an ellipse with major axis 4 and minor axis 2.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=4, height=2, color=ORANGE)
		self.add(ellipse)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the ellipse by a factor of 1.5 in 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=4, height=2, color=ORANGE)
		self.add(ellipse)
		self.play(ellipse.animate.scale(1.5), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (1, 1) and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((1, 1), color=PURPLE)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=CYAN)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the heptagon by 60 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=CYAN)
		self.add(heptagon)
		self.play(heptagon.animate.rotate(-60 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 6, centered at (-1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=6)
		rectangle.move_to((-1, 1))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'M' at the coordinates (0, 2) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=6)
		label = Text('M').move_to((0, 2))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a line segment and a square to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		square = Square()
		vgroup = VGroup(line, square)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1))
		square = Square()
		vgroup = VGroup(line, square)
		vgroup.rotate(-45 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 2 and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the octagon upward by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)
		self.play(octagon.animate.shift(UP * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 3 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3, color=PINK)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the nonagon by 90 degrees clockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=3, color=PINK)
		self.add(nonagon)
		self.play(nonagon.animate.rotate(-90 * DEGREES), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line from (0, 0) to (3, 4).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (3, 4), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line downward by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (3, 4), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(DOWN * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an equilateral triangle with side length 3 and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=3, color=YELLOW)
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the triangle by a factor of 1.5 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=3, color=YELLOW)
		self.add(triangle)
		self.play(triangle.animate.scale(1.5), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (-1, -1) and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((-1, -1), color=ORANGE)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular decagon with side length 2 and color it green.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=GREEN)
		self.add(decagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the decagon by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=GREEN)
		self.add(decagon)
		self.play(decagon.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 2 and height 4, centered at (2, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=2, height=4)
		rectangle.move_to((2, -1))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'N' at the coordinates (2, 3) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=2, height=4)
		label = Text('N').move_to((2, 3))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a circle and a triangle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle()
		triangle = Polygon((-1, -1), (1, -1), (0, 1))
		vgroup = VGroup(circle, triangle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 90 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle()
		triangle = Polygon((-1, -1), (1, -1), (0, 1))
		vgroup = VGroup(circle, triangle)
		vgroup.rotate(-90 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it violet.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=VIOLET)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the hexagon to the right by 3 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=VIOLET)
		self.add(hexagon)
		self.play(hexagon.animate.shift(RIGHT * 3), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular enneagon with side length 3 and color it brown.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		enneagon = RegularPolygon(n=9, radius=3, color=BROWN)
		self.add(enneagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the enneagon by 60 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		enneagon = RegularPolygon(n=9, radius=3, color=BROWN)
		self.add(enneagon)
		self.play(enneagon.animate.rotate(-60 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-3, -2) to (3, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, -2), (3, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment upward by 4 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, -2), (3, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(UP * 4), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an equilateral triangle with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=2, color=PINK)
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the triangle by a factor of 2 in 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=2, color=PINK)
		self.add(triangle)
		self.play(triangle.animate.scale(2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (2, 2) and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((2, 2), color=TEAL)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular dodecagon with side length 2 and color it gray.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=GRAY)
		self.add(dodecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the dodecagon by 30 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=GRAY)
		self.add(dodecagon)
		self.play(dodecagon.animate.rotate(-30 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 5, centered at (-2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=5)
		rectangle.move_to((-2, 2))
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Add a text label 'O' at the coordinates (-1, -2) of the rectangle.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=5)
		label = Text('O').move_to((-1, -2))
		self.add(rectangle, label)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a VGroup and add a circle, a square, and a triangle to it.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle()
		square = Square()
		triangle = Polygon((-1, -1), (1, -1), (0, 1))
		vgroup = VGroup(circle, square, triangle)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the VGroup by 120 degrees clockwise over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle()
		square = Square()
		triangle = Polygon((-1, -1), (1, -1), (0, 1))
		vgroup = VGroup(circle, square, triangle)
		vgroup.rotate(-120 * DEGREES)
		self.add(vgroup)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentadecagon with side length 2 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentadecagon = RegularPolygon(n=15, radius=2, color=CYAN)
		self.add(pentadecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the pentadecagon to the left by 4 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentadecagon = RegularPolygon(n=15, radius=2, color=CYAN)
		self.add(pentadecagon)
		self.play(pentadecagon.animate.shift(LEFT * 4), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 20 sides, side length 2, and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=20, radius=2, color=ORANGE)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the polygon by 75 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=20, radius=2, color=ORANGE)
		self.add(polygon)
		self.play(polygon.animate.rotate(-75 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment to the right by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(RIGHT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an equilateral triangle with side length 2 and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=2, color=YELLOW)
		self.add(triangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the triangle by a factor of 2 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		triangle = RegularPolygon(n=3, radius=2, color=YELLOW)
		self.add(triangle)
		self.play(triangle.animate.scale(2), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a square with side length 2 and color it blue.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=BLUE)
		self.add(square)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the square to the right by 3 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=BLUE)
		self.add(square)
		self.play(square.animate.shift(RIGHT * 3), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a circle with radius 1.5 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=1.5, color=RED)
		self.add(circle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the circle by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=1.5, color=RED)
		self.add(circle)
		self.play(circle.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a text object saying 'Hello, Manim!' and add it to the scene.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		text = Text('Hello, Manim!')
		self.add(text)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Fade in the text object over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		text = Text('Hello, Manim!')
		self.add(text)
		self.play(FadeIn(text), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2) and color it green.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 4 and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=4, color=ORANGE)
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the rectangle downward by 2 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=4, color=ORANGE)
		self.add(rectangle)
		self.play(rectangle.animate.shift(DOWN * 2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a polygon with vertices at (-2, 0), (0, 2), and (2, 0) and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = Polygon((-2, 0), (0, 2), (2, 0), color=YELLOW)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the polygon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = Polygon((-2, 0), (0, 2), (2, 0), color=YELLOW)
		self.add(polygon)
		self.play(polygon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=PINK)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 60 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=PINK)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(60 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an ellipse with x-radius 3 and y-radius 2 and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=6, height=4, color=PURPLE)
		self.add(ellipse)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Fade out the ellipse over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=6, height=4, color=PURPLE)
		self.add(ellipse)
		self.play(FadeOut(ellipse), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2 and color it cyan.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=CYAN)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the heptagon to the left by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=CYAN)
		self.add(heptagon)
		self.play(heptagon.animate.shift(LEFT * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a point at coordinates (2, 2) and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		point = Dot((2, 2), color=TEAL)
		self.add(point)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular dodecagon with side length 2 and color it gray.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=GRAY)
		self.add(dodecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the dodecagon by 30 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=GRAY)
		self.add(dodecagon)
		self.play(dodecagon.animate.rotate(-30 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2 and color it brown.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=BROWN)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the pentagon upward by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=BROWN)
		self.add(pentagon)
		self.play(pentagon.animate.shift(UP * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 2 and color it olive.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=OLIVE)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the octagon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=OLIVE)
		self.add(octagon)
		self.play(octagon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular tetradecagon with side length 2 and color it lime.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		tetradecagon = RegularPolygon(n=14, radius=2, color=LIME)
		self.add(tetradecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the tetradecagon to the right by 4 units over 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		tetradecagon = RegularPolygon(n=14, radius=2, color=LIME)
		self.add(tetradecagon)
		self.play(tetradecagon.animate.shift(RIGHT * 4), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 20 sides, side length 2, and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=20, radius=2, color=ORANGE)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the polygon by 75 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=20, radius=2, color=ORANGE)
		self.add(polygon)
		self.play(polygon.animate.rotate(-75 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment to the right by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(RIGHT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 6 sides, side length 2, and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=6, radius=2, color=PURPLE)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the polygon by 90 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=6, radius=2, color=PURPLE)
		self.add(polygon)
		self.play(polygon.animate.rotate(90 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (0, 0) to (4, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (4, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment upward by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (4, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(UP * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 8 sides, side length 2, and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the polygon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(polygon)
		self.play(polygon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (1, 1) to (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 10 sides, side length 2, and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=10, radius=2, color=YELLOW)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the polygon to the left by 3 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=10, radius=2, color=YELLOW)
		self.add(polygon)
		self.play(polygon.animate.shift(LEFT * 3), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-3, 0) to (3, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment downward by 2 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(DOWN * 2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 12 sides, side length 2, and color it blue.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=12, radius=2, color=BLUE)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the polygon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=12, radius=2, color=BLUE)
		self.add(polygon)
		self.play(polygon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 6 sides, side length 2, and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=6, radius=2, color=RED)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the polygon to the right by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=6, radius=2, color=RED)
		self.add(polygon)
		self.play(polygon.animate.shift(RIGHT * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular polygon with 8 sides, side length 2, and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=8, radius=2, color=PINK)
		self.add(polygon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the polygon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		polygon = RegularPolygon(n=8, radius=2, color=PINK)
		self.add(polygon)
		self.play(polygon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a square with side length 2 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=RED)
		self.add(square)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the square upward by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		square = Square(side_length=2, color=RED)
		self.add(square)
		self.play(square.animate.shift(UP * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a rectangle with width 3 and height 4.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=4, color=BLUE)
		self.add(rectangle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the rectangle by 90 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		rectangle = Rectangle(width=3, height=4, color=BLUE)
		self.add(rectangle)
		self.play(rectangle.animate.rotate(90 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create an ellipse with x-radius 2 and y-radius 3.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=4, height=6, color=GREEN)
		self.add(ellipse)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the ellipse by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		ellipse = Ellipse(width=4, height=6, color=GREEN)
		self.add(ellipse)
		self.play(ellipse.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a circle with radius 2 and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2, color=ORANGE)
		self.add(circle)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the circle to the left by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		circle = Circle(radius=2, color=ORANGE)
		self.add(circle)
		self.play(circle.animate.shift(LEFT * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it yellow.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=YELLOW)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the hexagon by 120 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=YELLOW)
		self.add(hexagon)
		self.play(hexagon.animate.rotate(-120 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (0, 0) to (4, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (4, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment upward by 2 units over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (4, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(UP * 2), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2 and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=PURPLE)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the pentagon by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=PURPLE)
		self.add(pentagon)
		self.play(pentagon.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-3, 0) to (3, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment downward by 2 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(DOWN * 2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 2 and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the octagon by 90 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)
		self.play(octagon.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (1, 1) to (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=PINK)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the heptagon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=PINK)
		self.add(heptagon)
		self.play(heptagon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=RED)
		self.add(hexagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the hexagon to the right by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=RED)
		self.add(hexagon)
		self.play(hexagon.animate.shift(RIGHT * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular nonagon with side length 2 and color it blue.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=BLUE)
		self.add(nonagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the nonagon by a factor of 2 in 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		nonagon = RegularPolygon(n=9, radius=2, color=BLUE)
		self.add(nonagon)
		self.play(nonagon.animate.scale(2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-1, -1) to (1, 1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 90 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-1, -1), (1, 1), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular decagon with side length 2 and color it orange.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=ORANGE)
		self.add(decagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the decagon downward by 3 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		decagon = RegularPolygon(n=10, radius=2, color=ORANGE)
		self.add(decagon)
		self.play(decagon.animate.shift(DOWN * 3), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (0, 0) to (3, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (3, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 60 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((0, 0), (3, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-60 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular dodecagon with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=PINK)
		self.add(dodecagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the dodecagon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		dodecagon = RegularPolygon(n=12, radius=2, color=PINK)
		self.add(dodecagon)
		self.play(dodecagon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, 0) to (2, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, 0), (2, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment upward by 1 unit over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, 0), (2, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(UP * 1), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular pentagon with side length 2 and color it purple.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=PURPLE)
		self.add(pentagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the pentagon by 90 degrees clockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		pentagon = RegularPolygon(n=5, radius=2, color=PURPLE)
		self.add(pentagon)
		self.play(pentagon.animate.rotate(90 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-3, 0) to (3, 0).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Move the line segment downward by 2 units over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-3, 0), (3, 0), color=GREEN)
		self.add(line)
		self.play(line.animate.shift(DOWN * 2), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular octagon with side length 2 and color it teal.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the octagon by 90 degrees clockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		octagon = RegularPolygon(n=8, radius=2, color=TEAL)
		self.add(octagon)
		self.play(octagon.animate.rotate(90 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (1, 1) to (-1, -1).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1.5 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((1, 1), (-1, -1), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1.5)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular heptagon with side length 2 and color it pink.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=PINK)
		self.add(heptagon)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Scale the heptagon by a factor of 1.5 in 2 seconds.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		heptagon = RegularPolygon(n=7, radius=2, color=PINK)
		self.add(heptagon)
		self.play(heptagon.animate.scale(1.5), run_time=2)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a line segment from (-2, -2) to (2, 2).

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Rotate the line segment by 45 degrees counterclockwise over 1 second.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		line = Line((-2, -2), (2, 2), color=GREEN)
		self.add(line)
		self.play(line.animate.rotate(-45 * DEGREES), run_time=1)


[System] Write Manim scripts for animations in Python. Generate code, not text.

[User] Create a regular hexagon with side length 2 and color it red.

[Assistant]
from manim import *
class MyScene(Scene):
	def construct(self):
		hexagon = RegularPolygon(n=6, radius=2, color=RED)
		self.add(hexagon)