text: #!/usr/bin/python
  # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  # ==============================================================================
  #
  # Automatically update TensorFlow version in source files
  #
  # Usage:
  #           ./tensorflow/tools/ci_build/update_version.py --version 1.4.0-rc1
  #           ./tensorflow/tools/ci_build/update_version.py --nightly
  #
  """Update version of TensorFlow script."""
  
  # pylint: disable=superfluous-parens
  
  import argparse
  import fileinput
  import os
  import re
  import subprocess
  import time
  
  # File parameters
  TF_SRC_DIR = "tensorflow"
  VERSION_H = "%s/core/public/version.h" % TF_SRC_DIR
  SETUP_PY = "%s/tools/pip_package/setup.py" % TF_SRC_DIR
  README_MD = "./README.md"
  DEVEL_DOCKERFILE = "%s/tools/docker/Dockerfile.devel" % TF_SRC_DIR
  GPU_DEVEL_DOCKERFILE = "%s/tools/docker/Dockerfile.devel-gpu" % TF_SRC_DIR
  RELEVANT_FILES = [TF_SRC_DIR,
                    VERSION_H,
                    SETUP_PY,
                    README_MD,
                    DEVEL_DOCKERFILE,
                    GPU_DEVEL_DOCKERFILE]
  
  # Version type parameters
  NIGHTLY_VERSION = 1
  REGULAR_VERSION = 0
  
  
  def replace_line(old_line, new_line, filename):
    """Replace a line in a file."""
    for line in fileinput.input(filename, inplace=True):
      print(line.rstrip().replace(old_line, new_line))
  
  
  def check_existence(filename):
    """Check the existence of file or dir."""
    if not os.path.exists(filename):
      raise RuntimeError("%s not found. Are you under the TensorFlow source root"
                         " directory?")
  
  
  def check_all_files():
    """Check all relevant files necessary for upgrade."""
    for file_name in RELEVANT_FILES:
      check_existence(file_name)
  
  
  def replace_with_sed(query, filename):
    """Replace with sed when regex is required."""
    subprocess.check_call(['sed', '-i', '-r', '-e', query, filename])
  
  
  class Version(object):
    """Version class object that stores SemVer version information."""
  
    def __init__(self, major, minor, patch, identifier_string, version_type):
      """Constructor.
  
      Args:
        major: major string eg. (1)
        minor: minor string eg. (3)
        patch: patch string eg. (1)
        identifier_string: extension string eg. (-rc0)
        version_type: version parameter ((REGULAR|NIGHTLY)_VERSION)
      """
      self.string = "%s.%s.%s%s" % (major,
                                    minor,
                                    patch,
                                    identifier_string)
      self.major = major
      self.minor = minor
      self.patch = patch
      self.identifier_string = identifier_string
      self.version_type = version_type
  
    def __str__(self):
      return self.string
  
    @property
    def pep_440_str(self):
      if self.version_type == REGULAR_VERSION:
        return_string = "%s.%s.%s%s" % (self.major,
                                        self.minor,
                                        self.patch,
                                        self.identifier_string)
        return return_string.replace("-", "")
      else:
        return_string = "%s.%s.%s" % (self.major,
                                      self.minor,
                                      self.identifier_string)
        return return_string.replace("-", "")
  
    @staticmethod
    def parse_from_string(string, version_type):
      """Returns version object from Semver string.
  
      Args:
        string: version string
        version_type: version parameter
  
      Raises:
        RuntimeError: If the version string is not valid.
      """
      # Check validity of new version string
      if not re.search(r"[0-9]+\.[0-9]+\.[a-zA-Z0-9]+", string):
        raise RuntimeError("Invalid version string: %s" % string)
  
      major, minor, extension = string.split(".", 2)
  
      # Isolate patch and identifier string if identifier string exists
      extension_split = extension.split("-", 1)
      patch = extension_split[0]
      if len(extension_split) == 2:
        identifier_string = "-" + extension_split[1]
      else:
        identifier_string = ""
  
      return Version(major,
                     minor,
                     patch,
                     identifier_string,
                     version_type)
  
  
  def get_current_semver_version():
    """Returns a Version object of current version.
  
    Returns:
      version: Version object of current SemVer string based on information from
      core/public/version.h
    """
  
    # Get current version information
    version_file = open(VERSION_H, "r")
    for line in version_file:
      major_match = re.search("^#define TF_MAJOR_VERSION ([0-9]+)", line)
      minor_match = re.search("^#define TF_MINOR_VERSION ([0-9]+)", line)
      patch_match = re.search("^#define TF_PATCH_VERSION ([0-9]+)", line)
      extension_match = re.search("^#define TF_VERSION_SUFFIX \"(.*)\"", line)
      if major_match:
        old_major = major_match.group(1)
      if minor_match:
        old_minor = minor_match.group(1)
      if patch_match:
        old_patch_num = patch_match.group(1)
      if extension_match:
        old_extension = extension_match.group(1)
        break
  
    if "dev" in old_extension:
      version_type = NIGHTLY_VERSION
    else:
      version_type = REGULAR_VERSION
  
    return Version(old_major,
                   old_minor,
                   old_patch_num,
                   old_extension,
                   version_type)
  
  
  def update_version_h(old_version, new_version):
    """Update tensorflow/core/public/version.h."""
    replace_line("#define TF_MAJOR_VERSION %s" % old_version.major,
                 "#define TF_MAJOR_VERSION %s" % new_version.major, VERSION_H)
    replace_line("#define TF_MINOR_VERSION %s" % old_version.minor,
                 "#define TF_MINOR_VERSION %s" % new_version.minor, VERSION_H)
    replace_line("#define TF_PATCH_VERSION %s" % old_version.patch,
                 "#define TF_PATCH_VERSION %s" % new_version.patch, VERSION_H)
    replace_line("#define TF_VERSION_SUFFIX \"%s\"" %
                 old_version.identifier_string,
                 "#define TF_VERSION_SUFFIX \"%s\""
                 % new_version.identifier_string,
                 VERSION_H)
  
  
  def update_setup_dot_py(old_version, new_version):
    """Update setup.py."""
    replace_line("_VERSION = '%s'" % old_version.string,
                 "_VERSION = '%s'" % new_version.string, SETUP_PY)
  
  
  def update_readme(old_version, new_version):
    """Update README."""
    pep_440_str = new_version.pep_440_str
    replace_with_sed(r"s/%s\.%s\.([[:alnum:]]+)-/%s-/g" % (old_version.major,
                                                           old_version.minor,
                                                           pep_440_str),
                     README_MD)
  
  
  def update_md_files(old_version, new_version):
    """Update the md doc files.
  
    Args:
      old_version: Version object of current version
      new_version: Version object of new version
    """
  
    old_pep_version = old_version.pep_440_str
    new_pep_version = new_version.pep_440_str
    for filename in ["linux", "mac", "windows", "sources"]:
      filepath = "%s/docs_src/install/install_%s.md" % (TF_SRC_DIR,
                                                        filename)
      replace_with_sed("s/tensorflow-%s/tensorflow-%s/g"
                       % (old_pep_version, new_pep_version), filepath)
      replace_with_sed("s/tensorflow_gpu-%s/tensorflow_gpu-%s/g"
                       % (old_pep_version, new_pep_version), filepath)
      replace_with_sed("s/TensorFlow %s/TensorFlow %s/g"
                       % (old_pep_version, new_pep_version), filepath)
  
    for filename in ["java", "go", "c"]:
      filepath = "%s/docs_src/install/install_%s.md" % (TF_SRC_DIR,
                                                        filename)
      replace_with_sed(r"s/x86_64-%s/x86_64-%s/g"
                       % (old_version, new_version), filepath)
      replace_with_sed(r"s/libtensorflow-%s.jar/libtensorflow-%s.jar/g"
                       % (old_version, new_version), filepath)
      replace_with_sed(r"s/<version>%s<\/version>/<version>%s<\/version>/g"
                       % (old_version, new_version), filepath)
  
  
  def major_minor_change(old_version, new_version):
    """Check if a major or minor change occurred."""
    major_mismatch = old_version.major != new_version.major
    minor_mismatch = old_version.minor != new_version.minor
    if major_mismatch or minor_mismatch:
      return True
    return False
  
  
  def update_dockerfiles(old_version, new_version):
    """Update dockerfiles if there was a major change."""
    if major_minor_change(old_version, new_version):
      old_r_major_minor = r"r%s\.%s" % (old_version.major, old_version.minor)
      old_r_major_minor_string = old_r_major_minor.replace("\\", "")
      r_major_minor = r"r%s\.%s" % (new_version.major, new_version.minor)
      r_major_minor_string = r_major_minor.replace("\\", "")
  
      print("Detected Major.Minor change.")
      print("Updating pattern %s to %s in additional files"
            % (old_r_major_minor_string, r_major_minor_string))
  
      # Update dockerfiles
      replace_with_sed("s/%s/%s/g"
                       % (old_r_major_minor, r_major_minor), DEVEL_DOCKERFILE)
      replace_with_sed("s/%s/%s/g"
                       % (old_r_major_minor, r_major_minor), GPU_DEVEL_DOCKERFILE)
  
  
  def check_for_lingering_string(lingering_string):
    """Check for given lingering strings."""
    formatted_string = lingering_string.replace(".", r"\.")
    try:
      linger_str_output = subprocess.check_output(
          ["grep", "-rnoH", formatted_string, TF_SRC_DIR])
      linger_strs = linger_str_output.decode("utf8").split("\n")
    except subprocess.CalledProcessError:
      linger_strs = []
  
    if linger_strs:
      print("WARNING: Below are potentially instances of lingering old version "
            "string \"%s\" in source directory \"%s/\" that are not "
            "updated by this script. Please check them manually!"
            % (lingering_string, TF_SRC_DIR))
      for linger_str in linger_strs:
        print(linger_str)
    else:
      print("No lingering old version strings \"%s\" found in source directory"
            " \"%s/\". Good." % (lingering_string, TF_SRC_DIR))
  
  
  def check_for_old_version(old_version, new_version):
    """Check for old version references."""
    for old_ver in [old_version.string, old_version.pep_440_str]:
      check_for_lingering_string(old_ver)
  
    if major_minor_change(old_version, new_version):
      old_r_major_minor = "r%s.%s" % (old_version.major, old_version.minor)
      check_for_lingering_string(old_r_major_minor)
  
  
  def main():
    """This script updates all instances of version in the tensorflow directory.
  
    Requirements:
      version: The version tag
      OR
      nightly: Create a nightly tag with current date
  
    Raises:
      RuntimeError: If the script is not being run from tf source dir
    """
  
    parser = argparse.ArgumentParser(description="Cherry picking automation.")
    group = parser.add_mutually_exclusive_group(required=True)
  
    # Arg information
    group.add_argument("--version",
                       help="<new_major_ver>.<new_minor_ver>.<new_patch_ver>",
                       default="")
    group.add_argument("--nightly",
                       help="disable the service provisioning step",
                       action="store_true")
  
    args = parser.parse_args()
  
    check_all_files()
    old_version = get_current_semver_version()
  
    if args.nightly:
      # dev minor version is one ahead of official
      nightly_minor_ver = int(old_version.minor) + 1
      new_version = Version(old_version.major,
                            str(nightly_minor_ver),
                            old_version.patch,
                            "-dev" + time.strftime("%Y%m%d"),
                            NIGHTLY_VERSION)
    else:
      new_version = Version.parse_from_string(args.version, REGULAR_VERSION)
  
    update_version_h(old_version, new_version)
    update_setup_dot_py(old_version, new_version)
    update_readme(old_version, new_version)
    update_md_files(old_version, new_version)
    update_dockerfiles(old_version, new_version)
  
    # Print transition details
    print("Major: %s -> %s" % (old_version.major, new_version.major))
    print("Minor: %s -> %s" % (old_version.minor, new_version.minor))
    print("Patch: %s -> %s\n" % (old_version.patch, new_version.patch))
  
    check_for_old_version(old_version, new_version)
  
  
  if __name__ == "__main__":
    main()
  