def version():
    """
    Returns the version of BTW. This value is computed once and then
    cached.
    """
    global _cached_version  # pylint: disable-msg=global-statement
    if _cached_version is not None:
        return _cached_version

    # We have to be running from a git tree.
    unclean = subprocess.check_output(["git", "status", "--porcelain"])

    if not (settings.DEBUG or settings.BTW_TESTING) and unclean:
        raise Exception("running with unclean tree while DEBUG is false")

    describe = subprocess.check_output(["git", "describe", "--match",
                                        "v*"]).strip()

    if unclean:
        describe += "-unclean"

    sep = describe.find("-")
    semver.parse(describe[1:len(describe) if sep == -1 else sep])

    _cached_version = describe

    return describe

def get_version_number():
    """
    Prompts the user to enter the version number being released. 
    Outputs the current version number.
    """
    context = {}
    context['current_version'] = apptemplate.VERSION
  
    puts('Current version: %(current_version)s' % context)
    new_version = None
    input = None
    while not new_version:
        if input is not None:
            puts('Invalid version number')
            
        input = raw_input('Enter the new version number: ')
        print input
        try:
            semver.parse(input)
        except ValueError:
            pass
        else:
            new_version = input
            
    return new_version

def main():
    p = argparse.ArgumentParser()
    p.add_argument("input_file")
    p.add_argument("output_file")

    args = p.parse_args()

    actual_data = []
    sim_data = []
    ult_data = []

    pat = re.compile("^A(?P<actual>.*),S(?P<sim>.*),S(?P<ult>.*)$", re.M)
    with open(args.input_file, 'r') as fin:
        for line in fin:
            m = re.match(pat, line)
            actual = m.group("actual")
            sim = m.group("sim")
            ult = m.group("ult")

            # Parse into decimal
            m_actual = semver.parse(actual)
            m_sim = semver.parse(sim)
            m_ult = semver.parse(ult)

            actual_data.append(m_actual)
            sim_data.append(m_sim)
            ult_data.append(m_ult)

    max_minor = {}
    for v in (sim_data + actual_data + ult_data):
        old_max = max_minor.get(v[0], 0)
        max_minor[v[0]] = max(v[1],old_max)
            
    with open(args.output_file, 'w') as fo:
        for i in range(len(sim_data)):
            simV = sim_data[i]
            ultV = ult_data[i]
            actV = actual_data[i]

            simMinor = int(100 * float(simV[1])/(max_minor[simV[0]] + 1))
            ultMinor = int(100 * float(ultV[1])/(max_minor[ultV[0]] + 1))
            actMinor = int(100 * float(actV[1])/(max_minor[actV[0]] + 1))

            f_actual = float("%02d.%02d" % (actV[0], actMinor))
            f_sim = float("%02d.%02d" % (simV[0], simMinor))
            f_ult = float("%02d.%02d" % (ultV[0], ultMinor))

            print "SimVersion = %s, f_sim = %s, ActVersion = %s, f_actual = %s" % (simV, f_sim, actV, f_actual)
            
            fo.write("{} {} {}\n".format(f_actual, f_sim, f_ult))

    def test_should_parse_version(self):
        self.assertEqual(
            parse("1.2.3-alpha.1.2+build.11.e0f985a"),
            {'major': 1,
             'minor': 2,
             'patch': 3,
             'prerelease': 'alpha.1.2',
             'build': 'build.11.e0f985a'})

        self.assertEqual(
            parse("1.2.3-alpha-1+build.11.e0f985a"),
            {'major': 1,
             'minor': 2,
             'patch': 3,
             'prerelease': 'alpha-1',
             'build': 'build.11.e0f985a'})

 def _parse_str(self, version):
     """
     Parse version as string and initialize self with data from version
     :param version:
     :return:
     """
     version = semver.parse(version)
     self._parse_dict(version)

 def _list_source_contents_from_multidir(cls, source):
     for pth in os.listdir(source):
         single_path = os.path.join(source, pth)
         if pth.endswith('.yaml'):
             pth = pth[:-5]
             yield RES_TYPE.Composer, pth, single_path
         elif os.path.exists(os.path.join(single_path, 'meta.yaml')):
             try:
                 semver.parse(pth)
             except ValueError:
                 name = pth
             else:
                 # if it was semver then single_path may look like
                 # /a/b/name/version
                 # and source may look like /a/b/name
                 # we can extract name from this path then
                 name = os.path.split(source)[-1]
             yield RES_TYPE.Normal, name, single_path
         else:
             maybe_cr = os.path.join(single_path,
                                     "{}.yaml".format(
                                         os.path.split(source)[-1]))
             if os.path.exists(maybe_cr):
                 name = os.path.split(source)[-1]
                 yield RES_TYPE.Composer, name, maybe_cr
                 continue
             if not os.path.isdir(single_path):
                 continue
             for single in os.listdir(single_path):
                 try:
                     semver.parse(single)
                 except ValueError:
                     fp = os.path.join(single_path, single)
                     raise RepositoryException(
                         "Unexpected repository content "
                         "structure: {} ""Expected directory "
                         "with version number".format(single_path))
                 else:
                     fp = os.path.join(single_path, single)
                     if os.path.exists(os.path.join(fp, 'meta.yaml')):
                         yield RES_TYPE.Normal, pth, fp
                     elif os.path.exists(
                             os.path.join(fp, '{}.yaml'.format(pth))):
                         cr = os.path.join(fp, '{}.yaml'.format(pth))
                         yield RES_TYPE.Composer, pth, cr

def test_should_parse_version():
    result = parse("1.2.3-alpha.1.2+build.11.e0f985a")
    assert result == {
        'major': 1,
        'minor': 2,
        'patch': 3,
        'prerelease': 'alpha.1.2',
        'build': 'build.11.e0f985a',
    }

    result = parse("1.2.3-alpha-1+build.11.e0f985a")
    assert result == {
        'major': 1,
        'minor': 2,
        'patch': 3,
        'prerelease': 'alpha-1',
        'build': 'build.11.e0f985a',
    }

def semver_bumper(old_version, part="patch"):
    """Bump the version with ``semver`` module.
    
    :arg str part: Specify which part should be bumped. Possible values are
        ``"patch"``, ``"minor"``, or ``"major"``.
        
        If ``part`` is a valid version number, it would bump the version
        number to ``part``.
    :rtype: str
    :return: new version number.
    """
    import semver
    bump = getattr(semver, "bump_" + part, None)
    if callable(bump):
        new_version = bump(old_version)
    else:
        new_version = part
        semver.parse(new_version)
    return new_version

    def set(self, field, value):
        """
        Set any field of semver to `value`

        :rtype : Version
        :param field:type of field (one of Version.VALID_FIELDS)
        :param value:
        :return: :raise ValueError:
        """

        if field not in self.VALID_FIELDS:
            raise ValueError("Incorrect value of \"type\"")

        version = Version(self)
        setattr(version, field, value)

        semver.parse(str(version))

        return version

def match(version, spec):
  if version[0] == 'v':
    version = version[1:]
  if spec[0] == '^':
    base = spec[1:]
    parsed_base = semver.parse(base)
    if parsed_base['major'] > 0:
      top = semver.bump_major(base)
    elif parsed_base['minor'] > 0:
      top = semver.bump_minor(base)
    else:
      top = semver.bump_patch(base)
    return semver.match(version, ">="+base) and semver.match(version, "<="+top)
  else:
    try:
      return semver.match(version, spec)
    except ValueError:
      # this happens when the spec isn't an expression, in which case we need an exact match
      return semver.parse(version) == semver.parse(spec)

    def read(self):
        """
        Read version from version file

        :rtype : Version
        :return:
        """
        with self._path.open(mode='r') as fh:
            version = fh.read().strip()
            version = semver.parse(version)
            return Version(version)

    def tag_semver(self):
        """
        Job tag, parsed as semver (or None if no match). Allows a 'v' prefix
        """
        if self.tag is None:
            return None

        try:
            return semver.parse(self._tag_without_v)
        except ValueError:
            pass

  def test_get_decision_trees_bulk_specific_version(self):
    """get_decision_trees_bulk should succeed when given a specific version.

    It should give a proper JSON response with a list containing a dict
    with `id` field being string and 'tree' field being a dict with the
    field 'version''major' being the version given as a parameter.
    """
    payload = [{"id": self.agent_id1, "timestamp": valid_data.VALID_LAST_TIMESTAMP},
               {"id": self.agent_id2, "timestamp": valid_data.VALID_LAST_TIMESTAMP}]
    version = 1
    decision_trees = self.client.get_decision_trees_bulk(payload, version)

    self.assertNotEqual(decision_trees[0].get("tree").get("_version"), None)
    tree_version = semver.parse(decision_trees[0].get("tree").get("_version"))
    self.assertEqual(tree_version["major"], version)
    self.assertNotEqual(decision_trees[1].get("tree").get("_version"), None)
    tree_version = semver.parse(decision_trees[1].get("tree").get("_version"))
    self.assertEqual(tree_version["major"], version)

    self.addCleanup(self.clean_up_agents,
                    [self.agent_id1, self.agent_id2])

def test_should_raise_value_error_for_zero_prefixed_versions():
    with pytest.raises(ValueError):
        parse("01.2.3")
    with pytest.raises(ValueError):
        parse("1.02.3")
    with pytest.raises(ValueError):
        parse("1.2.03")

    def get_latest_release(self):
        response = requests.get(self.releases_url)
        releases = response.json()

        latest_version = None
        for r in releases:
            if r["prerelease"] and not self.include_prereleases:
                continue
            version = r["tag_name"]
            # some tag was create with 'v' letter, we should remove it (ex. v0.0.3-alpha -> 0.0.3-alpha)
            if version[0] == "v":
                version = version[1:]

            # latest version of semver can't parse 0 per-release version (ex: 1.0.0-rc.0)
            try:
                semver.parse(version)
            except ValueError:
                continue

            if latest_version is None or semver.compare(version, latest_version) > 0:
                latest_version = version
        return latest_version

def test_get_decision_tree_with_specific_version():
  version = 1
  decision_tree = CLIENT.get_decision_tree(
    AGENT_ID,
    valid_data.VALID_TIMESTAMP,
    version)

  assert_is_instance(decision_tree, dict)
  assert_not_equal(decision_tree.get("_version"), None)
  tree_version = semver.parse(decision_tree.get("_version"))
  assert_equal(tree_version["major"], version)
  assert_not_equal(decision_tree.get("configuration"), None)
  assert_not_equal(decision_tree.get("trees"), None)

 def _list_source_contents(cls, source):
     if source.endswith('.yaml'):
         # single CR
         pth = os.path.split(source)[-1][:-5]
         return ((RES_TYPE.Composer, pth, source), )
     elif os.path.isdir(source):
         meta_path = os.path.join(source, 'meta.yaml')
         if os.path.exists(meta_path):
             # single normal
             pth = os.path.split(source)[-1]
             try:
                 semver.parse(pth)
             except ValueError:
                 name = pth
             else:
                 # if it was semver then single_path may look like
                 # /a/b/name/version
                 # and source may look like /a/b/name
                 # we can extract name from this path then
                 name = source.split(os.path.sep)[-2]
             return ((RES_TYPE.Normal, name, source), )
         return tuple(cls._list_source_contents_from_multidir(source))

def get_tags(image):
    php_version = semver.parse(image[0])
    php_versions = []

    if php_version["major"] == 7:
        if php_version["minor"] == 0:
            php_versions.append("7")
    else:
        php_versions.append(str(php_version["major"]))

    php_versions.extend([minorize(image[0]), image[0]])

    for tag in php_versions:
        yield matrix_join((tag,) + image[1:], "-")

    def set(self, field, value):
        """
        Set any field of semver to `value`

        :rtype : Version
        :param field:type of field (one of Version.VALID_FIELDS)
        :param value:
        :return: :raise ValueError:
        """

        if field not in self.VALID_FIELDS:
            raise ValueError("Invalid field type: %s" % field)

        version = Version(self)
        setattr(version, field, value)

        # validation
        try:
            semver.parse(str(version))
        except ValueError as exc:
            raise InvalidVersionError("Invalid value for field %s: %s" % (field, value)) from exc

        return version

    def test_semantic_version(self):
        """ociVersion (string, required) MUST be in SemVer v2.0.0 format.

        The spec wording in the docstring summary is from [1,2].
        v0.5.0 used 'must' instead of 'MUST', but that was accidental
        [3].

        This test is not restricted to known versions, because we
        expect a semantic-versioned field to extend to all spec
        releases (otherwise what's the point of SemVer?).

        [1]: https://github.com/opencontainers/runtime-spec/blob/v1.0.0-rc1/config.md#specification-version
        [2]: https://github.com/opencontainers/runtime-spec/blob/v0.5.0/config.md#specification-version
        [3]: https://github.com/opencontainers/runtime-spec/pull/409
        """
        self.assertTrue(isinstance(util.VERSION, str), 'ociVersion is not a string')
        try:
            version = semver.parse(version=util.VERSION)
        except ValueError as error:
            raise self.failureException(str(error)) from error