Verificamos que obtenemos un `username`, y extraemos los scopes.

Y luego validamos esos datos con el modelo de Pydantic (capturando la excepción `ValidationError`), y si obtenemos un error leyendo el token JWT o validando los datos con Pydantic, lanzamos la `HTTPException` que creamos antes.

Para eso, actualizamos el modelo de Pydantic `TokenData` con una nueva propiedad `scopes`.

            if (semaphoreAcquired) {
                requestSemaphore.release();
            }
        }
    }

    /**
     * Execute an operation with circuit breaker protection and custom error handling
     *
     * @param <T> return type
     * @param operation the operation to execute
     * @param isFailure custom failure detection
     * @return operation result

  }

  @Test
  fun setResponseMockReason() {
    val reasons =
      arrayOf<String?>(
        "Mock Response",
        "Informational",
        "OK",
        "Redirection",
        "Client Error",
        "Server Error",
        "Mock Response",
      )
    for (i in 0..599) {
      val builder = MockResponse.Builder().code(i)
      val expectedReason = reasons[i / 100]

            same[k] += 1;
          } else {
            diff[k] += 1;
          }
        }
      }
      // measure probability and assert it's within margin of error
      for (int j = 0; j < hashBits; j++) {
        double prob = (double) diff[j] / (double) (diff[j] + same[j]);
        assertThat(prob).isWithin(epsilon).of(0.50d);
      }
    }
  }

  /**

            same[k] += 1;
          } else {
            diff[k] += 1;
          }
        }
      }
      // measure probability and assert it's within margin of error
      for (int j = 0; j < hashBits; j++) {
        double prob = (double) diff[j] / (double) (diff[j] + same[j]);
        assertThat(prob).isWithin(epsilon).of(0.50d);
      }
    }
  }

  /**

            }

            bufferIndex += e.nextEntryOffset;
        }

        /* last nextEntryOffset for NT 4(but not 98) is 0 so we must
         * use dataCount or our accounting will report an error for NT :~(
         */

        //return bufferIndex - start;

        return dataCount;
    }

    @Override
    public String toString() {
        String c;

		return
	}

	vars := mux.Vars(r)
	bucket := vars["bucket"]

	var withUpdatedAt bool
	if updatedAtStr := r.Form.Get("withUpdatedAt"); updatedAtStr != "" {
		var err error
		withUpdatedAt, err = strconv.ParseBool(updatedAtStr)
		if err != nil {
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidLifecycleQueryParameter), r.URL)
			return
		}
	}

  }

  @Test fun cancelAllWhenEmptyDoesNotStartWorkerThread() {
    redQueue.execute("red task", 100.µs) {
      error("expected to be canceled")
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    blueQueue.execute("task", 100.µs) {
      error("expected to be canceled")
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    redQueue.cancelAll()

FastAPI will use this return type to:

* **Validate** the returned data.
    * If the data is invalid (e.g. you are missing a field), it means that *your* app code is broken, not returning what it should, and it will return a server error instead of returning incorrect data. This way you and your clients can be certain that they will receive the data and the data shape expected.
* Add a **JSON Schema** for the response, in the OpenAPI *path operation*.

   * non-null, it should be reported to the user should all further attempts fail.
   *
   * The two values are independent: results can contain both (recoverable error), neither
   * (success), just an exception (permanent failure), or just a plan (non-exceptional retry).
   */
  data class ConnectResult(
    val plan: Plan,
    val nextPlan: Plan? = null,