Fix duplicated code from an example above

app/src/content/article.mdx

@@ -220,56 +220,119 @@ Record a Dataset
 [https://github.com/fracapuano/robot-learning-tutorial/blob/main/snippets/ch1/02_record_data.py](https://github.com/fracapuano/robot-learning-tutorial/blob/main/snippets/ch1/02_record_data.py)
 
 ```python
-import torch
+"""
+You can also use the CLI to record data. To see the required arguments, run:
+lerobot-record --help
+"""
+from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.streaming_dataset import StreamingLeRobotDataset
-
-delta_timestamps = {
-    "observation.images.wrist_camera": [-0.2, -0.1, 0.0]  # 0.2, and 0.1 seconds *before* each frame
+from lerobot.datasets.utils import hw_to_dataset_features
+from lerobot.robots.so100_follower import SO100Follower, SO100FollowerConfig
+from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
+from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
+from lerobot.utils.control_utils import init_keyboard_listener
+from lerobot.utils.utils import log_say
+from lerobot.utils.visualization_utils import init_rerun
+from lerobot.scripts.lerobot_record import record_loop
+
+NUM_EPISODES = 5
+FPS = 30
+EPISODE_TIME_SEC = 60
+RESET_TIME_SEC = 10
+TASK_DESCRIPTION = ...  # provide a task description
+
+HF_USER = ...  # provide your Hugging Face username
+
+follower_port = ...  # find your ports running: lerobot-find-port
+leader_port = ...
+follower_id = ...  # to load the calibration file
+leader_id = ...
+
+# Create the robot and teleoperator configurations
+camera_config = {"front": OpenCVCameraConfig(
+    index_or_path=0, width=640, height=480, fps=FPS)
 }
-
-# Optionally, use StreamingLeRobotDataset to avoid downloading the dataset
-dataset = LeRobotDataset(
-    "lerobot/svla_so101_pickplace",
-    delta_timestamps=delta_timestamps
+robot_config = SO100FollowerConfig(
+    port=follower_port,
+    id=follower_id,
+    cameras=camera_config
 )
-
-# Streams frames from the Hugging Face Hub without loading into memory
-streaming_dataset = StreamingLeRobotDataset(
-    "lerobot/svla_so101_pickplace",
-    delta_timestamps=delta_timestamps
+teleop_config = SO100LeaderConfig(
+    port=leader_port, 
+id=leader_id
 )
 
-# Get the 100th frame in the dataset by 
-sample = dataset[100]
-print(sample)
-# {
-# 'observation.state': tensor([...]), 
-# 'action': tensor([...]), 
-# 'observation.images.wrist_camera': tensor([3, C, H, W]), for delta timesteps
-# ...
-# }
-
-batch_size=16
-# wrap the dataset in a DataLoader to use process it batches for training purposes
-data_loader = torch.utils.data.DataLoader(
-    dataset,
-    batch_size=batch_size
+# Initialize the robot and teleoperator
+robot = SO100Follower(robot_config)
+teleop = SO100Leader(teleop_config)
+
+# Configure the dataset features
+action_features = hw_to_dataset_features(robot.action_features, "action")
+obs_features = hw_to_dataset_features(robot.observation_features, "observation")
+dataset_features = {**action_features, **obs_features}
+
+# Create the dataset where to store the data
+dataset = LeRobotDataset.create(
+    repo_id=f"{HF_USER}/robot-learning-tutorial-data",
+    fps=FPS,
+    features=dataset_features,
+    robot_type=robot.name,
+    use_videos=True,
+    image_writer_threads=4,
 )
 
-# Iterate over the DataLoader in a training loop
-num_epochs = 1
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-for epoch in range(num_epochs):
-    for batch in data_loader:
-        # Move data to the appropriate device (e.g., GPU)
-        observations = batch["observation.state"].to(device)
-        actions = batch["action"].to(device)
-        images = batch["observation.images.wrist_camera"].to(device)
-
-        # Next, you can do amazing_model.forward(batch)
-        ...
+# Initialize the keyboard listener and rerun visualization
+_, events = init_keyboard_listener()
+init_rerun(session_name="recording")
+
+# Connect the robot and teleoperator
+robot.connect()
+teleop.connect()
+
+episode_idx = 0
+while episode_idx < NUM_EPISODES and not events["stop_recording"]:
+    log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")
+
+    record_loop(
+        robot=robot,
+        events=events,
+        fps=FPS,
+        teleop=teleop,
+        dataset=dataset,
+        control_time_s=EPISODE_TIME_SEC,
+        single_task=TASK_DESCRIPTION,
+        display_data=True,
+    )
+
+    # Reset the environment if not stopping or re-recording
+    if (not events["stop_recording"]) and \
+        (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
+        log_say("Reset the environment")
+        record_loop(
+            robot=robot,
+            events=events,
+            fps=FPS,
+            teleop=teleop,
+            control_time_s=RESET_TIME_SEC,
+            single_task=TASK_DESCRIPTION,
+            display_data=True,
+        )
+
+    if events["rerecord_episode"]:
+        log_say("Re-recording episode")
+        events["rerecord_episode"] = False
+        events["exit_early"] = False
+        dataset.clear_episode_buffer()
+        continue
+
+    dataset.save_episode()
+    episode_idx += 1
+
+# Clean up
+log_say("Stop recording")
+robot.disconnect()
+teleop.disconnect()
+dataset.push_to_hub()
 ```
 
 </div>