diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4363476..6fd62be 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -81,8 +81,6 @@
   option(IREE_BUILD_PYTHON_BINDINGS "Builds the IREE python bindings" OFF)
 endif()
 
-option(IREE_BUILD_OLD_PYTHON_COMPILER_API "Builds the original Python compiler API" ON)
-
 #-------------------------------------------------------------------------------
 # Experimental project flags
 #-------------------------------------------------------------------------------
@@ -560,5 +558,21 @@
     set(IREE_COMPILER_API_SUB_PROJECT ON)
     add_subdirectory(llvm-external-projects/iree-compiler-api
         "${CMAKE_CURRENT_BINARY_DIR}/compiler-api")
+
+    # Write out a .env file to make IDEs and developers happy.
+    # Yes, we are writing this to the source dir. It is only for IDEs and if
+    # it gets clobbered, it is fine.
+    set(_pythonpath_env "PYTHONPATH=$<SHELL_PATH:${CMAKE_CURRENT_BINARY_DIR}/compiler-api/python_package;${CMAKE_CURRENT_BINARY_DIR}/bindings/python>\n")
+    file(GENERATE OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/.env"
+      CONTENT "${_pythonpath_env}"
+    )
+    file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/.env"
+      CONTENT "${_pythonpath_env}"
+    )
+
+    # TODO: Remove this after about Dec-2021
+    if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/bindings/python/iree/compiler")
+      message(FATAL_ERROR "You are running in a build directory which needs some manual cleanup. Please delete the directory ${CMAKE_CURRENT_BINARY_DIR}/bindings/python/iree/compiler")
+    endif()
   endif()
 endif()
diff --git a/bindings/python/CMakeLists.txt b/bindings/python/CMakeLists.txt
index 92a2475..f019d28 100644
--- a/bindings/python/CMakeLists.txt
+++ b/bindings/python/CMakeLists.txt
@@ -12,11 +12,3 @@
 # Namespace packages.
 add_subdirectory(iree/runtime)
 add_subdirectory(iree/jax)
-
-if(IREE_BUILD_COMPILER AND IREE_BUILD_OLD_PYTHON_COMPILER_API)
-add_subdirectory(iree/compiler)
-add_subdirectory(iree/tools/core)
-endif()
-
-# Tests.
-add_subdirectory(tests)
diff --git a/bindings/python/iree/compiler/CMakeLists.txt b/bindings/python/iree/compiler/CMakeLists.txt
deleted file mode 100644
index 3543c1b..0000000
--- a/bindings/python/iree/compiler/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-iree_py_library(
-  NAME
-    compiler
-  SRCS
-    "__init__.py"
-    "core.py"
-    "debugging.py"
-    "tf.py"
-    "tflite.py"
-    "tools.py"
-    "xla.py"
-)
-
-iree_py_install_package(
-  COMPONENT IreePythonPackage-compiler
-  PACKAGE_NAME iree_compiler
-  MODULE_PATH iree/compiler
-  ADDL_PACKAGE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/README.md
-)
diff --git a/bindings/python/iree/compiler/README.md b/bindings/python/iree/compiler/README.md
deleted file mode 100644
index bd19d0b..0000000
--- a/bindings/python/iree/compiler/README.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# IREE Compiler Python Bindings
-
-## Core compiler
-
-```py
-import iree.compiler
-
-SIMPLE_MUL_ASM = """
-func @simple_mul(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>) -> tensor<4xf32> {
-    %0 = "mhlo.multiply"(%arg0, %arg1) {name = "mul.1"} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
-    return %0 : tensor<4xf32>
-}
-"""
-
-# Also see compile_file()
-# There are many keyword options available.
-# See iree.compiler.CompilerOptions
-binary = iree.compiler.compile_str(SIMPLE_MUL_ASM, target_backends=["vulkan-spirv"])
-```
-
-### Debugging
-
-A number of optional arguments to the compiler can be useful for debugging:
-
-* `extended_diagnostics=True` - Outputs verbose attached operations to
-  diagnostics. Can output a large volume of information.
-* `crash_reproducer_path=... some .mlir file path...` - On a crash or error,
-  a reproducer will be output at the listed path.
-* `extra_args=[...]` - Passes extra arguments to the compiler. Useful for
-  various standard features of MLIR based compilers like `-print-ir-after-all`.
-
-In addition, the core compiler and frontend compiler APIs have a unified
-mechanism for saving their temporary files, which are often useful for post
-mortem debugging. Since the need for this is often as part of a larger system,
-it is exposed both via an environment variable and an API.
-
-In order to save all temporaries and reproducers, set the `IREE_SAVE_TEMPS`
-environment variable to a directory in which to dump artifacts. For complex
-programs that invoke the compiler many times, it will typically be necessary
-to further qualify the path, and there are a few placeholders that will be
-expanded:
-
-* `{id}` - A per-process monotonically increasing number for each compiler
-  invocation. Can be overridden by the API if a better symbolic name is
-  available (i.e. test case, etc).
-* `{pid}` - Process ID of the current process.
-* `{main}` - Basename of `sys.argv[0]`, which is typically the name of the
-  Python main file.
-
-For interactive use, the following (on a Unix-like system) should provide
-value:
-
-```shell
-export IREE_SAVE_TEMPS="/tmp/ireedumps/{main}/{id}"
-```
-
-For the context manager based API, refer to the
-`iree.compiler.debugging.TempFileSaver` class.
-
-
-## TensorFlow compiler
-
-```py
-import tensorflow as tf
-import iree.compiler.tf
-
-class SimpleArithmeticModule(tf.Module):
-
-  @tf.function(input_signature=[
-      tf.TensorSpec([4], tf.float32),
-      tf.TensorSpec([4], tf.float32)
-  ])
-  def simple_mul(self, a, b):
-    return a * b
-
-# Also see compile_saved_model to directly compile an on-disk saved model.
-# There are many keyword options available.
-# See: iree.compiler.tf.ImportOptions
-binary = iree.compiler.tf.compile_module(
-    SimpleArithmeticModule(), target_backends=["vulkan-spirv"])
-```
diff --git a/bindings/python/iree/compiler/__init__.py b/bindings/python/iree/compiler/__init__.py
deleted file mode 100644
index 845bfc0..0000000
--- a/bindings/python/iree/compiler/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Lint-as: python3
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-from .core import *
-from .debugging import TempFileSaver
-from .tools import CompilerToolError
diff --git a/bindings/python/iree/compiler/core.py b/bindings/python/iree/compiler/core.py
deleted file mode 100644
index a6e6aad..0000000
--- a/bindings/python/iree/compiler/core.py
+++ /dev/null
@@ -1,252 +0,0 @@
-# Lint-as: python3
-"""Core compiler interface."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# TODO(#4131) python>=3.7: Use postponed type annotations.
-
-from enum import Enum
-import subprocess
-from typing import Any, Dict, List, Optional, Sequence, Union
-
-from .debugging import TempFileSaver
-from .tools import *
-
-__all__ = [
-    "DEFAULT_TESTING_BACKENDS",
-    "compile_file",
-    "compile_str",
-    "CompilerOptions",
-    "OutputFormat",
-]
-
-# Default testing backend for invoking the compiler.
-# TODO: Remove these. In the absence of default profiles, though, it is better
-# to centralize.
-DEFAULT_TESTING_BACKENDS = ["dylib-llvm-aot"]
-DEFAULT_TESTING_DRIVER = "dylib"
-
-
-class InputType(Enum):
-  """The type of input pipeline to run prior to the core compiler."""
-  NONE = "none"
-  MHLO = "mhlo"
-  TOSA = "tosa"
-
-  @staticmethod
-  def parse(spec: Union[str, "InputType"]) -> "InputType":
-    """Parses or returns an InputType.
-
-    Args:
-      spec: An InputType instance or the case-insensitive name of one of the
-        enum values.
-    Returns:
-      An InputType instance.
-    """
-    if isinstance(spec, InputType):
-      return spec
-    spec = spec.upper().replace("-", "_")
-    if spec not in InputType.__members__:
-      raise ValueError(f"For input_type= argument, expected one of: "
-                       f"{', '.join(InputType.__members__.keys())}")
-    return InputType[spec]
-
-
-class OutputFormat(Enum):
-  """The output format of the compiler."""
-  FLATBUFFER_BINARY = "flatbuffer-binary"
-  FLATBUFFER_TEXT = "flatbuffer-text"
-  MLIR_TEXT = "mlir-text"
-
-  @staticmethod
-  def parse(spec: Union[str, "OutputFormat"]) -> "OutputFormat":
-    """Parses or returns an OutputFormat.
-
-    Args:
-      spec: An OutputFormat instance or the case-insensitive name of one of
-        the enum values.
-    Returns:
-      An OutputFormat instance.
-    """
-    if isinstance(spec, OutputFormat):
-      return spec
-    spec = spec.upper().replace("-", "_")
-    if spec not in OutputFormat.__members__:
-      raise ValueError(f"For output_format= argument, expected one of: "
-                       f"{', '.join(OutputFormat.__members__.keys())}")
-    return OutputFormat[spec]
-
-
-# TODO(#4131) python>=3.7: Consider using a dataclass.
-class CompilerOptions:
-  """Options to the compiler backend.
-
-  Keyword options:
-    output_file: Optionally save the compiled binary to a file instead of
-      returning it.
-    target_backends: List of str names of target backends to compile into
-      the binary. The resulting binary will run on targets that match one
-      or more of the compiled backends.
-    input_type: The type of input legalization to perform prior to full
-      compilation. Defaults to none.
-    output_format: Override the output format. See the OutputFormat enum.
-      Values can either be an enum value or a case-insensitive name of
-      the option. Typically used for debugging
-    extra_args: Optional list of additional arguments to pass to the compiler.
-      Example: ["--print-ir-after-all"]
-    optimize: Whether to apply some default high level optimizations (default
-      True).
-    output_mlir_debuginfo: Include debuginfo (including paths) in any saved or
-      returned MLIR.
-    output_generic_mlir: Use the generic (and more portable) MLIR formatting for
-      any saved or returned MLIR instead of the per-dialect custom assembly.
-    extended_diagnostics: Outputs extended information on diagnostics,
-      potentially outputting very verbosely (defaults to False).
-    strip_debug_ops: Whether to strip high level operations used to aid
-      debugging.
-    strip_source_map: Whether to strip source map information (used to generate
-      better errors).
-    crash_reproducer_path: File name to output an MLIR crash dump to if there
-      is a compiler failure.
-    enable_tflite_bindings: Support the IREE TFLite runtime bindings API shim.
-    enable_benchmark: Whether to generate instrumented binaries suitable
-      for benchmarking.
-  """
-
-  def __init__(self,
-               *,
-               output_file: Optional[str] = None,
-               target_backends: Sequence[str] = (),
-               input_type: Union[InputType, str] = InputType.NONE,
-               output_format: Union[OutputFormat,
-                                    str] = OutputFormat.FLATBUFFER_BINARY,
-               extra_args: Sequence[str] = (),
-               optimize: bool = True,
-               output_mlir_debuginfo: bool = True,
-               output_generic_mlir: bool = False,
-               extended_diagnostics: bool = False,
-               strip_debug_ops: bool = False,
-               strip_source_map: bool = False,
-               crash_reproducer_path: Optional[str] = None,
-               enable_tflite_bindings: bool = False,
-               enable_benchmark: bool = False):
-    self.output_file = output_file
-    self.target_backends = target_backends
-    self.input_type = InputType.parse(input_type)
-    self.output_format = OutputFormat.parse(output_format)
-    self.extra_args = extra_args
-    self.optimize = optimize
-    self.output_mlir_debuginfo = output_mlir_debuginfo
-    self.output_generic_mlir = output_generic_mlir
-    self.extended_diagnostics = extended_diagnostics
-    self.strip_debug_ops = strip_debug_ops
-    self.strip_source_map = strip_source_map
-    self.crash_reproducer_path = crash_reproducer_path
-    self.enable_tflite_bindings = enable_tflite_bindings
-    self.enable_benchmark = enable_benchmark
-
-
-def build_compile_command_line(input_file: str, tfs: TempFileSaver,
-                               options: CompilerOptions) -> List[str]:
-  """Builds a command line for invoking the compiler.
-
-  Args:
-    input_file: The input file name.
-    tfs: TempFileSaver.
-    options: Compiler options.
-  Returns:
-    List of strings of command line.
-  """
-  iree_translate = find_tool("iree-translate")
-  if not options.target_backends:
-    raise ValueError("Expected a non-empty list for 'target_backends'")
-
-  cl = [
-      iree_translate,
-      input_file,
-      f"--iree-input-type={options.input_type.value}",
-      f"--iree-vm-bytecode-module-output-format={options.output_format.value}",
-  ]
-  for target_backend in options.target_backends:
-    cl.append(f"--iree-hal-target-backends={target_backend}")
-
-  # Output file.
-  output_file = tfs.alloc_optional("core-output.bin",
-                                   export_as=options.output_file)
-  if output_file:
-    cl.append(f"-o={output_file}")
-
-  # Translation to perform.
-  cl.append("--iree-mlir-to-vm-bytecode-module")
-
-  # MLIR flags.
-  if options.output_mlir_debuginfo:
-    cl.append("--mlir-print-debuginfo")
-  if options.output_generic_mlir:
-    cl.append("--mlir-print-op-generic")
-  if options.extended_diagnostics:
-    # Note that different tools have different defaults, so be explicit.
-    cl.append("--mlir-print-op-on-diagnostic=true")
-  else:
-    cl.append("--mlir-print-op-on-diagnostic=false")
-
-  # Other options to set if specified.
-  if options.strip_debug_ops:
-    cl.append("--iree-vm-bytecode-module-strip-debug-ops")
-  if options.strip_source_map:
-    cl.append("--iree-vm-bytecode-module-strip-source-map")
-  crash_reproducer_path = tfs.alloc_optional(
-      "core-reproducer.mlir", export_as=options.crash_reproducer_path)
-  if crash_reproducer_path:
-    cl.append(f"--pass-pipeline-crash-reproducer={crash_reproducer_path}")
-  if options.enable_tflite_bindings:
-    cl.append("--iree-tflite-bindings-support")
-  if options.enable_benchmark:
-    cl.append("--iree-flow-export-benchmark-funcs")
-
-  cl.extend(options.extra_args)
-  return cl
-
-
-def compile_file(input_file: str, **kwargs):
-  """Invokes the IREE compiler on an input file.
-
-  Args:
-    input_file: File containing MLIR assembly to compile.
-    **kwargs: Keyword arguments corresponding to CompilerOptions.
-  Returns:
-    Either a byte buffer of the compiled content or None if output_file
-    was specified in the options.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = CompilerOptions(**kwargs)
-    cl = build_compile_command_line(input_file, tfs, options)
-    result = invoke_immediate(cl)
-    if options.output_file:
-      return None
-    return result
-
-
-def compile_str(input_str: Union[str, bytes], **kwargs):
-  """Invokes the IREE compiler with an input string.
-
-  Args:
-    input_str: MLIR assembly to parse/compile (str or bytes).
-    **kwargs: Keyword arguments corresponding to CompilerOptions.
-  Returns:
-    Either a byte buffer of the compiled content or None if output_file
-    was specified in the options.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = CompilerOptions(**kwargs)
-    cl = build_compile_command_line("-", tfs, options)
-    input_bytes = input_str.encode("utf-8") if isinstance(input_str,
-                                                          str) else input_str
-    result = invoke_immediate(cl, immediate_input=input_bytes)
-    if options.output_file:
-      return None
-    return result
diff --git a/bindings/python/iree/compiler/debugging.py b/bindings/python/iree/compiler/debugging.py
deleted file mode 100644
index 63b285f..0000000
--- a/bindings/python/iree/compiler/debugging.py
+++ /dev/null
@@ -1,176 +0,0 @@
-"""Debugging support."""
-
-# Copyright 2021 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-from typing import Optional
-
-import logging
-import os
-import shutil
-import sys
-import threading
-
-_thread_locals = threading.local()
-_invocation_id = 0
-
-
-def _get_temp_file_saver_stack():
-  try:
-    return _thread_locals.temp_file_saver_stack
-  except AttributeError:
-    stack = []
-    _thread_locals.temp_file_saver_stack = stack
-    return stack
-
-
-def _interpolate_path_pattern(path_pattern: str, *, invocation_id: str):
-  # We do not use str.format() because we do not know the providence of
-  # path_pattern. Instead, handle a fixed set of replacements.
-  path_pattern = path_pattern.replace("{id}", str(invocation_id))
-  path_pattern = path_pattern.replace("{pid}", str(os.getpid()))
-  path_pattern = path_pattern.replace("{main}", os.path.basename(sys.argv[0]))
-  return path_pattern
-
-
-class TempFileSaver:
-  """Manages the saving of temp files resulting from tool invocations.
-
-  The TempFileSaver is a thread-local context bound object. An attempt to
-  create a new one will return the most recent instance created and entered
-  as a context manager. This allows up-stack callers to establish the
-  policy for saving temporaries and deep implementations will inherit it.
-
-  Proper usage from users wishing to establish a saver context:
-    with TempFileSaver():
-      # Do things with temp files.
-
-  Proper usage for implementors wishing to use an established saver context
-  or set up a new one:
-    with TempFileSaver.implicit() as tfs:
-      # Do things with temp files.
-
-  The outer-most creator can customize it with explicit arguments to __init__
-  but these will be ignored if an instance is already thread bound.
-  """
-  TEMP_PATH_ENV_KEY = "IREE_SAVE_TEMPS"
-
-  @staticmethod
-  def implicit():
-    stack = _get_temp_file_saver_stack()
-    if stack:
-      return stack[-1]
-    return TempFileSaver()
-
-  def __init__(self,
-               temp_path_pattern: str = None,
-               *,
-               invocation_id: Optional[str] = None):
-    self.retained = False
-    self._refcount = 0
-    if temp_path_pattern is None:
-      temp_path_pattern = os.environ.get(TempFileSaver.TEMP_PATH_ENV_KEY)
-    if temp_path_pattern is None:
-      return
-
-    global _invocation_id
-    if invocation_id is not None:
-      self.invocation_id = invocation_id
-    else:
-      self.invocation_id = _invocation_id
-      _invocation_id += 1
-
-    self.retained_path = _interpolate_path_pattern(
-        temp_path_pattern, invocation_id=self.invocation_id)
-    self.retained = True
-    self._retained_file_names = set()
-    self._copy_on_finalize = list()  # Of (source_path, target_path)
-
-  def __enter__(self):
-    _get_temp_file_saver_stack().append(self)
-    self._refcount += 1
-    return self
-
-  def __exit__(self, exc_type, exc_value, traceback):
-    del _get_temp_file_saver_stack()[-1]
-    self._refcount -= 1
-    if self._refcount == 0:
-      self._finalize()
-
-  @staticmethod
-  def current():
-    try:
-      return _get_temp_file_saver_stack()[-1]
-    except KeyError:
-      raise RuntimeError("No current TempFileSaver")
-
-  def alloc_optional(self,
-                     file_name: str,
-                     *,
-                     export_as: Optional[str] = None) -> Optional[str]:
-    """Allocates an optional temporary file.
-
-
-    When in non-retained mode, the return value is 'export_as', meaning that the
-    file is just some user specified output file.
-
-    When in retained mode, the output file will be an index-mangled variant
-    of 'file_name' under the temp_path. In addition, a mapping will be added
-    so that upon finalization, the file is also exported to 'export_as' if
-    specified.
-
-    Returns None if neither a user-specified 'export_as' is specified nor in
-    retained mode.
-
-    The distinction between retained temporaries and exports is to help in
-    cases for when the caller has requested that an artifact be written to
-    a specific place (i.e. an output file) but for debuggability, we also
-    want to save it as a temporary. In this case, we save it to the temporary
-    location and then conclude by moving artifacts to their final location
-    once the saver goes out of scope.
-    """
-    if not self.retained:
-      return export_as
-    alloced_path = self._alloc_retained_path(file_name)
-    if export_as:
-      self._copy_on_finalize.append((alloced_path, export_as))
-    return alloced_path
-
-  def _alloc_retained_path(self, file_name: str) -> str:
-    assert self.retained
-    index = 0
-    original_file_name = file_name
-    while True:
-      if file_name not in self._retained_file_names:
-        # First use of this name.
-        self._retained_file_names.add(file_name)
-        os.makedirs(self.retained_path, exist_ok=True)
-        return os.path.join(self.retained_path, file_name)
-      index += 1
-      stem, ext = os.path.splitext(original_file_name)
-      file_name = f"{stem}_{index}{ext}"
-
-  def _finalize(self):
-    if not self.retained:
-      return
-    # See which files were materialized.
-    was_materialized = []
-    for file_name in self._retained_file_names:
-      file_path = os.path.join(self.retained_path, file_name)
-      if os.path.exists(file_path):
-        was_materialized.append((file_name, file_path))
-    if was_materialized:
-      logging.info(
-          "**** IREE Compiler retained temporary files (%s)***:\n%s",
-          self.invocation_id, "\n".join([
-              f"  * {file_name} : {file_path}"
-              for file_name, file_path in was_materialized
-          ]))
-    for source_path, target_path in self._copy_on_finalize:
-      if os.path.exists(source_path):
-        logging.info("Copy retained file to output: %s -> %s", source_path,
-                     target_path)
-        shutil.copyfile(source_path, target_path)
diff --git a/bindings/python/iree/compiler/setup.py.in b/bindings/python/iree/compiler/setup.py.in
deleted file mode 100644
index 8055d8b..0000000
--- a/bindings/python/iree/compiler/setup.py.in
+++ /dev/null
@@ -1,91 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# Build platform specific wheel files for the iree.runtime package.
-# Built artifacts are per-platform and build out of the build tree.
-
-from distutils.command.install import install
-import os
-import platform
-from setuptools import setup, find_namespace_packages
-
-with open(os.path.join(os.path.dirname(__file__), "README.md"), "r") as f:
-  README = f.read()
-
-exe_suffix = ".exe" if platform.system() == "Windows" else ""
-
-# Force platform specific wheel.
-# https://stackoverflow.com/questions/45150304
-try:
-  from wheel.bdist_wheel import bdist_wheel as _bdist_wheel
-
-  class bdist_wheel(_bdist_wheel):
-
-    def finalize_options(self):
-      _bdist_wheel.finalize_options(self)
-      self.root_is_pure = False
-
-    def get_tag(self):
-      python, abi, plat = _bdist_wheel.get_tag(self)
-      # We don't contain any python extensions so are version agnostic
-      # but still want to be platform specific.
-      python, abi = 'py3', 'none'
-      return python, abi, plat
-
-except ImportError:
-  bdist_wheel = None
-
-
-# Force installation into platlib.
-# Since this is a pure-python library with platform binaries, it is
-# mis-detected as "pure", which fails audit. Usually, the presence of an
-# extension triggers non-pure install. We force it here.
-class platlib_install(install):
-
-  def finalize_options(self):
-    install.finalize_options(self)
-    self.install_lib = self.install_platlib
-
-
-setup(
-    name="iree-compiler@IREE_RELEASE_PACKAGE_SUFFIX@",
-    version="@IREE_RELEASE_VERSION@",
-    author="The IREE Team",
-    author_email="iree-discuss@googlegroups.com",
-    license="Apache",
-    description="IREE Python Compiler API",
-    long_description=README,
-    long_description_content_type="text/markdown",
-    url="https://github.com/google/iree",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: Apache License",
-        "Operating System :: OS Independent",
-        "Development Status :: 3 - Alpha",
-    ],
-    python_requires=">=3.7",
-    packages=find_namespace_packages(include=[
-        "iree.compiler",
-        "iree.compiler.*",
-        "iree.tools.core",
-        "iree.tools.core.*",
-    ]),
-    package_data={
-        "iree.tools.core": [f"iree-translate{exe_suffix}",],
-    },
-    cmdclass={
-        'bdist_wheel': bdist_wheel,
-        'install': platlib_install,
-    },
-    entry_points={
-        "console_scripts": [
-            "iree-translate = iree.tools.core.scripts.iree_translate.__main__:main",
-        ],
-    },
-    zip_safe=False,  # This package is fine but not zipping is more versatile.
-)
diff --git a/bindings/python/iree/compiler/tf.py b/bindings/python/iree/compiler/tf.py
deleted file mode 100644
index 65c81b1..0000000
--- a/bindings/python/iree/compiler/tf.py
+++ /dev/null
@@ -1,238 +0,0 @@
-# Lint-as: python3
-"""TensorFlow compiler interface."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# TODO(#4131) python>=3.7: Use postponed type annotations.
-
-from enum import Enum
-import logging
-import tempfile
-from typing import List, Optional, Sequence, Set, Union
-
-from .core import CompilerOptions, DEFAULT_TESTING_BACKENDS, build_compile_command_line
-from .debugging import TempFileSaver
-from .tools import find_tool, invoke_immediate, invoke_pipeline
-
-__all__ = [
-    "compile_saved_model",
-    "compile_module",
-    "is_available",
-    "DEFAULT_TESTING_BACKENDS",
-    "ImportOptions",
-    "ImportType",
-]
-
-_TF_IMPORT_TOOL = "iree-import-tf"
-
-
-def is_available():
-  """Determine if TensorFlow and the compiler are available."""
-  try:
-    import tensorflow as tf
-  except ModuleNotFoundError:
-    logging.warn("Unable to import tensorflow")
-    return False
-  try:
-    find_tool(_TF_IMPORT_TOOL)
-  except ValueError:
-    logging.warning("Unable to find IREE tool %s", _TF_IMPORT_TOOL)
-    return False
-  return True
-
-
-class ImportType(Enum):
-  """Import type of the model."""
-  OBJECT_GRAPH = "savedmodel_v2"
-  V2 = "savedmodel_v2"
-  SIGNATURE_DEF = "savedmodel_v1"
-  V1 = "savedmodel_v1"
-
-  @staticmethod
-  def parse(spec: Union[str, "ImportType"]) -> "ImportType":
-    """Parses or returns an ImportType.
-
-    Args:
-      spec: An ImportType instance or the case-insensitive name of one of
-        the enum values.
-    Returns:
-      An ImportType instance.
-    """
-    if isinstance(spec, ImportType):
-      return spec
-    spec = spec.upper()
-    if spec not in ImportType.__members__:
-      raise ValueError(f"For import_type= argument, expected one of: "
-                       f"{', '.join(ImportType.__members__.keys())}")
-    return ImportType[spec]
-
-
-# TODO(#4131) python>=3.7: Consider using a dataclass.
-class ImportOptions(CompilerOptions):
-  """Import options layer on top of the backend compiler options."""
-
-  def __init__(self,
-               exported_names: Sequence[str] = (),
-               import_only: bool = False,
-               import_type: Union[ImportType, str] = ImportType.OBJECT_GRAPH,
-               saved_model_tags: Set[str] = set(),
-               import_extra_args: Sequence[str] = (),
-               save_temp_tf_input: Optional[str] = None,
-               save_temp_mid_level_input: Optional[str] = None,
-               save_temp_iree_input: Optional[str] = None,
-               use_tosa: bool = False,
-               **kwargs):
-    """Initialize options from keywords.
-
-    Args:
-      exported_names: Optional sequence representing the exported names to
-        keep (object graph/v2 models only).
-      import_only: Only import the module. If True, the result will be textual
-        MLIR that can be further fed to the IREE compiler. If False (default),
-        the result will be the fully compiled IREE binary. In both cases,
-        bytes-like output is returned. Note that if the output_file= is
-        specified and import_only=True, then the MLIR form will be written to
-        the output file.
-      import_type: Type of import to perform. See ImportType enum.
-      saved_model_tags: Set of tags to export (signature def/v1 saved models
-        only).
-      import_extra_args: Extra arguments to pass to the iree-import-tf tool.
-      save_temp_tf_input: Optionally save the IR that is input to the
-        TensorFlow pipeline.
-      save_temp_mid_level_input: Optionally save the IR that is input to the
-        mid level IR.
-      save_temp_iree_input: Optionally save the IR that is the result of the
-        import (ready to be passed to IREE).
-    """
-    super().__init__(**kwargs)
-    self.exported_names = exported_names
-    self.import_only = import_only
-    self.import_type = ImportType.parse(import_type)
-    self.saved_model_tags = saved_model_tags
-    self.import_extra_args = import_extra_args
-    self.save_temp_tf_input = save_temp_tf_input
-    self.save_temp_mid_level_input = save_temp_mid_level_input
-    self.save_temp_iree_input = save_temp_iree_input
-    self.use_tosa = use_tosa
-
-
-def build_import_command_line(input_path: str, tfs: TempFileSaver,
-                              options: ImportOptions) -> List[str]:
-  """Builds a command line for invoking the import stage.
-
-  Args:
-    input_path: The input path.
-    tfs: TempFileSaver.
-    options: Import options.
-  Returns:
-    List of strings of command line.
-  """
-  tf_import = find_tool(_TF_IMPORT_TOOL)
-  cl = [
-      tf_import,
-      input_path,
-      f"--tf-import-type={options.import_type.value}",
-      f"--tf-savedmodel-exported-names={','.join(options.exported_names)}",
-      f"--tf-savedmodel-tags={','.join(options.saved_model_tags)}",
-  ]
-
-  if options.import_only and options.output_file:
-    # Import stage directly outputs.
-    output_file = tfs.alloc_optional("tf-output.mlir",
-                                     export_as=options.output_file)
-    cl.append(f"-o={output_file}")
-
-  # MLIR flags.
-  if options.output_mlir_debuginfo:
-    cl.append("--mlir-print-debuginfo")
-  if options.output_generic_mlir:
-    cl.append("--mlir-print-op-generic")
-
-  # Save temps flags.
-  save_tf_input = tfs.alloc_optional("tf-input.mlir",
-                                     export_as=options.save_temp_tf_input)
-  if save_tf_input:
-    cl.append(f"--save-temp-tf-input={save_tf_input}")
-  save_mid_level_input = tfs.alloc_optional(
-      "tf-mid-level-input.mlir", export_as=options.save_temp_mid_level_input)
-  if save_mid_level_input:
-    cl.append(f"--save-temp-mid-level-input={save_mid_level_input}")
-  save_iree_input = tfs.alloc_optional("tf-iree-input.mlir",
-                                       export_as=options.save_temp_iree_input)
-  if save_iree_input:
-    cl.append(f"--save-temp-iree-input={save_iree_input}")
-
-  if options.use_tosa:
-    cl.append(f"--use-tosa")
-
-  # Crash reproducer (locally qualified).
-  requested_crash_reproducer_path = options.crash_reproducer_path
-  if requested_crash_reproducer_path:
-    requested_crash_reproducer_path = (requested_crash_reproducer_path +
-                                       ".import-tf")
-  crash_reproducer_path = tfs.alloc_optional(
-      "tf-reproducer.mlir", export_as=requested_crash_reproducer_path)
-  if crash_reproducer_path:
-    cl.append(f"--pass-pipeline-crash-reproducer={crash_reproducer_path}")
-
-  # Extra args.
-  cl.extend(options.import_extra_args)
-  return cl
-
-
-def compile_saved_model(saved_model_dir: str, **kwargs):
-  """Compiles an on-disk saved model to an IREE binary.
-
-  Args:
-    saved_model_dir: Path to directory where the model was saved.
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    A bytes-like object with the compiled output or None if output_file=
-    was specified.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = ImportOptions(**kwargs)
-    import_cl = build_import_command_line(saved_model_dir, tfs, options)
-    if options.import_only:
-      # One stage tool pipeline.
-      result = invoke_immediate(import_cl)
-      if options.output_file:
-        return None
-      return result
-
-    # Full compilation pipeline.
-    compile_cl = build_compile_command_line("-", tfs, options)
-    result = invoke_pipeline([import_cl, compile_cl])
-    if options.output_file:
-      return None
-    return result
-
-
-def compile_module(module, saved_model_dir: Optional[str] = None, **kwargs):
-  """Compiles a tf.Module to an IREE binary (by saving to disk).
-
-  Args:
-    module: The tf.Module instance to convert to MLIR
-    saved_model_dir: Optional path to save the tf.Module to. The module will not
-      be persisted on disk outside of this call if this is not provided.
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    Same as compile_saved_model().
-  """
-  with TempFileSaver.implicit() as tfs:
-
-    def do_it(saved_model_dir):
-      import tensorflow as tf
-      options = tf.saved_model.SaveOptions(save_debug_info=True)
-      tf.saved_model.save(module, saved_model_dir, options=options)
-      return compile_saved_model(saved_model_dir, **kwargs)
-
-    if saved_model_dir:
-      return do_it(saved_model_dir)
-    else:
-      with tempfile.TemporaryDirectory(suffix=".sm") as td:
-        return do_it(td)
diff --git a/bindings/python/iree/compiler/tflite.py b/bindings/python/iree/compiler/tflite.py
deleted file mode 100644
index d59e9cd..0000000
--- a/bindings/python/iree/compiler/tflite.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# Lint-as: python3
-"""TFLite compiler interface."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# TODO(#4131) python>=3.7: Use postponed type annotations.
-
-from enum import Enum
-import logging
-import tempfile
-from typing import List, Optional, Sequence, Set, Union
-
-from .debugging import TempFileSaver
-from .tools import find_tool, invoke_immediate, invoke_pipeline
-from .core import CompilerOptions, DEFAULT_TESTING_BACKENDS, build_compile_command_line
-
-__all__ = [
-    "compile_file",
-    "compile_str",
-    "is_available",
-    "DEFAULT_TESTING_BACKENDS",
-    "ImportOptions",
-]
-
-_IMPORT_TOOL = "iree-import-tflite"
-
-
-def is_available():
-  """Determine if the XLA frontend is available."""
-  try:
-    find_tool(_IMPORT_TOOL)
-  except ValueError:
-    logging.warning("Unable to find IREE tool %s", _IMPORT_TOOL)
-    return False
-  return True
-
-
-# TODO(#4131) python>=3.7: Consider using a dataclass.
-class ImportOptions(CompilerOptions):
-  """Import options layer on top of the backend compiler options."""
-
-  def __init__(self,
-               input_arrays: Sequence[str] = (),
-               output_arrays: Sequence[str] = (),
-               import_only: bool = False,
-               import_extra_args: Sequence[str] = (),
-               save_temp_tfl_input: Optional[str] = None,
-               save_temp_iree_input: Optional[str] = None,
-               **kwargs):
-    """Initialize options from keywords.
-
-    Args:
-      input_arrays: Sequence of input array node names (if different from
-        default).
-      output_arrays: Sequence of output array node names (if different from
-        default).
-      import_only: Only import the module. If True, the result will be textual
-        MLIR that can be further fed to the IREE compiler. If False (default),
-        the result will be the fully compiled IREE binary. In both cases,
-        bytes-like output is returned. Note that if the output_file= is
-        specified and import_only=True, then the MLIR form will be written to
-        the output file.
-      import_extra_args: Extra arguments to pass to the iree-import-tf tool.
-      save_temp_tfl_input: Optionally save the IR that results from importing
-        the flatbuffer (prior to any further transformations).
-      save_temp_iree_input: Optionally save the IR that is the result of the
-        import (ready to be passed to IREE).
-    """
-    super().__init__(**kwargs)
-    self.input_arrays = input_arrays
-    self.output_arrays = output_arrays
-    self.import_only = import_only
-    self.import_extra_args = import_extra_args
-    self.save_temp_tfl_input = save_temp_tfl_input
-    self.save_temp_iree_input = save_temp_iree_input
-
-
-def build_import_command_line(input_path: str, tfs: TempFileSaver,
-                              options: ImportOptions) -> List[str]:
-  """Builds a command line for invoking the import stage.
-
-  Args:
-    input_path: The input path.
-    tfs: TempFileSaver.
-    options: Import options.
-  Returns:
-    List of strings of command line.
-  """
-  import_tool = find_tool(_IMPORT_TOOL)
-  cl = [
-      import_tool,
-      input_path,
-  ]
-
-  if options.import_only and options.output_file:
-    # Import stage directly outputs.
-    output_file = tfs.alloc_optional("tflite-output.mlir",
-                                     export_as=options.output_file)
-    cl.append(f"-o={options.output_file}")
-
-  # Input arrays.
-  if options.input_arrays:
-    for input_array in options.input_arrays:
-      cl.append(f"--input-array={input_array}")
-    for output_array in options.output_arrays:
-      cl.append(f"--output-array={output_array}")
-
-  # MLIR flags.
-  if options.output_mlir_debuginfo:
-    cl.append("--mlir-print-debuginfo")
-  if options.output_generic_mlir:
-    cl.append("--mlir-print-op-generic")
-
-  # Save temps flags.
-  tfl_input = tfs.alloc_optional("tflite-input.mlir",
-                                 export_as=options.save_temp_tfl_input)
-  if tfl_input:
-    cl.append(f"--save-temp-tfl-input={tfl_input}")
-  iree_input = tfs.alloc_optional("tflite-iree-input.mlir",
-                                  export_as=options.save_temp_iree_input)
-  if iree_input:
-    cl.append(f"--save-temp-iree-input={iree_input}")
-
-  # Crash reproducer (locally qualified).
-  requested_crash_reproducer_path = options.crash_reproducer_path
-  if requested_crash_reproducer_path:
-    requested_crash_reproducer_path = (requested_crash_reproducer_path +
-                                       ".import-tflite")
-  crash_reproducer_path = tfs.alloc_optional(
-      "tflite-reproducer.mlir", export_as=requested_crash_reproducer_path)
-  if crash_reproducer_path:
-    cl.append(f"--pass-pipeline-crash-reproducer={crash_reproducer_path}")
-
-  # Extra args.
-  cl.extend(options.import_extra_args)
-  return cl
-
-
-def compile_file(fb_path: str, **kwargs):
-  """Compiles a TFLite flatbuffer file to an IREE binary.
-
-  Args:
-    fb_path: Path to the flatbuffer.
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    A bytes-like object with the compiled output or None if output_file=
-    was specified.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = ImportOptions(**kwargs)
-    import_cl = build_import_command_line(fb_path, tfs, options)
-    if options.import_only:
-      # One stage tool pipeline.
-      result = invoke_immediate(import_cl)
-      if options.output_file:
-        return None
-      return result
-
-    # Full compilation pipeline.
-    compile_cl = build_compile_command_line("-", tfs, options)
-    result = invoke_pipeline([import_cl, compile_cl])
-    if options.output_file:
-      return None
-    return result
-
-
-def compile_str(fb_content: bytes, **kwargs):
-  """Compiles in-memory TFLite flatbuffer to an IREE binary.
-
-  Args:
-    xla_content: Flatbuffer content as bytes.
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    A bytes-like object with the compiled output or None if output_file=
-    was specified.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = ImportOptions(**kwargs)
-    import_cl = build_import_command_line("-", tfs, options)
-    if options.import_only:
-      # One stage tool pipeline.
-      result = invoke_immediate(import_cl, immediate_input=fb_content)
-      if options.output_file:
-        return None
-      return result
-
-    # Full compilation pipeline.
-    compile_cl = build_compile_command_line("-", tfs, options)
-    result = invoke_pipeline([import_cl, compile_cl],
-                             immediate_input=fb_content)
-    if options.output_file:
-      return None
-    return result
diff --git a/bindings/python/iree/compiler/tools.py b/bindings/python/iree/compiler/tools.py
deleted file mode 100644
index 68a92d9..0000000
--- a/bindings/python/iree/compiler/tools.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# Lint-as: python3
-"""Utilities for locating and invoking compiler tools."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import importlib
-import io
-import os
-import subprocess
-import sys
-import textwrap
-import threading
-
-from typing import List, Optional, Union
-
-__all__ = [
-    "find_tool",
-    "invoke_immediate",
-    "invoke_pipeline",
-    "get_tool_path",
-    "CompilerToolError",
-]
-
-# In normal distribution circumstances, each named tool is associated with
-# a python module that provides a `get_tool` function for getting its absolute
-# path. This dictionary maps the tool name to the module.
-_TOOL_MODULE_MAP = {
-    "iree-import-tflite": "iree.tools.tflite",
-    "iree-import-xla": "iree.tools.xla",
-    "iree-import-tf": "iree.tools.tf",
-    "iree-translate": "iree.tools.core",
-}
-
-# Map of tool module to package name as distributed to archives (used for
-# error messages).
-_TOOL_MODULE_PACKAGES = {
-    "iree.tools.core": "google-iree-tools-core",
-    "iree.tools.tf": "google-iree-tools-tf",
-    "iree.tools.tflite": "google-iree-tools-tflite",
-    "iree.tools.xla": "google-iree-tools-xla",
-}
-
-# Environment variable holding directories to be searched for named tools.
-# Delimitted by os.pathsep.
-_TOOL_PATH_ENVVAR = "IREE_TOOL_PATH"
-
-
-class CompilerToolError(Exception):
-  """Compiler exception that preserves the command line and error output."""
-
-  def __init__(self, process: subprocess.CompletedProcess):
-    try:
-      errs = process.stderr.decode("utf-8")
-    except:
-      errs = str(process.stderr)  # Decode error or other: best we can do.
-
-    tool_name = os.path.basename(process.args[0])
-    super().__init__(f"Error invoking IREE compiler tool {tool_name}\n"
-                     f"Diagnostics:\n{errs}\n\n"
-                     f"Invoked with:\n  {' '.join(process.args)}")
-
-
-def get_tool_path() -> List[str]:
-  """Returns list of paths to search for tools."""
-  list_str = os.environ.get(_TOOL_PATH_ENVVAR)
-  if not list_str:
-    return []
-  return list_str.split(os.pathsep)
-
-
-def find_tool(exe_name: str) -> str:
-  """Finds a tool by its (extension-less) executable name.
-
-  Args:
-    exe_name: The name of the executable (extension-less).
-  Returns:
-    An absolute path to the tool.
-  Raises:
-    ValueError: If the tool is not known or not found.
-  """
-  if exe_name not in _TOOL_MODULE_MAP:
-    raise ValueError(f"IREE compiler tool '{exe_name}' is not a known tool")
-  # First search an explicit tool path.
-  tool_path = get_tool_path()
-  for path_entry in tool_path:
-    if not path_entry:
-      continue
-    candidate_exe = os.path.join(path_entry, exe_name)
-    if os.path.isfile(candidate_exe) and os.access(candidate_exe, os.X_OK):
-      return candidate_exe
-
-  # Attempt to load the tool module.
-  tool_module_name = _TOOL_MODULE_MAP[exe_name]
-  tool_module_package = _TOOL_MODULE_PACKAGES[tool_module_name]
-  try:
-    tool_module = importlib.import_module(tool_module_name)
-  except ModuleNotFoundError:
-    raise ValueError(
-        f"IREE compiler tool '{exe_name}' is not installed (it should have been "
-        f"found in the python module '{tool_module_name}', typically installed "
-        f"via the package {tool_module_package}).\n\n"
-        f"Either install the package or set the {_TOOL_PATH_ENVVAR} environment "
-        f"variable to contain the path of the tool executable "
-        f"(current {_TOOL_PATH_ENVVAR} = {repr(tool_path)})") from None
-
-  # Ask the module for its tool.
-  candidate_exe = tool_module.get_tool(exe_name)
-  if (not candidate_exe or not os.path.isfile(candidate_exe) or
-      not os.access(candidate_exe, os.X_OK)):
-    raise ValueError(
-        f"IREE compiler tool '{exe_name}' was located in module "
-        f"'{tool_module_name}' but the file was not found or not executable: "
-        f"{candidate_exe}")
-  return candidate_exe
-
-
-def invoke_immediate(command_line: List[str],
-                     *,
-                     input_file: Optional[bytes] = None,
-                     immediate_input=None):
-  """Invokes an immediate command.
-
-  This is separate from invoke_pipeline as it is simpler and supports more
-  complex input redirection, using recommended facilities for sub-processes
-  (less magic).
-
-  Note that this differs from the usual way of using subprocess.run or
-  subprocess.Popen().communicate() because we need to pump all of the error
-  streams individually and only pump pipes not connected to a different stage.
-  Uses threads to pump everything that is required.
-  """
-  run_args = {}
-  input_file_handle = None
-  stderr_handle = sys.stderr
-  try:
-    # Redirect input.
-    if input_file is not None:
-      input_file_handle = open(input_file, "rb")
-      run_args["stdin"] = input_file_handle
-    elif immediate_input is not None:
-      run_args["input"] = immediate_input
-
-    # Capture output.
-    # TODO(#4131) python>=3.7: Use capture_output=True.
-    run_args["stdout"] = subprocess.PIPE
-    run_args["stderr"] = subprocess.PIPE
-    process = subprocess.run(command_line, **run_args)
-    if process.returncode != 0:
-      raise CompilerToolError(process)
-    # Emit stderr contents.
-    _write_binary_stderr(stderr_handle, process.stderr)
-    return process.stdout
-  finally:
-    if input_file_handle:
-      input_file_handle.close()
-
-
-def invoke_pipeline(command_lines: List[List[str]], immediate_input=None):
-  """Invoke a pipeline of commands.
-
-  The first stage of the pipeline will have its stdin set to DEVNULL and each
-  subsequent stdin will derive from the prior stdout. The final stdout will
-  be accumulated and returned. All stderr contents are accumulated and printed
-  to stderr on completion or the first failing stage of the pipeline will have
-  an exception raised with its stderr output.
-  """
-  stages = []
-  pipeline_input = (subprocess.DEVNULL
-                    if immediate_input is None else subprocess.PIPE)
-  prev_out = pipeline_input
-  stderr_handle = sys.stderr
-
-  # Create all stages.
-  for i in range(len(command_lines)):
-    command_line = command_lines[i]
-    popen_args = {
-        "stdin": prev_out,
-        "stdout": subprocess.PIPE,
-        "stderr": subprocess.PIPE,
-    }
-    process = subprocess.Popen(command_line, **popen_args)
-    prev_out = process.stdout
-    capture_output = (i == (len(command_lines) - 1))
-    stages.append(_PipelineStage(process, capture_output))
-
-  # Start stages.
-  for stage in stages:
-    stage.start()
-
-  # Pump input.
-  pipe_success = True
-  if immediate_input is not None:
-    try:
-      pipe_success = False
-      stages[0].process.stdin.write(immediate_input)
-      pipe_success = True
-    finally:
-      stages[0].process.stdin.close()
-
-  # Join.
-  for stage in stages:
-    stage.join()
-
-  # Check for errors.
-  for stage in stages:
-    assert stage.completed
-    if stage.completed.returncode != 0:
-      raise CompilerToolError(stage.completed)
-
-  # Broken pipe.
-  if not pipe_success:
-    raise CompilerToolError(stages[0].completed)
-
-  # Print any stderr output.
-  for stage in stages:
-    _write_binary_stderr(stderr_handle, stage.errs)
-  return stages[-1].outs
-
-
-class _PipelineStage(threading.Thread):
-  """Wraps a process and pumps its handles, waiting for completion."""
-
-  def __init__(self, process, capture_output):
-    super().__init__()
-    self.process = process
-    self.capture_output = capture_output
-    self.completed: Optional[subprocess.CompletedProcess] = None
-    self.outs = None
-    self.errs = None
-
-  def pump_stderr(self):
-    self.errs = self.process.stderr.read()
-
-  def pump_stdout(self):
-    self.outs = self.process.stdout.read()
-
-  def run(self):
-    stderr_thread = threading.Thread(target=self.pump_stderr)
-    stderr_thread.start()
-    if self.capture_output:
-      stdout_thread = threading.Thread(target=self.pump_stdout)
-      stdout_thread.start()
-    self.process.wait()
-    stderr_thread.join()
-    if self.capture_output:
-      stdout_thread.join()
-    self.completed = subprocess.CompletedProcess(self.process.args,
-                                                 self.process.returncode,
-                                                 self.outs, self.errs)
-    self.process.stderr.close()
-    self.process.stdout.close()
-
-
-def _write_binary_stderr(out_handle, contents):
-  # Fast-paths buffered text-io (which stderr is by default) while allowing
-  # full decode for non buffered and binary io.
-  if hasattr(out_handle, "buffer"):
-    out_handle.buffer.write(contents)
-  elif isinstance(out_handle, io.TextIOBase):
-    out_handle.write(contents.decode("utf-8"))
-  else:
-    out_handle.write(contents)
diff --git a/bindings/python/iree/compiler/version.py.in b/bindings/python/iree/compiler/version.py.in
deleted file mode 100644
index e660b02..0000000
--- a/bindings/python/iree/compiler/version.py.in
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-PACKAGE_SUFFIX = "@IREE_RELEASE_PACKAGE_SUFFIX@"
-VERSION = "@IREE_RELEASE_VERSION@"
-REVISION = "@IREE_RELEASE_REVISION@"
diff --git a/bindings/python/iree/compiler/xla.py b/bindings/python/iree/compiler/xla.py
deleted file mode 100644
index a0b0578..0000000
--- a/bindings/python/iree/compiler/xla.py
+++ /dev/null
@@ -1,212 +0,0 @@
-# Lint-as: python3
-"""XLA compiler interface."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# TODO(#4131) python>=3.7: Use postponed type annotations.
-
-from enum import Enum
-import logging
-import tempfile
-from typing import List, Optional, Sequence, Set, Union
-
-from .core import CompilerOptions, DEFAULT_TESTING_BACKENDS, build_compile_command_line
-from .debugging import TempFileSaver
-from .tools import find_tool, invoke_immediate, invoke_pipeline
-
-__all__ = [
-    "compile_file",
-    "compile_str",
-    "is_available",
-    "DEFAULT_TESTING_BACKENDS",
-    "ImportOptions",
-    "ImportFormat",
-]
-
-_IMPORT_TOOL = "iree-import-xla"
-
-
-def is_available():
-  """Determine if the XLA frontend is available."""
-  try:
-    find_tool(_IMPORT_TOOL)
-  except ValueError:
-    logging.warning("Unable to find IREE tool %s", _IMPORT_TOOL)
-    return False
-  return True
-
-
-class ImportFormat(Enum):
-  """Import type of the model."""
-  BINARY_PROTO = "binary_proto"
-  TEXT_PROTO = "text_proto"
-  HLO_TEXT = "hlo_text"
-
-  @staticmethod
-  def parse(spec: Union[str, "ImportFormat"]) -> "ImportFormat":
-    """Parses or returns an ImportFormat.
-
-    Args:
-      spec: An ImportFormat instance or the case-insensitive name of one of
-        the enum values.
-    Returns:
-      An ImportFormat instance.
-    """
-    if isinstance(spec, ImportFormat):
-      return spec
-    spec = spec.upper()
-    if spec not in ImportFormat.__members__:
-      raise ValueError(f"For import_format= argument, expected one of: "
-                       f"{', '.join(ImportFormat.__members__.keys())}")
-    return ImportFormat[spec]
-
-
-# TODO(#4131) python>=3.7: Consider using a dataclass.
-class ImportOptions(CompilerOptions):
-  """Import options layer on top of the backend compiler options."""
-
-  def __init__(self,
-               import_only: bool = False,
-               import_format: Union[ImportFormat,
-                                    str] = ImportFormat.BINARY_PROTO,
-               import_extra_args: Sequence[str] = (),
-               save_temp_mhlo_input: Optional[str] = None,
-               save_temp_iree_input: Optional[str] = None,
-               **kwargs):
-    """Initialize options from keywords.
-
-    Args:
-      import_format: Format of the proto (text or binary).
-      save_temp_iree_input: Optionally save the IR that is the result of the
-        import (ready to be passed to IREE).
-    """
-    super().__init__(**kwargs)
-    self.import_only = import_only
-    self.import_format = ImportFormat.parse(import_format)
-    self.import_extra_args = import_extra_args
-    self.save_temp_mhlo_input = save_temp_mhlo_input
-    self.save_temp_iree_input = save_temp_iree_input
-
-
-def build_import_command_line(input_path: str, tfs: TempFileSaver,
-                              options: ImportOptions) -> List[str]:
-  """Builds a command line for invoking the import stage.
-
-  Args:
-    input_path: The input path.
-    tfs: TempFileSaver.
-    options: Import options.
-  Returns:
-    List of strings of command line.
-  """
-  import_tool = find_tool(_IMPORT_TOOL)
-  cl = [
-      import_tool,
-      input_path,
-      f"--xla-format={options.import_format.value}",
-  ]
-
-  if options.import_only and options.output_file:
-    # Import stage directly outputs.
-    output_file = tfs.alloc_optional("xla-output.mlir",
-                                     export_as=options.output_file)
-    cl.append(f"-o={output_file}")
-
-  # MLIR flags.
-  if options.output_mlir_debuginfo:
-    cl.append("--mlir-print-debuginfo")
-  if options.output_generic_mlir:
-    cl.append("--mlir-print-op-generic")
-
-  # Save temps flags.
-  save_mhlo_input = tfs.alloc_optional("tf-mhlo.mlir",
-                                       export_as=options.save_temp_mhlo_input)
-  if save_mhlo_input:
-    cl.append(f"--save-temp-mhlo-input={save_mhlo_input}")
-  iree_input = tfs.alloc_optional("xla-iree-input.mlir",
-                                  export_as=options.save_temp_iree_input)
-  if iree_input:
-    cl.append(f"--save-temp-iree-input={iree_input}")
-
-  # Crash reproducer (locally qualified).
-  requested_crash_reproducer_path = options.crash_reproducer_path
-  if requested_crash_reproducer_path:
-    requested_crash_reproducer_path = (requested_crash_reproducer_path +
-                                       ".import-xla")
-  crash_reproducer_path = tfs.alloc_optional(
-      "xla-reproducer.mlir", export_as=requested_crash_reproducer_path)
-  if crash_reproducer_path:
-    cl.append(f"--pass-pipeline-crash-reproducer={crash_reproducer_path}")
-
-  # Extra args.
-  cl.extend(options.import_extra_args)
-  return cl
-
-
-def compile_file(xla_file_path: str, **kwargs):
-  """Compiles an on-disk XLA protocol buffer to an IREE binary.
-
-  Args:
-    xla_file_path: Path to the XLA proto file.
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    A bytes-like object with the compiled output or None if output_file=
-    was specified.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = ImportOptions(**kwargs)
-    import_cl = build_import_command_line(xla_file_path, tfs, options)
-    if options.import_only:
-      # One stage tool pipeline.
-      result = invoke_immediate(import_cl)
-      if options.output_file:
-        return None
-      return result
-
-    # Full compilation pipeline.
-    compile_cl = build_compile_command_line("-", tfs, options)
-    result = invoke_pipeline([import_cl, compile_cl])
-    if options.output_file:
-      return None
-    return result
-
-
-def compile_str(xla_content: Union[bytes, str], **kwargs):
-  """Compiles in-memory XLA content to an IREE binary.
-
-  Args:
-    xla_content: Either bytes or str content (str is only valid for text
-      formats).
-    **kwargs: Keyword args corresponding to ImportOptions or CompilerOptions.
-  Returns:
-    A bytes-like object with the compiled output or None if output_file=
-    was specified.
-  """
-  with TempFileSaver.implicit() as tfs:
-    options = ImportOptions(**kwargs)
-    if isinstance(xla_content, str):
-      if options.import_format not in [
-          ImportFormat.TEXT_PROTO, ImportFormat.HLO_TEXT
-      ]:
-        raise ValueError("If passing a string, ImportFormat must be TEXT_PROTO")
-      xla_content = xla_content.encode("utf-8")
-
-    import_cl = build_import_command_line("-", tfs, options)
-    if options.import_only:
-      # One stage tool pipeline.
-      result = invoke_immediate(import_cl, immediate_input=xla_content)
-      if options.output_file:
-        return None
-      return result
-
-    # Full compilation pipeline.
-    compile_cl = build_compile_command_line("-", tfs, options)
-    result = invoke_pipeline([import_cl, compile_cl],
-                             immediate_input=xla_content)
-    if options.output_file:
-      return None
-    return result
diff --git a/bindings/python/iree/tools/core/CMakeLists.txt b/bindings/python/iree/tools/core/CMakeLists.txt
deleted file mode 100644
index 1553ddf..0000000
--- a/bindings/python/iree/tools/core/CMakeLists.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-set(_srcs
-  "__init__.py"
-  "scripts/iree_translate/__main__.py"
-)
-
-iree_py_library(
-  NAME
-    core
-  SRCS ${_srcs}
-)
-
-if(${IREE_BUILD_COMPILER})
-  iree_symlink_tool(
-    TARGET core
-    FROM_TOOL_TARGET iree_tools_iree-translate
-    TO_EXE_NAME iree-translate
-  )
-endif()
-
-iree_py_install_package(
-  AUGMENT_EXISTING_PACKAGE
-  COMPONENT IreePythonPackage-compiler
-  PACKAGE_NAME iree_compiler
-  MODULE_PATH iree/tools/core
-  FILES_MATCHING ${_srcs}
-  DEPS
-    iree_tools_iree-translate
-)
-
-install(
-  TARGETS iree_tools_iree-translate
-  COMPONENT ${PY_INSTALL_COMPONENT}
-  DESTINATION "${PY_INSTALL_MODULE_DIR}"
-)
diff --git a/bindings/python/iree/tools/core/__init__.py b/bindings/python/iree/tools/core/__init__.py
deleted file mode 100644
index 11f9d20..0000000
--- a/bindings/python/iree/tools/core/__init__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# Lint-as: python3
-"""Core tools."""
-
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-from typing import Optional
-
-import os
-import platform
-
-
-def get_tool(exe_name: str) -> Optional[str]:
-  if platform.system() == "Windows":
-    exe_name = exe_name + ".exe"
-  this_path = os.path.dirname(__file__)
-  tool_path = os.path.join(this_path, exe_name)
-  return tool_path
diff --git a/bindings/python/iree/tools/core/scripts/iree_translate/__main__.py b/bindings/python/iree/tools/core/scripts/iree_translate/__main__.py
deleted file mode 100644
index ba7a831..0000000
--- a/bindings/python/iree/tools/core/scripts/iree_translate/__main__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright 2021 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import subprocess
-import sys
-
-import iree.tools.core
-
-
-def main(args=None):
-  if args is None:
-    args = sys.argv[1:]
-  exe = iree.tools.core.get_tool("iree-translate")
-  return subprocess.call(args=[exe] + args)
-
-
-if __name__ == "__main__":
-  sys.exit(main())
diff --git a/bindings/python/tests/CMakeLists.txt b/bindings/python/tests/CMakeLists.txt
deleted file mode 100644
index ce39429..0000000
--- a/bindings/python/tests/CMakeLists.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-iree_py_test(
-  NAME
-    compiler_core_test
-  SRCS
-    "compiler_core_test.py"
-)
-
-iree_py_test(
-  NAME
-    compiler_tf_test
-  SRCS
-    "compiler_tf_test.py"
-)
-
-iree_py_test(
-  NAME
-    compiler_tflite_test
-  SRCS
-    "compiler_tflite_test.py"
-)
-
-iree_py_test(
-  NAME
-    compiler_xla_test
-  SRCS
-    "compiler_xla_test.py"
-)
diff --git a/bindings/python/tests/README.md b/bindings/python/tests/README.md
deleted file mode 100644
index e6e6c29..0000000
--- a/bindings/python/tests/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Python API Tests
-
-These tests are run in an environment where all available Python bindings
-are setup on the `PYTHONPATH`. Each will internally skip itself if optional
-components are not available.
-
-Note that IREE compiler tool locations can be overridden by specifying the
-`IREE_TOOL_PATH` environment variable.
diff --git a/bindings/python/tests/compiler_core_test.py b/bindings/python/tests/compiler_core_test.py
deleted file mode 100644
index f06f2e1..0000000
--- a/bindings/python/tests/compiler_core_test.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# Lint as: python3
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import contextlib
-import logging
-import os
-import io
-import tempfile
-import unittest
-
-import iree.compiler
-
-SIMPLE_MUL_ASM = """
-func @simple_mul(%arg0: tensor<4xf32>, %arg1: tensor<4xf32>) -> tensor<4xf32> {
-    %0 = "mhlo.multiply"(%arg0, %arg1) {name = "mul.1"} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
-    return %0 : tensor<4xf32>
-}
-"""
-
-
-class CompilerTest(unittest.TestCase):
-
-  def setUp(self):
-    if "IREE_SAVE_TEMPS" in os.environ:
-      del os.environ["IREE_SAVE_TEMPS"]
-
-  def testNoTargetBackends(self):
-    with self.assertRaisesRegex(
-        ValueError, "Expected a non-empty list for 'target_backends'"):
-      binary = iree.compiler.compile_str(SIMPLE_MUL_ASM)
-
-  def testCompileStr(self):
-    binary = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type="mhlo",
-        target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-    logging.info("Flatbuffer size = %d", len(binary))
-    self.assertTrue(binary)
-
-  # Compiling the string form means that the compiler does not have a valid
-  # source file name, which can cause issues on the AOT side. Verify
-  # specifically. See: https://github.com/google/iree/issues/4439
-  def testCompileStrLLVMAOT(self):
-    binary = iree.compiler.compile_str(SIMPLE_MUL_ASM,
-                                       input_type="mhlo",
-                                       target_backends=["dylib-llvm-aot"])
-    logging.info("Flatbuffer size = %d", len(binary))
-    self.assertTrue(binary)
-
-  # Verifies that multiple target_backends are accepted. Which two are not
-  # load bearing.
-  # See: https://github.com/google/iree/issues/4436
-  def testCompileMultipleBackends(self):
-    binary = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type="mhlo",
-        target_backends=["dylib-llvm-aot", "vulkan-spirv"])
-    logging.info("Flatbuffer size = %d", len(binary))
-    self.assertTrue(binary)
-
-  def testCompileInputFile(self):
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.write(SIMPLE_MUL_ASM)
-        f.close()
-        binary = iree.compiler.compile_file(
-            f.name,
-            input_type="mhlo",
-            target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-      finally:
-        os.remove(f.name)
-    logging.info("Flatbuffer size = %d", len(binary))
-    self.assertIn(b"simple_mul", binary)
-
-  def testCompileOutputFile(self):
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.close()
-        output = iree.compiler.compile_str(
-            SIMPLE_MUL_ASM,
-            input_type="mhlo",
-            output_file=f.name,
-            target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-        self.assertIsNone(output)
-
-        with open(f.name, "rb") as f_read:
-          binary = f_read.read()
-      finally:
-        os.remove(f.name)
-    logging.info("Flatbuffer size = %d", len(binary))
-    self.assertIn(b"simple_mul", binary)
-
-  def testOutputFbText(self):
-    text = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type="mhlo",
-        output_format=iree.compiler.OutputFormat.FLATBUFFER_TEXT,
-        target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS).decode("utf-8")
-    # Just check for an arbitrary JSON-tag.
-    self.assertIn('"exported_functions"', text)
-
-  def testBadInputType(self):
-    with self.assertRaisesRegex(
-        ValueError, "For input_type= argument, expected one of: "
-        "NONE, MHLO, TOSA"):
-      _ = iree.compiler.compile_str(
-          SIMPLE_MUL_ASM,
-          input_type="not-existing",
-          output_format="foobar",
-          target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-
-  def testBadOutputFormat(self):
-    with self.assertRaisesRegex(
-        ValueError, "For output_format= argument, expected one of: "
-        "FLATBUFFER_BINARY, FLATBUFFER_TEXT, MLIR_TEXT"):
-      _ = iree.compiler.compile_str(
-          SIMPLE_MUL_ASM,
-          input_type="mhlo",
-          output_format="foobar",
-          target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-
-  def testOutputFbTextParsed(self):
-    text = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type='mhlo',
-        output_format='flatbuffer_text',
-        target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS).decode("utf-8")
-    # Just check for an arbitrary JSON-tag.
-    self.assertIn('"exported_functions"', text)
-
-  def testOutputMlirText(self):
-    text = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type="mhlo",
-        output_format=iree.compiler.OutputFormat.MLIR_TEXT,
-        target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS).decode("utf-8")
-    # Just check for a textual op name.
-    self.assertIn("vm.module", text)
-
-  def testExtraArgsStderr(self):
-    # mlir-timing is not special: it just does something and emits to stderr.
-    with io.StringIO() as buf, contextlib.redirect_stderr(buf):
-      iree.compiler.compile_str(
-          SIMPLE_MUL_ASM,
-          input_type="mhlo",
-          extra_args=["--mlir-timing"],
-          target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-      stderr = buf.getvalue()
-    self.assertIn("Execution time report", stderr)
-
-  def testAllOptions(self):
-    binary = iree.compiler.compile_str(
-        SIMPLE_MUL_ASM,
-        input_type="mhlo",
-        optimize=False,
-        strip_debug_ops=True,
-        strip_source_map=True,
-        crash_reproducer_path="foobar.txt",
-        # Re-enable when benchmarking pass is fixed: #6196
-        # enable_benchmark=True,
-        target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-
-  def testException(self):
-    with self.assertRaisesRegex(iree.compiler.CompilerToolError,
-                                "Invoked with"):
-      _ = iree.compiler.compile_str(
-          "I'm a little teapot but not a valid program",
-          target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-
-  def testExplicitTempFileSaver(self):
-    temp_dir = tempfile.TemporaryDirectory()
-    output_file = tempfile.NamedTemporaryFile("wt")
-    output_file.close()
-    with iree.compiler.TempFileSaver(temp_dir.name):
-      output = iree.compiler.compile_str(
-          SIMPLE_MUL_ASM,
-          input_type="mhlo",
-          output_file=output_file.name,
-          target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-      self.assertIsNone(output)
-
-    # There should be an output file and a core-output.bin in the temp dir.
-    self.assertTrue(os.path.exists(output_file.name))
-    expected_temp_file = os.path.join(temp_dir.name, "core-output.bin")
-    self.assertTrue(os.path.exists(expected_temp_file))
-
-    # And they should have the same contents.
-    with open(output_file.name, "rb") as f:
-      output_contents = f.read()
-    with open(expected_temp_file, "rb") as f:
-      temp_contents = f.read()
-    self.assertEqual(temp_contents, output_contents)
-    temp_dir.cleanup()
-
-  def testEnvTempFileSaver(self):
-    temp_dir = tempfile.TemporaryDirectory()
-    os.environ["IREE_SAVE_TEMPS"] = temp_dir.name
-    with iree.compiler.TempFileSaver() as tfs:
-      self.assertTrue(tfs.retained)
-      self.assertEqual(tfs.retained_path, temp_dir.name)
-
-  def testTempFileSaverDisabled(self):
-    with iree.compiler.TempFileSaver() as tfs:
-      self.assertFalse(tfs.retained)
-
-
-if __name__ == "__main__":
-  logging.basicConfig(level=logging.DEBUG)
-  unittest.main()
diff --git a/bindings/python/tests/compiler_tf_test.py b/bindings/python/tests/compiler_tf_test.py
deleted file mode 100644
index bd847eb..0000000
--- a/bindings/python/tests/compiler_tf_test.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import logging
-import os
-import sys
-import tempfile
-import unittest
-
-# TODO: No idea why pytype cannot find names from this module.
-# pytype: disable=name-error
-import iree.compiler.tf
-
-if not iree.compiler.tf.is_available():
-  print(f"Skipping test {__file__} because the IREE TensorFlow compiler "
-        f"is not installed")
-  sys.exit(0)
-
-import tensorflow as tf
-
-
-class SimpleArithmeticModule(tf.Module):
-
-  @tf.function(input_signature=[
-      tf.TensorSpec([4], tf.float32),
-      tf.TensorSpec([4], tf.float32)
-  ])
-  def simple_mul(self, a, b):
-    return a * b
-
-  @tf.function(input_signature=[
-      tf.TensorSpec([128, 3072], tf.float32),
-      tf.TensorSpec([3072, 256], tf.float32),
-  ])
-  def simple_matmul(self, a, b):
-    return tf.matmul(a, b)
-
-
-# TODO(laurenzo): More test cases needed (may need additional files).
-# Specifically, figure out how to test v1 models.
-class TfCompilerTest(tf.test.TestCase):
-
-  def testImportSavedModel(self):
-    import_mlir = iree.compiler.tf.compile_saved_model(
-        self.smdir, import_only=True, output_generic_mlir=True).decode("utf-8")
-    self.assertIn("sym_name = \"simple_matmul\"", import_mlir)
-
-  def testCompileSavedModel(self):
-    binary = iree.compiler.tf.compile_saved_model(
-        self.smdir, target_backends=iree.compiler.tf.DEFAULT_TESTING_BACKENDS)
-    logging.info("Compiled len: %d", len(binary))
-    self.assertIn(b"simple_matmul", binary)
-    self.assertIn(b"simple_mul", binary)
-
-  def testCompileModule(self):
-    binary = iree.compiler.tf.compile_module(
-        self.m, target_backends=iree.compiler.tf.DEFAULT_TESTING_BACKENDS)
-    logging.info("Compiled len: %d", len(binary))
-    self.assertIn(b"simple_matmul", binary)
-    self.assertIn(b"simple_mul", binary)
-
-  @classmethod
-  def setUpClass(cls):
-    cls.m = SimpleArithmeticModule()
-    cls.tempdir = tempfile.TemporaryDirectory()
-    cls.smdir = os.path.join(cls.tempdir.name, "arith.sm")
-    tf.saved_model.save(
-        cls.m,
-        cls.smdir,
-        options=tf.saved_model.SaveOptions(save_debug_info=True))
-
-  @classmethod
-  def tearDownClass(cls):
-    cls.tempdir.cleanup()
-
-
-if __name__ == "__main__":
-  logging.basicConfig(level=logging.DEBUG)
-  tf.test.main()
diff --git a/bindings/python/tests/compiler_tflite_test.py b/bindings/python/tests/compiler_tflite_test.py
deleted file mode 100644
index aeeacf9..0000000
--- a/bindings/python/tests/compiler_tflite_test.py
+++ /dev/null
@@ -1,103 +0,0 @@
-# Lint as: python3
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import logging
-import os
-import sys
-import tempfile
-import unittest
-
-# TODO: No idea why pytype cannot find names from this module.
-# pytype: disable=name-error
-import iree.compiler.tflite
-
-if not iree.compiler.tflite.is_available():
-  print(f"Skipping test {__file__} because the IREE TFLite compiler "
-        f"is not installed")
-  sys.exit(0)
-
-
-class CompilerTest(unittest.TestCase):
-
-  def testImportBinaryPbFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    text = iree.compiler.tflite.compile_file(path,
-                                             import_only=True).decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("tosa.mul", text)
-
-  @unittest.skip("IREE tosa compilation not implemented yet")
-  def testCompileBinaryPbFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    binary = iree.compiler.tflite.compile_file(
-        path, target_backends=iree.compiler.tflite.DEFAULT_TESTING_BACKENDS)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-  def testImportBinaryPbFileOutputFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.close()
-        output = iree.compiler.tflite.compile_file(path,
-                                                   import_only=True,
-                                                   output_file=f.name)
-        self.assertIsNone(output)
-        with open(f.name, "rt") as f_read:
-          text = f_read.read()
-      finally:
-        os.remove(f.name)
-    logging.info("%s", text)
-    self.assertIn("tosa.mul", text)
-
-  @unittest.skip("IREE tosa compilation not implemented yet")
-  def testCompileBinaryPbFileOutputFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.close()
-        output = iree.compiler.tflite.compile_file(
-            path,
-            output_file=f.name,
-            target_backends=iree.compiler.tflite.DEFAULT_TESTING_BACKENDS)
-        self.assertIsNone(output)
-        with open(f.name, "rb") as f_read:
-          binary = f_read.read()
-      finally:
-        os.remove(f.name)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-  def testImportBinaryPbBytes(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    with open(path, "rb") as f:
-      content = f.read()
-    text = iree.compiler.tflite.compile_str(content,
-                                            import_only=True).decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("tosa.mul", text)
-
-  @unittest.skip("IREE tosa compilation not implemented yet")
-  def testCompileBinaryPbBytes(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata",
-                        "tflite_sample.fb")
-    with open(path, "rb") as f:
-      content = f.read()
-    binary = iree.compiler.tflite.compile_str(
-        content, target_backends=iree.compiler.tflite.DEFAULT_TESTING_BACKENDS)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-
-if __name__ == "__main__":
-  logging.basicConfig(level=logging.DEBUG)
-  unittest.main()
diff --git a/bindings/python/tests/compiler_xla_test.py b/bindings/python/tests/compiler_xla_test.py
deleted file mode 100644
index 37182ae..0000000
--- a/bindings/python/tests/compiler_xla_test.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Lint as: python3
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import logging
-import os
-import sys
-import tempfile
-import unittest
-
-# TODO: No idea why pytype cannot find names from this module.
-# pytype: disable=name-error
-# pytype: disable=module-attr
-import iree.compiler.xla
-
-if not iree.compiler.xla.is_available():
-  print(f"Skipping test {__file__} because the IREE XLA compiler "
-        f"is not installed")
-  sys.exit(0)
-
-
-class CompilerTest(unittest.TestCase):
-
-  def testImportBinaryPbFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    text = iree.compiler.xla.compile_file(path,
-                                          import_only=True).decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-  def testCompileBinaryPbFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    binary = iree.compiler.xla.compile_file(
-        path, target_backends=iree.compiler.xla.DEFAULT_TESTING_BACKENDS)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-  def testImportBinaryPbFileOutputFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.close()
-        output = iree.compiler.xla.compile_file(path,
-                                                import_only=True,
-                                                output_file=f.name)
-        self.assertIsNone(output)
-        with open(f.name, "rt") as f_read:
-          text = f_read.read()
-      finally:
-        os.remove(f.name)
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-  def testCompileBinaryPbFileOutputFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    with tempfile.NamedTemporaryFile("wt", delete=False) as f:
-      try:
-        f.close()
-        output = iree.compiler.xla.compile_file(
-            path,
-            output_file=f.name,
-            target_backends=iree.compiler.DEFAULT_TESTING_BACKENDS)
-        self.assertIsNone(output)
-        with open(f.name, "rb") as f_read:
-          binary = f_read.read()
-      finally:
-        os.remove(f.name)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-  def testImportBinaryPbBytes(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    with open(path, "rb") as f:
-      content = f.read()
-    text = iree.compiler.xla.compile_str(content,
-                                         import_only=True).decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-  def testCompileBinaryPbBytes(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.pb")
-    with open(path, "rb") as f:
-      content = f.read()
-    binary = iree.compiler.xla.compile_str(
-        content, target_backends=iree.compiler.xla.DEFAULT_TESTING_BACKENDS)
-    logging.info("Binary length = %d", len(binary))
-    self.assertIn(b"main", binary)
-
-  def testImportHloTextFile(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.hlo")
-    text = iree.compiler.xla.compile_file(
-        path, import_only=True, import_format="hlo_text").decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-  def testImportHloTextStr(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.hlo")
-    with open(path, "rt") as f:
-      content = f.read()
-    text = iree.compiler.xla.compile_str(
-        content, import_only=True, import_format="hlo_text").decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-  def testImportHloTextBytes(self):
-    path = os.path.join(os.path.dirname(__file__), "testdata", "xla_sample.hlo")
-    with open(path, "rb") as f:
-      content = f.read()
-    text = iree.compiler.xla.compile_str(
-        content, import_only=True, import_format="hlo_text").decode("utf-8")
-    logging.info("%s", text)
-    self.assertIn("linalg.generic", text)
-
-
-if __name__ == "__main__":
-  logging.basicConfig(level=logging.DEBUG)
-  unittest.main()
diff --git a/bindings/python/tests/testdata/generate_tflite.py b/bindings/python/tests/testdata/generate_tflite.py
deleted file mode 100644
index a325089..0000000
--- a/bindings/python/tests/testdata/generate_tflite.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import os
-
-import tensorflow as tf
-
-
-class Squared(tf.Module):
-
-  @tf.function
-  def __call__(self, x):
-    return tf.square(x)
-
-
-model = Squared()
-concrete_func = model.__call__.get_concrete_function(
-    tf.TensorSpec(shape=[4, 3], dtype=tf.float32))
-
-converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func],
-                                                            model)
-tflite_model = converter.convert()
-
-this_dir = os.path.dirname(__file__)
-with open(os.path.join(this_dir, "tflite_sample.fb"), "wb") as f:
-  f.write(tflite_model)
diff --git a/bindings/python/tests/testdata/generate_xla.py b/bindings/python/tests/testdata/generate_xla.py
deleted file mode 100644
index c583291..0000000
--- a/bindings/python/tests/testdata/generate_xla.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright 2020 The IREE Authors
-#
-# Licensed under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-import os
-
-import numpy as np
-
-# Jax is the most accessible way to get at an xla_client.
-# python -m pip install --upgrade pip
-# python -m pip install --upgrade jax jaxlib
-from jaxlib import xla_client
-
-ops = xla_client.ops
-
-builder = xla_client.XlaBuilder("testbuilder")
-in_shape = np.array([4], dtype=np.float32)
-in_feed = ops.Parameter(builder, 0, xla_client.shape_from_pyval(in_shape))
-result = ops.Add(in_feed, ops.Constant(builder, np.float32(1.0)))
-xla_computation = builder.Build(result)
-
-this_dir = os.path.dirname(__file__)
-with open(os.path.join(this_dir, "xla_sample.pb"), "wb") as f:
-  f.write(xla_computation.as_serialized_hlo_module_proto())
-with open(os.path.join(this_dir, "xla_sample.hlo"), "wt") as f:
-  f.write(xla_computation.as_hlo_text())
diff --git a/bindings/python/tests/testdata/tflite_sample.fb b/bindings/python/tests/testdata/tflite_sample.fb
deleted file mode 100644
index 52cb9e4..0000000
--- a/bindings/python/tests/testdata/tflite_sample.fb
+++ /dev/null
Binary files differ
diff --git a/bindings/python/tests/testdata/xla_sample.hlo b/bindings/python/tests/testdata/xla_sample.hlo
deleted file mode 100644
index 2617141..0000000
--- a/bindings/python/tests/testdata/xla_sample.hlo
+++ /dev/null
@@ -1,9 +0,0 @@
-HloModule testbuilder.5
-
-ENTRY testbuilder.5 {
-  parameter.1 = f32[1] parameter(0)
-  constant.2 = f32[] constant(1)
-  broadcast.3 = f32[1]{0} broadcast(constant.2), dimensions={}
-  ROOT add.4 = f32[1]{0} add(parameter.1, broadcast.3)
-}
-
diff --git a/bindings/python/tests/testdata/xla_sample.pb b/bindings/python/tests/testdata/xla_sample.pb
deleted file mode 100644
index 1f69a64..0000000
--- a/bindings/python/tests/testdata/xla_sample.pb
+++ /dev/null
Binary files differ
diff --git a/build_tools/cmake/iree_python.cmake b/build_tools/cmake/iree_python.cmake
index 59e1069..09f11da 100644
--- a/build_tools/cmake/iree_python.cmake
+++ b/build_tools/cmake/iree_python.cmake
@@ -299,9 +299,9 @@
     TEST_NAME "${_NAME_PATH}"
     LABELS "${_RULE_LABELS}"
     ENVIRONMENT
-      "PYTHONPATH=${CMAKE_BINARY_DIR}/bindings/python:$ENV{PYTHONPATH}"
+      "PYTHONPATH=${IREE_BINARY_DIR}/compiler-api/python_package:${IREE_BINARY_DIR}/bindings/python:$ENV{PYTHONPATH}"
     COMMAND
-      "${CMAKE_SOURCE_DIR}/build_tools/cmake/run_test.${IREE_HOST_SCRIPT_EXT}"
+      "${IREE_SOURCE_DIR}/build_tools/cmake/run_test.${IREE_HOST_SCRIPT_EXT}"
       "${Python3_EXECUTABLE}"
       "${_SRC_DIR}/${_RULE_SRCS}"
       ${_RULE_ARGS}
diff --git a/docs/website/docs/building-from-source/optional-features.md b/docs/website/docs/building-from-source/optional-features.md
index 737764c..a22d196 100644
--- a/docs/website/docs/building-from-source/optional-features.md
+++ b/docs/website/docs/building-from-source/optional-features.md
@@ -96,7 +96,9 @@
         .
     cmake --build .
 
-    # Add ./bindings/python to PYTHONPATH and use the API.
+    # Add ./bindings/python and compiler-api/python_package to PYTHONPATH and
+    # use the API.
+    source .env && export PYTHONPATH
     export PYTHONPATH="$PWD/bindings/python"
     python -c "import iree.compiler"
     python -c "import iree.runtime"
@@ -108,8 +110,9 @@
     cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DIREE_BUILD_PYTHON_BINDINGS=ON .
     cmake --build .
 
-    # Add bindings\python to PYTHONPATH and use the API.
-    set PYTHONPATH="$pwd\bindings\python;%PYTHONPATH%"
+    # Add bindings\python and compiler-api\python_package to PYTHONPATH and use
+    # the API.
+    set PYTHONPATH="$pwd\compiler-api\python_package;$pwd\bindings\python;%PYTHONPATH%"
     python -c "import iree.compiler"
     python -c "import iree.runtime"
     ```