import okhttp3.Call;
import okhttp3.HttpUrl;

import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    Call call = OkHttpCaller.callOkHttp(HttpUrl.get("https://square.com/robots.txt"));

    System.out.println(call.execute().body().string());
  }

import okio.BufferedSource
import okio.Source
import okio.source
import org.brotli.dec.BrotliInputStream

object Brotli : CompressionInterceptor.DecompressionAlgorithm {
  override val encoding: String get() = "br"

  override fun decompress(compressedSource: BufferedSource): Source = BrotliInputStream(compressedSource.inputStream()).source()

    )


async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
    user = fake_decode_token(token)
    return user


@app.get("/users/me")
async def read_users_me(current_user: Annotated[User, Depends(get_current_user)]):

    pass


def get_username():
    try:
        yield "Rick"
    except InternalError:
        print("We don't swallow the internal error here, we raise again 😎")
        raise


@app.get("/items/{item_id}")
def get_item(item_id: str, username: str = Depends(get_username)):
    if item_id == "portal-gun":
        raise InternalError(
            f"The portal gun is too dangerous to be owned by {username}"

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * Just asserts that it's able to create those components. Handy when CDI container gets a nervous breakdown.
 *
 */
class LifecycleExecutorSubModulesTest extends AbstractCoreMavenComponentTestCase {
    @Inject
    private DefaultLifecycles defaultLifeCycles;

    @Inject

            throw new CrawlerSystemException("Extractor instance is null. Cannot register null extractor.");
        }
        if (extractorMap.containsKey(key)) {
            final Extractor[] existingExtractors = extractorMap.get(key);

            final Extractor[] newExtractors = new Extractor[existingExtractors.length + 1];
            System.arraycopy(existingExtractors, 0, newExtractors, 0, existingExtractors.length);

            }

            @Override
            public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
                    Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository) {
                throw new UnsupportedOperationException("Cannot get available versions in this test case");

      checkNotNull(event);
      checkNotNull(subscribers);
      // requireNonNull accommodates Android's @RecentlyNullable annotation on ThreadLocal.get
      Queue<Event> queueForThread = requireNonNull(queue.get());
      queueForThread.offer(new Event(event, subscribers));

      if (!dispatching.get()) {
        dispatching.set(true);
        try {
          Event nextEvent;
          while ((nextEvent = queueForThread.poll()) != null) {

from typing import Annotated

from fastapi import Depends, FastAPI
from fastapi.security import HTTPBasic, HTTPBasicCredentials

app = FastAPI()

security = HTTPBasic()


@app.get("/users/me")
def read_current_user(credentials: Annotated[HTTPBasicCredentials, Depends(security)]):

from typing import Annotated

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: Annotated[str, Query(min_length=3)]):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})