)
  print('=== Updated QuantizationConfig ===')
  print(config)

  if not (
      _has_quantization_method(config.specs, 'static_range_ptq')
      and len(config.calibration_options.representative_datasets) == 1
  ) and not _has_quantization_method(config.specs, 'weight_only_ptq'):
    raise ValueError(
        '`quantize_saved_model` currently only supports static-range PTQ with a'

        "//tensorflow/python:__pkg__",
    ],
    licenses = ["notice"],
)

# copybara:uncomment_begin(google-only)
# tf_py_strict_test(
#     name = "tensorflow_to_stablehlo_test",
#     testonly = 1,
#     srcs = ["integration_test/tensorflow_to_stablehlo_test.py"],
#     deps = [
#         ":pywrap_tensorflow_to_stablehlo",
#         "//testing/pymocks:matchers",
#         "//third_party/py/mlir",

type Reader struct {
	r     *bufio.Reader
	v     version.Version
	specs []event.Spec
}

// NewReader creates a new reader for the trace wire format.
func NewReader(r io.Reader) (*Reader, error) {
	br := bufio.NewReader(r)
	v, err := version.ReadHeader(br)
	if err != nil {
		return nil, err
	}
	return &Reader{r: br, v: v, specs: v.Specs()}, nil
}

// Version returns the version of the trace that we're reading.

 */
package org.gradle.api.internal.project.taskfactory;

import org.gradle.api.Task;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.specs.Specs;
import org.gradle.internal.instantiation.InstantiationScheme;
import org.gradle.internal.reflect.Instantiator;

import javax.annotation.Nullable;

/**

        List<String> callInterceptorTypes = new ArrayList<>();
        CallInterceptorSpecs specs = GroovyClassGeneratorUtils.groupRequests(filteredRequests);
        specs.getNamedRequests().forEach(spec -> callInterceptorTypes.add(spec.getFullClassName()));
        specs.getConstructorRequests().forEach(spec -> callInterceptorTypes.add(spec.getFullClassName()));

 * limitations under the License.
 */
package org.gradle.api.specs;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;

public class NotSpecTest {
    @Test
    public void testIsSatisfiedBy() {
        assertThat(new org.gradle.api.specs.NotSpec(createFilterSpec()).isSatisfiedBy(true), equalTo(false));

        ":friends",
    ],
)

package_group(
    name = "friends",
    packages = [
        "//tensorflow/compiler/mlir/lite/...",
    ],
)

tf_cc_binary(
    name = "odml-converter",
    srcs = ["odml_converter_main.cc"],
    compatible_with = get_compatible_with_portable(),
    visibility = [
        "//tensorflow/compiler/mlir/lite/stablehlo/odml_converter:__subpackages__",

)

# Run this binary manually, with an argument pointing to the testdata/
# directory, to generate the test files used by the filegroup rule below.
py_strict_binary(
    name = "gen_saved_models",
    srcs = ["gen_saved_models.py"],
    python_version = "PY3",
    deps = [
        "//tensorflow/python/compat:v2_compat",
        "//tensorflow/python/eager:def_function",
        "//tensorflow/python/framework:constant_op",

cc_library(
    name = "tensor_types_test_util",
    testonly = True,
    hdrs = ["tensor_types_test_util.h"],
    deps = [
        "//tensorflow/c:tf_datatype",
    ],
)

tf_cc_test(
    name = "tensor_test",
    srcs = [
        "tensor_test.cc",
    ],
    deps = [
        ":tensor_types_test_util",
        "//tensorflow/c:tf_datatype",
        "//tensorflow/cc/experimental/base/public:status",

    ]) + if_google([
        "//tensorflow/core/platform/default/build_config:test_main",
    ]),
)

filegroup(
    name = "quantize_header",
    srcs = ["quantize.h"],
    visibility = ["//visibility:public"],
)

cc_library(
    name = "tfcompile_lib",
    srcs = [
        "codegen.cc",
        "compile.cc",
        "flags.cc",
    ],
    hdrs = [
        "codegen.h",
        "compile.h",