docs: def _split_fit_score_trial(self, X, y, idx=0):
          """
          Splits the dataset, fits a clone of the estimator, then scores it
          according to the required metrics.
  
          The index of the split is added to the random_state if the
          random_state is not None; this ensures that every split is shuffled
          differently but in a deterministic fashion for testing purposes.
          """
          random_state = self.random_state
          if random_state is not None:
              random_state += idx
  
          splitter = self._check_cv(self.cv, random_state)
  
          for train_index, test_index in splitter.split(X, y):
              # Safe indexing handles multiple types of inputs including
              # DataFrames and structured arrays - required for generic splits.
              X_train = safe_indexing(X, train_index)
              y_train = safe_indexing(y, train_index)
              X_test = safe_indexing(X, test_index)
              y_test = safe_indexing(y, test_index)
  
              model = clone(self.estimator)
              model.fit(X_train, y_train)
  
              if hasattr(model, "predict_proba"):
                  # Get the probabilities for the positive class
                  y_scores = model.predict_proba(X_test)[:,1]
              else:
                  # Use the decision function to get the scores
                  y_scores = model.decision_function(X_test)
  
              # Compute the curve metrics and thresholds
              curve_metrics = precision_recall_curve(y_test, y_scores)
              precision, recall, thresholds = curve_metrics
  
              # Compute the F1 score from precision and recall
              # Don't need to warn for F, precision/recall would have warned
              with np.errstate(divide='ignore', invalid='ignore'):
                  beta = self.fbeta ** 2
                  f_score = ((1 + beta) * precision * recall /
                     (beta * precision + recall))
  
              # Ensure thresholds ends at 1
              thresholds = np.append(thresholds, 1)
  
              # Compute the queue rate
              queue_rate = np.array([
                  (y_scores >= threshold).mean()
                  for threshold in thresholds
              ])
  
              yield {
                  'thresholds': thresholds,
                  'precision': precision,
                  'recall': recall,
                  'fscore': f_score,
                  'queue_rate': queue_rate
              }