- name: FastAPI-template
  html_url: https://github.com/s3rius/FastAPI-template
  stars: 2637
  owner_login: s3rius
  owner_html_url: https://github.com/s3rius
- name: YC-Killer
  html_url: https://github.com/sahibzada-allahyar/YC-Killer
  stars: 2599
  owner_login: sahibzada-allahyar
  owner_html_url: https://github.com/sahibzada-allahyar
- name: fastapi-react
  html_url: https://github.com/Buuntu/fastapi-react

            }
            return new SpnegoCredential(username[0]);
        }).orElse(null);

    }

    /**
     * SPNEGO filter configuration implementation.
     *
     * This inner class provides configuration parameters for the SPNEGO filter,
     * mapping system properties to SPNEGO configuration values. It handles
     * various authentication settings including Kerberos configuration,

// Handlers can use this to create a reusable response.
// The response may be reused, so caller should clear any fields.
func (h *SingleHandler[Req, Resp]) NewResponse() Resp {
	return h.newResp()
}

// NewRequest creates a new request.
// Handlers can use this to create a reusable request.
// The request may be reused, so caller should clear any fields.
func (h *SingleHandler[Req, Resp]) NewRequest() Req {
	return h.newReq()

	// Approx 49 days.
	MaxDeadline = time.Duration(math.MaxUint32) * time.Millisecond
)

// ContextDialer is a dialer that can be used to dial a remote.
type ContextDialer func(ctx context.Context, network, address string) (net.Conn, error)

// DialContext implements the Dialer interface.
func (c ContextDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
	return c(ctx, network, address)

				// concurrently, check for it before we
				// write the filler byte.
				select {
				case err := <-doneCh:
					if err != nil {
						write([]byte{1})
						write([]byte(err.Error()))
					} else {
						write([]byte{0})
					}
					return
				default:
				}

				// Response not ready, write a filler byte.
				write([]byte{32})
				if canWrite {
					xhttp.Flush(w)
				}

                persistResumptionData(result, session);
                return result;
            } else {
                session.getAllProjects().stream()
                        .filter(MavenProject::isExecutionRoot)
                        .findFirst()
                        .ifPresent(buildResumptionDataRepository::removeResumptionData);
            }
        } finally {
            try {

        assertEquals("junit-4.13.1.jar", modules.get(0).getFileName().toString());
        assertTrue(paths.containsAll(classes));
        assertTrue(paths.containsAll(modules));

        // If caller wants only a classpath, JUnit shall move there.
        dispatched = session.resolveDependencies(coords, PathScope.TEST_COMPILE, Arrays.asList(JavaPathType.CLASSES));
        classes = dispatched.get(JavaPathType.CLASSES);

	//
	// 1. If a writer.write() returns false, select loop below exits and
	// closes `doneCh` to indicate to caller to also exit.
	//
	// 2. If caller (Evaluate()) has an error, it sends an error
	// message and waits for this go-routine to quit in
	// FinishWithError()
	//
	// 3. If caller is done, it waits for this go-routine to exit
	// in Finish()

	quitFlag := false
	for !quitFlag {
		select {

    // In the process we made one successful connection attempt.
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectStart::class }).hasSize(2)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectFailed::class }).hasSize(1)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectEnd::class }).hasSize(1)
  }

  @Test
  fun reachesIpv6WhenIpv4IsDown() {
    serverIpv4.close()

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter}.
   */
  public static <T extends @Nullable Object> Iterable<T> filter(
      Iterable<T> unfiltered, Predicate<? super T> retainIfTrue) {
    checkNotNull(unfiltered);
    checkNotNull(retainIfTrue);
    return new FluentIterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return Iterators.filter(unfiltered.iterator(), retainIfTrue);
      }