set -exo pipefail
cd "$(dirname "$0")/../../"  # tensorflow/
# Any request that includes "nightly_upload" should just use the
# local multi-cache (public read-only cache + disk cache) instead.
export TFCI="$(echo $TFCI | sed 's/,nightly_upload/,public_cache,disk_cache/')"
if [[ -n "${TF_ANY_EXTRA_ENV:-}" ]]; then
  export TFCI="$TFCI,$TF_ANY_EXTRA_ENV"
fi
if [[ -n "${TF_ANY_SCRIPT:-}" ]]; then
  "$TF_ANY_SCRIPT"

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:5.3.0")
```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())

 * the License.
 */

package com.google.common.cache;

import com.google.common.annotations.GwtCompatible;

/**
 * Calculates the weights of cache entries.
 *
 * @author Charles Fry
 * @since 11.0
 */
@GwtCompatible
public interface Weigher<K, V> {

  /**
   * Returns the weight of a cache entry. There is no unit for entry weights; rather they are simply
   * relative to each other.

 */
package okhttp3.recipes.kt

import java.io.File
import java.io.IOException
import okhttp3.Cache
import okhttp3.OkHttpClient
import okhttp3.Request

class CacheResponse(
  cacheDirectory: File,
) {
  private val client: OkHttpClient =
    OkHttpClient
      .Builder()
      .cache(
        Cache(
          directory = cacheDirectory,
          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,

    /// note

    The `--no-cache-dir` is only related to `pip`, it has nothing to do with Docker or containers.

    ///

    The `--upgrade` option tells `pip` to upgrade the packages if they are already installed.

    Because the previous step copying the file could be detected by the **Docker cache**, this step will also **use the Docker cache** when available.

        assertUniqueKey(key);

        CacheRecord record = new CacheRecord(Collections.unmodifiableList(new ArrayList<>(pluginArtifacts)));

        cache.put(key, record);

        return record;
    }

    protected void assertUniqueKey(Key key) {
        if (cache.containsKey(key)) {
            throw new IllegalStateException("Duplicate artifact resolution result for plugin " + key);
        }
    }

 */
package okhttp3.internal

import okhttp3.Cache
import okhttp3.Dispatcher
import okhttp3.Response
import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache = Cache(fileSystem, file, maxSize)

      - name: Set up Python
        uses: actions/setup-python@v6
        with:
          python-version: "3.10"
          # Issue ref: https://github.com/actions/setup-python/issues/436
          # cache: "pip"
          # cache-dependency-path: pyproject.toml
      - name: Install build dependencies
        run: pip install build
      - name: Build distribution
        env:
          TIANGOLO_BUILD_PACKAGE: ${{ matrix.package }}

	workers *ActiveWorkerStat
	// queue stats cache
	qCache queueCache

	pCache proxyStatsCache
	// mrf backlog stats
	mrfStats ReplicationMRFStats
	// for bucket replication, continue to use existing cache
	Cache             map[string]*BucketReplicationStats
	mostRecentStats   BucketStatsMap
	registry          metrics.Registry
	sync.RWMutex                 // mutex for Cache
	mostRecentStatsMu sync.Mutex // mutex for mostRecentStats

		case "Deleted":
			z.Deleted, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Deleted")
				return
			}
		case "Cached":
			z.Cached, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Cached")
				return
			}
		case "NoMetadata":
			z.NoMetadata, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NoMetadata")