code: def demo(n: int = 100) -> hip.Experiment:
      xp = hip.Experiment()
      xp.display_data(hip.Displays.XY).update(
          {
              "axis_x": "time",
              "axis_y": "exp_metric",
          }
      )
  
      # Some fake PBT-ish data
      def fake_params() -> t.Dict[str, hip.DisplayableType]:
          r = random.random()
          p: t.Dict[str, hip.DisplayableType] = {
              "lr": 10 ** random.uniform(-5, 0),
              "seed": random.uniform(0, 10),
              "name": uuid.uuid4().hex[:6],
              "optimizer": random.choice(["sgd", "adam", "adamw"]),
              "r": r,
              "c": random.choice(["red", "green", "black"]),
          }
          if r < 0.1:
              del p["optimizer"]
          if r > 0.3:
              p["optionA"] = random.uniform(1, 5)
          else:
              p["optionB"] = random.uniform(1, 5)
  
          if r < 0.2:
              p["pctile"] = -1.0
          elif r < 0.5:
              p["pctile"] = random.uniform(-1.0, 10.0)
          elif r < 0.8:
              p["pctile"] = 10 ** random.uniform(1, 2)
          else:
              p["pctile"] = random.uniform(100, 101)
  
          if random.random() > 0.3:
              p["special_values"] = random.uniform(1, 5)
          else:
              p["special_values"] = random.choice(
                  [math.inf, -math.inf, math.nan]
              )
          return p
  
      def fake_metrics(tm: float) -> t.Dict[str, hip.DisplayableType]:
          return {
              "exp_metric": 10 ** random.uniform(-5, 0),
              "pct_success": random.uniform(10, 90),
              "chkpt": uuid.uuid4().hex[:6],
              "time": tm + random.uniform(-0.2, 0.2),
              "force_numericlog": random.uniform(1, 100),
              "timestamp": int(time.time() + (task_idx * 2000)),
          }
  
      current_pop: t.List[t.Dict[str, t.Any]] = [
          dict(uid=f"init{i}", params=fake_params(), last_ckpt_uid=None)
          for i in range(10)
      ]
      continue_num = 0
      for task_idx in range(n):
          # All drop checkpoints
          for p in current_pop:
              ckpt_uid = f"{p['uid']}_{uuid.uuid4().hex[:6]}"
              xp.datapoints.append(
                  hip.Datapoint(
                      uid=ckpt_uid,
                      from_uid=p["last_ckpt_uid"],
                      values={**p["params"], **fake_metrics(task_idx)},
                  )
              )
              p["last_ckpt_uid"] = ckpt_uid
  
          # Randomly drop some
          current_pop = [
              p for p in current_pop if random.random() > 0.3
          ]
  
          # Respawn as needed
          for _ in range(10 - len(current_pop)):
              continue_num += 1
              parent = random.choice(xp.datapoints[-10:])
              current_pop.append(
                  dict(
                      uid=f"continue{continue_num}",
                      params=fake_params(),
                      last_ckpt_uid=parent.uid,
                  )
              )
      xp.parameters_definition["c"].colors = {
          "red": "rgb(255, 0, 0)",
          "green": "rgb(0, 255, 0)",
          "black": "rgb(0, 0, 0)",
      }
      xp.parameters_definition[
          "force_numericlog"
      ].type = hip.ValueType.NUMERIC_LOG
      xp.parameters_definition[
          "pctile"
      ].type = hip.ValueType.NUMERIC_PERCENTILE
      xp.parameters_definition[
          "timestamp"
      ].type = hip.ValueType.TIMESTAMP
      return xp
  
imports: import uuid
  import random
  import math
  import time
  import typing
  from .None import experiment
label_desc: Use image node_id 5 for calling a global function with example usage: demo(n) and returns: xp, p, dict