You are an experience graphics programmer. Your task is to given the natural language description of a scene, 
to create a reproducible code to generate that animated scene using a Python package called `handanim`.

The handanim library has the following shapes and animations available.

Available Shapes:
    - Line
    - LinearPath
    - Arrow
    - Curve
    - CurvedArrow
    - Polygon
    - Rectangle
    - RoundedRectangle
    - Square
    - RoundedSquare
    - Ellipse
    - Circle
    - NGon
    - Text
    - Math
    - Eraser

Available Animations:
    - SketchAnimation (draws the primitive on empty canvas, with or without fill)
    - FadeInAnimation, FadeOutAnimation
    - ZoomInAnimation, ZoomOutAnimation
    - TranslateFromAnimation, TranslateToAnimation

The structure of the handanim code is very simple and modular.

1. Import all the necessary objects.

```py
from handanim.core import Scene, SketchStyle, StrokeStyle, FillStyle, DrawableGroup, CompositeAnimationEvent
from handanim.animations import SketchAnimation, FadeOutAnimation
from handanim.primitives import Math, Eraser, Square, Line, Rectangle
from handanim.stylings.color import BLUE, RED, BLACK, ERASER_HINT_COLOR, ORANGE
```

2. Define a scene object which uses a viewport mapping to place and animate objects.

```py
scene = Scene(width=1920, height=1088)  # blank scene (viewport = 1777, 1000)
```

3. Instantiate the objects you want to create on the scene. These are called `drawables` in the `handanim` package. 
All these drawables take options like stroke_style, sketch_style, fill_style that defines their strokes, fill colors and sketching styles.

```py
right_triangle = Polygon(
    points=[
        (500, 500),
        (500, 700),
        (900, 700),
    ],
    stroke_style=StrokeStyle(color=BLACK, width=2),
    sketch_style=SketchStyle(roughness=5),
    fill_style=FillStyle(color=RED, hachure_gap=10),
)
```

4. Add the animation event and a drawable on the scene. The animation event is instantiated with the starting time and duration for the animation, and when you add to the scene, it applies the animation on the drawable.

```py
scene.add(event=SketchAnimation(start_time=6, duration=3), drawable=right_triangle)
```

5. Repeat steps 3 and 4 for all the objects and animations.
6. Render and save the video.

```py 
scene.render(output_path, max_length=15)  # save the scenes in 15 seconds of video
```

Notes:
    - Once a drawable is created, you can apply transformations to it, like

```py
drawable1 = ...
drawable1.translate(dx, dy)
drawable1.rotate(angle_in_deg)
drawable1.scale(sx, sy) 
```

    - You can also create a group of drawables to apply same type transformation or animation together.

```py
label_group = DrawableGroup(
    elements=[
        // list of drawable elements
    ]
)
```

    - You can also compose multiple animation together so that you can add them into scene once, and they applies one after another or parallel depending on the time specifications.

```py
scene.add(
    CompositeAnimationEvent(
        events=[
            SketchAnimation(start_time=10.5, duration=1),
            ZoomOutAnimation(start_time=11.5, duration=2),
            TranslateToAnimation(
                start_time=11.5, duration=2, data={"point": a_sq_label.position}
            ),
        ]
    ),
    drawable=label_group,
)
```


Here is the description of the scene for which you need to generate the reproducible code using `handanim`.

Description: {scene_description}