*       stateless, and therefore thread-safe.
 *   <li><b>collision-averse:</b> while it can't be helped that a hash function will sometimes
 *       produce the same hash code for distinct inputs (a "collision"), every hash function strives
 *       to <i>some</i> degree to make this unlikely. (Without this condition, a function that
 *       always returns zero could be called a hash function. It is not.)
 * </ul>
 *

  private val postponedRoutes = mutableListOf<Route>()

  init {
    resetNextProxy(address.url, address.proxy)
  }

  /**
   * Returns true if there's another set of routes to attempt. Every address has at least one route.
   */
  operator fun hasNext(): Boolean = hasNextProxy() || postponedRoutes.isNotEmpty()

  @Throws(IOException::class)
  operator fun next(): Selection {

   * array nor its contents can be null, but it is not useful to force the use of {@code
   * requireNonNull} or the like just to assert that.
   *
   * <p>{@code EqualsTester} will always check that every object it is given returns false from
   * {@code equals(null)}, so it is neither useful nor allowed to include a null value in any
   * equality group.
   */
  @CanIgnoreReturnValue

And if you update that local FastAPI source code when you run that Python file again, it will use the fresh version of FastAPI you just edited.

That way, you don't have to "install" your local version to be able to test every change.

/// note | Technical Details

This only happens when you install using this included `requirements.txt` instead of running `pip install fastapi` directly.

 * of bugs and confusion.
 *
 * <h3>About <i>all</i> {@code Immutable-} collections</h3>
 *
 * <p>The remainder of this documentation applies to every public {@code Immutable-} type in this
 * package, whether it is a subtype of {@code ImmutableCollection} or not.
 *
 * <h4>Guarantees</h4>
 *
 * <p>Each makes the following guarantees:
 *
 * <ul>

      for (PerListenerQueue<L> queue : listeners) {
        queue.add(event, label);
      }
    }
  }

  /**
   * Dispatches all events enqueued prior to this call, serially and in order, for every listener.
   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions

   * callback has returned. Synchronous calls become idle once [execute()][Call.execute] returns.
   * This means that if you are doing synchronous calls the network layer will not truly be idle
   * until every returned [Response] has been closed.
   */
  @get:Synchronized
  @set:Synchronized
  var idleCallback: Runnable? = null

  private var executorServiceOrNull: ExecutorService? = null

        ALLOWS_NULL_KEYS);
  }

  /**
   * Map generator that verifies that {@code setUp()} methods are called in all the test cases. The
   * {@code setUpRan} parameter is set true by the {@code setUp} that every test case is supposed to
   * have registered, and set false by the {@code tearDown}. We use a dynamic proxy to intercept all
   * of the {@code Map} method calls and check that {@code setUpRan} is true.
   */

              AtomicIntegerFieldUpdater.class.getName(),
              AtomicReferenceFieldUpdater.class.getName()));

  public static TestSuite suite() {
    // we create a test suite containing a test for every FuturesTest test method and we
    // set it as the name of the test.  Then in runTest we can reflectively load and invoke the
    // corresponding method on FuturesTest in the correct classloader.

      while (iterator.hasNext()) {
        if (element.equals(iterator.next())) {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * Traverses an iterator and removes every element that belongs to the provided collection. The
   * iterator will be left exhausted: its {@code hasNext()} method will return {@code false}.
   *
   * @param removeFrom the iterator to (potentially) remove elements from