}
```

Maven and JVM Projects
----------------------

OkHttp is published as a Kotlin Multiplatform project. While Gradle handles this automatically,
Maven projects must select between `okhttp-jvm` and `okhttp-android`. The `okhttp` artifact will be empty in
Maven projects.

```xml
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.squareup.okhttp3</groupId>

│   ├── main.py
└── static/
```

### Download the files { #download-the-files }

Download the static files needed for the docs and put them on that `static/` directory.

You can probably right-click each link and select an option similar to "Save link as...".

**Swagger UI** uses the files:

* <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js" class="external-link" target="_blank">`swagger-ui-bundle.js`</a>

import java.math.RoundingMode;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.jspecify.annotations.Nullable;

/**
 * An accumulator that selects the "top" {@code k} elements added to it, relative to a provided
 * comparator. "Top" can mean the greatest or the lowest elements, specified in the factory used to
 * create the {@code TopKSelector} instance.
 *

            if (os ==
                Os.WINDOWS
            ) {
                "\npowershell -Command \"Get-CimInstance -ClassName Win32_Process -Filter \\\"Name = 'java.exe'\\\" | Select-Object ProcessId, Name, CommandLine | Format-List\""
            } else {
                ""
            }
        skipConditionally(buildType)

        // This should always return at least the TCP fallback provider
        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();
        assertNotNull(provider, "Should always select an RDMA provider (at minimum TCP fallback)");
        assertNotNull(provider.getProviderName(), "Provider name should not be null");
        assertNotNull(provider.getSupportedCapabilities(), "Supported capabilities should not be null");

}

// Reader to read random data.
type netperfReader struct {
	n   uint64
	eof chan struct{}
	buf []byte
}

func (m *netperfReader) Read(b []byte) (int, error) {
	select {
	case <-m.eof:
		return 0, io.EOF
	default:
	}
	n := copy(b, m.buf)
	atomic.AddUint64(&m.n, uint64(n))
	return n, nil
}

	"github.com/minio/minio/internal/logger"
	"github.com/minio/minio/internal/once"
	"github.com/minio/minio/internal/store"
	xnet "github.com/minio/pkg/v3/net"
)

const (
	mysqlTableExists = `SELECT 1 FROM %s;`
	// Some MySQL has a 3072 byte limit on key sizes.
	mysqlCreateNamespaceTable = `CREATE TABLE %s (
             key_name VARCHAR(3072) NOT NULL,

        } catch (Exception e) {
            sessionChannels.remove(sessionId);
            throw new CIFSException("Failed to create channels for session " + sessionId, e);
        }
    }

    /**
     * Selects the best channel for an operation.
     *
     * @param sessionId the session identifier
     * @return the selected channel, or null if no channels available
     */

### Ler Heroes { #read-heroes }

Podemos **ler** `Hero`s do banco de dados usando um `select()`. Podemos incluir um `limit` e `offset` para paginar os resultados.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[48:55] hl[51:52,54] *}

### Ler um Único Hero { #read-one-hero }

	const bucketMetadataRefresh = 15 * time.Minute

	sleeper := newDynamicSleeper(2, 150*time.Millisecond, false)

	t := time.NewTimer(bucketMetadataRefresh)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-t.C:
			buckets, err := sys.objAPI.ListBuckets(ctx, BucketOptions{NoMetadata: true})
			if err != nil {
				internalLogIf(ctx, err, logger.WarningKind)
				break