CreateExportedModel(signature_keys, tags, quantization_config,
                          WeightOnlyPtqComponent::kName, *function_aliases,
                          *ctx, *module));

  // Remove the `tpu` tag for exporting because the output quantized model is
  // essentially a CPU model.
  tags.erase("tpu");

  py_function_library.SaveExportedModel(
      dst_saved_model_path, post_calibrated_exported_model,

 *
 * These extension functions allow an interface to implement a dependencies block in the Kotlin DSL by
 * - exposing an instance of [DependencyCollector] to add dependencies without explicitly calling [DependencyCollector.add] or [DependencyCollector.addConstraint]
 * - exposing an instance of [DependencyModifier] to modify dependencies without explicitly calling [DependencyModifier.modify]
 *

    const xla::LocalExecutable& executable) {
  if (executable.executable() == nullptr) {
    return errors::FailedPrecondition(
        "Executable not found for serialization.");
  }

  VLOG(1)
      << "Exporting xla::LocalExecutable as an xla::AotCompilationResult and "
         "serializing it to string.";
  xla::Compiler* compiler = client_->backend().compiler();
  auto exported = compiler->Export(executable.executable());

semantics of the WeakReference type.

Using go:linkname to access this package and the functions it references
is explicitly forbidden by the toolchain because the semantics of this
package have not gone through the proposal process. By exposing this
functionality, we risk locking in the existing semantics due to Hyrum's Law.

If you believe you have a good use-case for weak references not already
covered by the standard library, file a proposal issue at

  <modelVersion>4.0.0</modelVersion>
  <groupId>com.gradle.tutorial</groupId>
  <artifactId>tutorial</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>
</project>
----

== Step 5. Exploring Plugins
Plugins are used to extend build capability and customize Gradle.

Using plugins is the **primary mechanism for organizing build logic**.

 * As such, these objects should be designed for serialization to non Java formats (e.g. JSON).
 *
 * - Should be practically immutable
 * - Should only expose primitive(ish) JDK types, or other structured types only exposing JDK types
 * - Collection like structures should have deterministic order - either sorted, or meaningful
 * - Should expose either java.util.List or java.util.Map over specialised collection types
 *

<<part2_gradle_tasks#part2_begin,Part 2.>> Running Tasks +
<<part3_gradle_dep_man#part3_begin,Part 3.>> Understanding Dependencies +
<<part4_gradle_plugins#part4_begin,Part 4.>> Applying Plugins +
<<part5_gradle_inc_builds#part5_begin,Part 5.>> Exploring Incremental Builds +
<<part6_gradle_caching#part6_begin,Part 6.>> Enabling the Cache +

            // However, this property is mostly an accident of the way this classpath entry was produced.
            // Exposing it may put unnecessary burden on clients if, for example, they try to keep the compression method
            // while repackaging entries.
            return CompressionMethod.UNDEFINED;
        }
    }

        failure.assertHasDescription("Execution failed for task ':grammar-builder:generateGrammarSource'.")
        failure.assertHasCause("There were errors during grammar generation")
        failure.assertHasCause("ANTLR Panic: Exiting due to errors.")
    }

    def "uses antlr v2 if no explicit dependency is set"() {
        buildFile.text = buildFile.text.replace("antlr '$antlrDependency'", "")

        goodGrammar()
        goodProgram()

        then:
        def config = result().remote.config
        config.url == safeUri.toString() + '/'
        config.authenticated == "true"
    }

    def "--offline wins over DSL configuration when exposing remote enabled configuration"() {
        given:
        httpBuildCacheServer.start()
        def url = "${httpBuildCacheServer.uri}/"
        settingsFile << """
            buildCache {