)


async def get_token(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
    return token


app = FastAPI(dependencies=[Depends(get_token)])


@app.get("/")
async def root():
    return {"message": "Hello World"}


@app.get(
    "/with-oauth2-scheme",
    dependencies=[Security(oauth2_scheme, scopes=["read", "write"])],
)
async def read_with_oauth2_scheme():

import java.security.cert.X509Certificate
import java.util.ArrayDeque
import java.util.Deque
import javax.net.ssl.SSLPeerUnverifiedException

/**
 * A certificate chain cleaner that uses a set of trusted root certificates to build the trusted
 * chain. This class duplicates the clean chain building performed during the TLS handshake. We
 * prefer other mechanisms where they exist, such as with

    @Test
    void testCauseConstructor() {
        // Test the constructor with a cause argument
        Throwable cause = new RuntimeException("Root cause");
        RequestTimeoutException exception = new RequestTimeoutException(cause);
        assertEquals("java.lang.RuntimeException: Root cause", exception.getMessage(), "Message should be derived from the cause");

    /**
     * Gets the root directory of the project, which is the parent directory
     * containing the {@code .mvn} directory or flagged with {@code root="true"}.
     *
     * @return the root directory of the project
     * @throws IllegalStateException if the root directory could not be found
     * @see Session#getRootDirectory()
     */
    @Nonnull
    Path getRootDirectory();

    /**

     */
    public TransportException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**
     * Gets the root cause of this exception.
     * @return root cause of this exception
     */
    @Deprecated
    public Throwable getRootCause() {
        return getCause();
    }

            DslDocModel model = createDslDocModelClosure(loadPluginsMetaData())
            def root = doc.documentElement
            root.section.table.each { Element table ->
                mergeContent(table, model)
            }
            model.classes.each {
                generateDocForType(root.ownerDocument, model, linkRepository, it)
            }
        }

        // Create a root cause exception
        RuntimeException rootCause = new RuntimeException("Root cause error");
        TransportException exception = new TransportException(rootCause);

        // Verify the exception has the correct cause
        assertNotNull(exception);
        assertEquals(rootCause, exception.getCause());
        assertEquals("java.lang.RuntimeException: Root cause error", exception.getMessage());

				wg.Wait()
				// Flatten for upstream, but save full state.
				var root dataUsageEntry
				if r := cache.root(); r != nil {
					root = cache.flatten(*r)
				}
				select {
				case <-ctx.Done():
					return
				case bucketResults <- dataUsageEntryInfo{
					Name:   cache.Info.Name,
					Parent: dataUsageRoot,
					Entry:  root,
				}:
				}

				// Save cache

import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.WebResource;
import org.apache.catalina.webresources.StandardRoot;

/**
 * Fess-specific web resource root implementation for Tomcat.
 * This class extends StandardRoot to provide custom web resource handling
 * for Fess plugins, including support for plugin JAR files in the WEB-INF/plugin directory.
 */

    // https://www.jetbrains.com/help/teamcity/2022.04/configuring-schedule-triggers.html#general-syntax-1
    // We want it to be triggered only when there're pending changes in the specific vcs root, i.e. GradleMaster/GradleRelease
    triggerRules = "+:root=${branch.vcsRootId()}:."
    branchFilter = "+:<default>"
}

class PublishNightlySnapshot(
    branch: VersionedSettingsBranch,
) : PublishGradleDistributionFullBuild(