code: def createParameterEditor(self, parameter, index):
      title = urwid.Text(parameter.name)
  
      shouldLock = urwid.Button("Lock")
      urwid.connect_signal(
          shouldLock,
          "click",
          lambda button: self.lockParameter(parameter, index),
      )
      shouldScramble = urwid.Button("Scramble")
      urwid.connect_signal(
          shouldScramble,
          "click",
          lambda button: self.scrambleParameter(parameter, index),
      )
      shouldRelearn = urwid.Button("Relearn")
      urwid.connect_signal(
          shouldRelearn,
          "click",
          lambda button: self.refitParameter(parameter, index),
      )
  
      best = None
      if self.optimizer.best and parameter.name in self.optimizer.best:
          best = urwid.Text(
              "Best: " + str(self.optimizer.best[parameter.name])
          )
      else:
          best = urwid.Text("Not in best")
  
      minEdit = urwid.Edit()
      minLabel = urwid.Text("Min")
      maxEdit = urwid.Edit()
      maxLabel = urwid.Text("Max")
      minEdit.set_edit_text(str(parameter.config["min"]))
      maxEdit.set_edit_text(str(parameter.config["max"]))
      rangeArea = urwid.Columns([minLabel, minEdit, maxLabel, maxEdit])
      self.parameterMinEdits[parameter.name] = minEdit
      self.parameterMaxEdits[parameter.name] = maxEdit
      urwid.connect_signal(
          minEdit,
          "postchange",
          lambda button, value: self.updateMin(parameter),
      )
      urwid.connect_signal(
          maxEdit,
          "postchange",
          lambda button, value: self.updateMax(parameter),
      )
  
      edit = None
      self.parameterLockedValueEdits[parameter.name] = urwid.Edit()
      self.statusLabels[parameter.name] = urwid.Text("")
      status = self.statusLabels[parameter.name]
      found = False
      if not found:
          for lockedParam in self.guidanceOptions["lockedParameters"]:
              if lockedParam["variable"] == parameter.name:
                  status.set_text(
                      "Locked to " + str(lockedParam["value"])
                  )
                  edit = self.parameterLockedValueEdits[parameter.name]
                  edit.set_edit_text(str(lockedParam["value"]))
                  shouldLock = urwid.Button("Unlock")
                  urwid.connect_signal(
                      shouldLock,
                      "click",
                      lambda button: self.cancelSpecialsOnParameter(
                          parameter, index
                      ),
                  )
      if not found:
          for refitParam in self.guidanceOptions["refitParameters"]:
              if refitParam["variable"] == parameter.name:
                  status.set_text(
                      "Refitting from trial "
                      + str(refitParam["refitStartTrial"])
                  )
                  shouldRelearn = urwid.Button("Stop Relearning")
                  urwid.connect_signal(
                      shouldRelearn,
                      "click",
                      lambda button: self.cancelSpecialsOnParameter(
                          parameter, index
                      ),
                  )
      if not found:
          for refitParam in self.guidanceOptions["scrambleParameters"]:
              if refitParam["variable"] == parameter.name:
                  status.set_text("Scrambling (random searching)")
                  shouldScramble = urwid.Button("Stop Scrambling")
                  urwid.connect_signal(
                      shouldScramble,
                      "click",
                      lambda button: self.cancelSpecialsOnParameter(
                          parameter, index
                      ),
                  )
  
      if edit is None:
          edit = urwid.Text("")
  
      if status is None:
          status = urwid.Text("")
  
      urwid.connect_signal(
          self.parameterLockedValueEdits[parameter.name],
          "postchange",
          lambda button, value: self.updateLockValue(parameter, index),
      )
  
      return urwid.Columns(
          [
              urwid.Columns(
                  [
                      ("pack", title),
                      ("pack", urwid.Text("      ")),
                      ("pack", best),
                  ]
              ),
              rangeArea,
              urwid.Columns([("pack", status), ("pack", edit)]),
              urwid.Columns(
                  [shouldLock, shouldScramble, shouldRelearn]
              ),
          ]
      )
  
imports: import urwid
  import urwid.html_fragment
  from pprint import pformat
  import numpy
  import sys
  import os.path
  import csv
  import yaml
  import math
  import copy
  import datetime
  import json
  from panwid import DataTable, DataTableColumn
  from hypermax.hyperparameter import Hyperparameter
label_desc: Use image node_id 2 for calling the HumanGuidancePopup obj's underlying member method code with example usage: obj.createParameterEditor(parameter, index) and returns: urwid