# This bazelrc can build a CPU-supporting TF package.

# Convenient cache configurations
# Use a cache directory mounted to /tf/cache. Very useful!
build:sigbuild_local_cache --disk_cache=/tf/cache
# Use the public-access TF DevInfra cache (read only)
build:sigbuild_remote_cache --remote_cache="https://storage.googleapis.com/tensorflow-devinfra-bazel-cache/manylinux2014" --remote_upload_local_results=false

platforms:
  - bt_ge_build_cache:
    name: 'bt_ge_build_cache'
    subprojects:
      - 'platforms/core-execution/build-cache/'
      - 'platforms/core-execution/build-cache-base/'
      - 'platforms/core-execution/build-cache-http/'
      - 'platforms/core-execution/build-cache-packaging/'
      - 'platforms/core-runtime/build-operations/'
      - 'platforms/core-runtime/files/'

      assertThat(response!!.networkResponse).isNull()
    }

  /** Asserts that the current response didn't use the cache.  */
  fun assertNoCacheResponse() =
    apply {
      assertThat(response!!.cacheResponse).isNull()
    }

  /**
   * Asserts that the current response used the cache and returns the cache response.
   */
  fun cacheResponse(): RecordedResponse {
    val cacheResponse = response!!.cacheResponse!!

FROM golang:1.21-alpine as build

ARG TARGETARCH
ARG RELEASE

ENV GOPATH /go
ENV CGO_ENABLED 0

# Install curl and minisign
RUN apk add -U --no-cache ca-certificates && \
    apk add -U --no-cache curl && \
    go install aead.dev/minisign/cmd/minisign@v0.2.1

# Download minio binary and signature file
RUN curl -s -q https://dl.min.io/server/minio/release/linux-${TARGETARCH}/archive/minio.${RELEASE} -o /go/bin/minio && \

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.cache

import java.io.IOException
import okio.Sink

interface CacheRequest {
  @Throws(IOException::class)
  fun body(): Sink

  fun abort()

            includeGroup("net.rubygrapefruit")
            includeModule("flot", "flot")
            includeModule("org.gradle", "gradle-tooling-api")
            includeModule("org.gradle.buildtool.internal", "configuration-cache-report")
            includeModule("org.gradle.buildtool.internal", "gradle-ide-starter")
        }
    }
    google {
        content {
            includeGroup("com.android.databinding")

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.psi.KtClassOrObject

//todo introduce LibraryModificationTracker based cache?
internal object FirSyntheticFunctionInterfaceSourceProvider {
    fun findPsi(fir: FirDeclaration): PsiElement? {
        return when (fir) {
            is FirSimpleFunction -> provideSourceForInvokeFunction(fir)

## Exécutez votre code avec votre <abbr title="En anglais: debugger">débogueur</abbr>

Parce que vous exécutez le serveur Uvicorn directement depuis votre code, vous pouvez appeler votre programme Python (votre application FastAPI) directement depuis le <abbr title="En anglais: debugger">débogueur</abbr>.

---

```Python hl_lines="22-24"
{!../../../docs_src/extending_openapi/tutorial001.py!}
```

### Zwischenspeichern des OpenAPI-Schemas

Sie können die Eigenschaft `.openapi_schema` als „Cache“ verwenden, um Ihr generiertes Schema zu speichern.

Auf diese Weise muss Ihre Anwendung das Schema nicht jedes Mal generieren, wenn ein Benutzer Ihre API-Dokumentation öffnet.

import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay

class RerunFlakyTest(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
    name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"
    description = "Allows you to rerun a selected flaky test 10 times"
    id(id)
    val testJvmVendorParameter = "testJavaVendor"