def test__version__serialize__pvp_with_metadata() -> None:
style = Style.Pvp
assert Version("0.1.0").serialize(style=style) == "0.1.0"
assert Version("0.1.0").serialize(metadata=True, style=style) == "0.1.0"
assert Version("0.1.0").serialize(metadata=False, style=style) == "0.1.0"
assert Version("0.1.0", stage=("a", 1),
commit="abc").serialize(style=style) == "0.1.0-a-1"
assert (Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=True,
style=style) == "0.1.0-a-1-abc")
assert (Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=False,
style=style) == "0.1.0-a-1")
assert Version("0.1.0", distance=1,
commit="abc").serialize(style=style) == "0.1.0-post-1-abc"
assert (Version("0.1.0", distance=1,
commit="abc").serialize(metadata=True,
style=style) == "0.1.0-post-1-abc")
assert (Version("0.1.0", distance=1,
commit="abc").serialize(metadata=False,
style=style) == "0.1.0-post-1")
assert (Version("0.1.0", distance=1, commit="abc",
tagged_metadata="def").serialize(
style=style,
tagged_metadata=True) == "0.1.0-post-1-def-abc")
def test__version__serialize__semver_with_metadata() -> None:
style = Style.SemVer
assert Version("0.1.0").serialize(style=style) == "0.1.0"
assert Version("0.1.0").serialize(metadata=True, style=style) == "0.1.0"
assert Version("0.1.0").serialize(metadata=False, style=style) == "0.1.0"
assert Version("0.1.0", stage=("a", 1),
commit="abc").serialize(style=style) == "0.1.0-a.1"
assert (Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=True,
style=style) == "0.1.0-a.1+abc")
assert (Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=False,
style=style) == "0.1.0-a.1")
assert Version("0.1.0", distance=1,
commit="abc").serialize(style=style) == "0.1.0-post.1+abc"
assert (Version("0.1.0", distance=1,
commit="abc").serialize(metadata=True,
style=style) == "0.1.0-post.1+abc")
assert (Version("0.1.0", distance=1,
commit="abc").serialize(metadata=False,
style=style) == "0.1.0-post.1")
assert (Version("0.1.0", distance=1, commit="abc",
tagged_metadata="def").serialize(
style=style,
tagged_metadata=True) == "0.1.0-post.1+def.abc")
def test__version__from_git__with_mixed_tags(tmp_path) -> None:
vcs = tmp_path / "dunamai-git-mixed"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_git)
with chdir(vcs):
run("git init")
(vcs / "foo.txt").write_text("hi")
run("git add .")
run('git commit -m "Initial commit"')
run("git tag v0.1.0")
(vcs / "foo.txt").write_text("hi 2")
run("git add .")
avoid_identical_ref_timestamps()
run('git commit -m "Second"')
run('git tag v0.2.0 -m "Annotated"')
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
(vcs / "foo.txt").write_text("hi 3")
run("git add .")
avoid_identical_ref_timestamps()
run('git commit -m "Third"')
run("git tag v0.3.0")
assert from_vcs() == Version("0.3.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.3.0",
commit="abc",
dirty=False)
def test__version__serialize__format() -> None:
format = "{base},{stage},{revision},{distance},{commit},{dirty}"
assert Version("0.1.0").serialize(format=format) == "0.1.0,,,0,,clean"
assert (Version(
"1", stage=("a", 2), distance=3, commit="abc",
dirty=True).serialize(format=format) == "1,a,2,3,abc,dirty")
with pytest.raises(ValueError):
Version("0.1.0").serialize(format="v{base}", style=Style.Pep440)
def test__version__from_git__with_lightweight_tags(tmp_path) -> None:
vcs = tmp_path / "dunamai-git-lightweight"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_git)
with chdir(vcs):
run("git init")
(vcs / "foo.txt").write_text("hi")
run("git add .")
run('git commit -m "Initial commit"')
run("git tag v0.1.0")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from git") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "foo.txt").write_text("bye")
run("git add .")
avoid_identical_ref_timestamps()
run('git commit -m "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
(vcs / "foo.txt").write_text("again")
run("git add .")
avoid_identical_ref_timestamps()
run('git commit -m "Third"')
assert from_vcs() == Version("0.1.0",
distance=2,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=2,
commit="abc",
dirty=False)
run("git tag v0.2.0")
run("git tag v0.1.1 HEAD~1")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
run("git checkout v0.1.1")
assert from_vcs() == Version("0.1.1", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.1",
commit="abc",
dirty=False)
def _bump_version_per_config(version: Version, bump: bool) -> Version:
if not bump or version.distance == 0:
return version
version = copy.deepcopy(version)
if version.stage is None:
version.base = bump_version(version.base)
else:
if version.revision is None:
version.revision = 2
else:
version.revision += 1
return version
def _get_version(config: Mapping) -> Tuple[Version, str]:
vcs = Vcs(config["vcs"])
style = config["style"]
if style is not None:
style = Style(style)
version = Version.from_vcs(vcs, config["pattern"], config["latest-tag"],
config["subversion"]["tag-dir"])
if config["format-jinja"]:
base = version.base
revision = version.revision
if config["bump"]:
if version.stage is None:
base = bump_version(version.base)
else:
if version.revision is None:
revision = 2
else:
revision = version.revision + 1
default_context = {
"base": base,
"version": version,
"stage": version.stage,
"revision": revision,
"distance": version.distance,
"commit": version.commit,
"dirty": version.dirty,
"env": os.environ,
"bump_version": bump_version,
"tagged_metadata": version.tagged_metadata,
"serialize_pep440": serialize_pep440,
"serialize_pvp": serialize_pvp,
"serialize_semver": serialize_semver,
}
custom_context = {} # type: dict
for entry in config["format-jinja-imports"]:
if "module" in entry:
module = import_module(entry["module"])
if "item" in entry:
custom_context[entry["item"]] = getattr(
module, entry["item"])
else:
custom_context[entry["module"]] = module
serialized = jinja2.Template(
config["format-jinja"]).render(**default_context, **custom_context)
if style is not None:
check_version(serialized, style)
else:
serialized = version.serialize(
metadata=config["metadata"],
dirty=config["dirty"],
format=config["format"],
style=style,
bump=config["bump"],
tagged_metadata=config["tagged-metadata"],
)
return (version, serialized)
def from_vcs(
vcs: Vcs,
pattern: str,
metadata: Optional[bool],
dirty: bool,
format: Optional[str],
style: Optional[Style],
latest_tag: bool,
tag_dir: str,
debug: bool,
bump: bool,
tagged_metadata: bool,
) -> None:
version = Version.from_vcs(vcs, pattern, latest_tag, tag_dir)
print(
version.serialize(metadata,
dirty,
format,
style,
bump,
tagged_metadata=tagged_metadata))
if debug:
print("# Matched tag: {}".format(version._matched_tag),
file=sys.stderr)
print("# Newer unmatched tags: {}".format(
version._newer_unmatched_tags),
file=sys.stderr)
def version() -> None:
"""Shows the version of the project."""
try:
v = Version.from_git().serialize(style=Style.SemVer)
except RuntimeError:
v = __version__
print("pynfogen", v)
def test__version__from_git__with_nonchronological_commits(tmp_path) -> None:
vcs = tmp_path / "dunamai-git-nonchronological"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_git)
with chdir(vcs):
run("git init")
(vcs / "foo.txt").write_text("hi")
run("git add .")
run(
'git commit -m "Initial commit"',
env={
"GIT_COMMITTER_DATE": "2000-01-02T01:00:00",
"GIT_AUTHOR_DATE": "2000-01-02T01:00:00",
**os.environ,
},
)
run("git tag v0.1.0")
(vcs / "foo.txt").write_text("hi 2")
run("git add .")
avoid_identical_ref_timestamps()
run(
'git commit -m "Second"',
env={
"GIT_COMMITTER_DATE": "2000-01-01T01:00:00",
"GIT_AUTHOR_DATE": "2000-01-01T01:00:00",
**os.environ,
},
)
run("git tag v0.2.0")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
def test__version__init() -> None:
v = Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True)
assert v.base == "1"
assert v.stage == "a"
assert v.revision == 2
assert v.distance == 3
assert v.commit == "abc"
assert v.dirty
def test__version__repr() -> None:
v = Version("1",
stage=("a", 2),
distance=3,
commit="abc",
dirty=True,
tagged_metadata="tagged")
assert repr(v) == ("Version(base='1', stage='a', revision=2, distance=3,"
" commit='abc', dirty=True, tagged_metadata='tagged')")
def from_vcs(
vcs: Vcs,
pattern: str,
metadata: Optional[bool],
dirty: bool,
format: Optional[str],
style: Optional[Style],
latest_tag: bool,
tag_dir: str,
) -> None:
version = Version.from_vcs(vcs, pattern, latest_tag, tag_dir)
print(version.serialize(metadata, dirty, format, style))
def test__version__serialize__pep440_with_dirty() -> None:
assert Version("0.1.0", dirty=True).serialize() == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(dirty=True) == "0.1.0+dirty"
assert Version("0.1.0", dirty=False).serialize() == "0.1.0"
assert Version("0.1.0", dirty=False).serialize(dirty=True) == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(metadata=True) == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(metadata=True,
dirty=True) == "0.1.0+dirty"
assert Version("0.1.0", dirty=True).serialize(metadata=False) == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(metadata=False,
dirty=True) == "0.1.0"
def test__version__serialize__pep440_metadata() -> None:
assert Version("0.1.0").serialize() == "0.1.0"
assert Version("0.1.0").serialize(metadata=True) == "0.1.0"
assert Version("0.1.0").serialize(metadata=False) == "0.1.0"
assert Version("0.1.0", stage=("a", 1),
commit="abc").serialize() == "0.1.0a1"
assert Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=True) == "0.1.0a1+abc"
assert Version("0.1.0", stage=("a", 1),
commit="abc").serialize(metadata=False) == "0.1.0a1"
assert Version("0.1.0", distance=1,
commit="abc").serialize() == "0.1.0.post1.dev0+abc"
assert (Version(
"0.1.0", distance=1,
commit="abc").serialize(metadata=True) == "0.1.0.post1.dev0+abc")
assert (Version(
"0.1.0", distance=1,
commit="abc").serialize(metadata=False) == "0.1.0.post1.dev0")
def test__check_version__semver() -> None:
style = Style.SemVer
check_version("0.1.0", style=style)
check_version("0.1.0-alpha.1", style=style)
check_version("0.1.0+abc", style=style)
check_version("0.1.0+a.b.c", style=style)
check_version("0.1.0-alpha.1.beta.2+abc.dirty", style=style)
with pytest.raises(ValueError):
check_version("1", style=style)
with pytest.raises(ValueError):
check_version("0.1", style=style)
with pytest.raises(ValueError):
check_version("0.0.0.1", style=style)
# "-" is a valid identifier.
Version("0.1.0--").serialize(style=style)
Version("0.1.0--.-").serialize(style=style)
# No leading zeroes in numeric segments:
with pytest.raises(ValueError):
Version("00.0.0").serialize(style=style)
with pytest.raises(ValueError):
Version("0.01.0").serialize(style=style)
with pytest.raises(ValueError):
Version("0.1.0-alpha.02").serialize(style=style)
# But leading zeroes are fine for non-numeric parts:
Version("0.1.0-alpha.02a").serialize(style=style)
# Identifiers can't be empty:
with pytest.raises(ValueError):
Version("0.1.0-.").serialize(style=style)
with pytest.raises(ValueError):
Version("0.1.0-a.").serialize(style=style)
with pytest.raises(ValueError):
Version("0.1.0-.a").serialize(style=style)
def test__version__serialize__pvp_with_dirty() -> None:
style = Style.Pvp
assert Version("0.1.0", dirty=True).serialize(style=style) == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(dirty=True,
style=style) == "0.1.0-dirty"
assert Version("0.1.0", dirty=False).serialize(style=style) == "0.1.0"
assert Version("0.1.0", dirty=False).serialize(dirty=True,
style=style) == "0.1.0"
assert Version("0.1.0", dirty=True).serialize(metadata=True,
style=style) == "0.1.0"
assert (Version("0.1.0",
dirty=True).serialize(metadata=True,
dirty=True,
style=style) == "0.1.0-dirty")
assert Version("0.1.0", dirty=True).serialize(metadata=False,
style=style) == "0.1.0"
assert (Version("0.1.0", dirty=True).serialize(metadata=False,
dirty=True,
style=style) == "0.1.0")
def _get_version(config: Mapping, pyproject_path: Path) -> Tuple[Version, str]:
if _state.version:
return _state.version
pyproject = tomlkit.parse(pyproject_path.read_text(encoding='utf8'))
if not _state.original_version:
_state.original_version = pyproject["tool"]["poetry"]["version"]
vcs = Vcs(config["vcs"])
style = config["style"]
if style is not None:
style = Style(style)
version = Version.from_vcs(vcs, config["pattern"], config["latest-tag"],
config["subversion"]["tag-dir"])
if config["format-jinja"]:
serialized = jinja2.Template(config["format-jinja"]).render(
base=version.base,
stage=version.stage,
revision=version.revision,
distance=version.distance,
commit=version.commit,
dirty=version.dirty,
env=os.environ,
bump_version=bump_version,
serialize_pep440=serialize_pep440,
serialize_pvp=serialize_pvp,
serialize_semver=serialize_semver,
)
if style is not None:
check_version(serialized, style)
else:
serialized = version.serialize(config["metadata"], config["dirty"],
config["format"], style)
pyproject["tool"]["poetry"]["version"] = serialized
pyproject_path.write_text(tomlkit.dumps(pyproject))
_state.version = (version, serialized)
return (version, serialized)
def _get_version(config: Mapping, pyproject_path: Path) -> Tuple[Version, str]:
if _state.version:
return _state.version
pyproject = tomlkit.parse(pyproject_path.read_text())
if not _state.original_version:
_state.original_version = pyproject["tool"]["poetry"]["version"]
vcs = Vcs(config["vcs"])
style = config["style"]
if style is not None:
style = Style(style)
version = Version.from_vcs(vcs, config["pattern"], config["latest-tag"],
config["subversion"]["tag-dir"])
serialized = version.serialize(config["metadata"], config["dirty"],
config["format"], style)
pyproject["tool"]["poetry"]["version"] = serialized
pyproject_path.write_text(tomlkit.dumps(pyproject))
_state.version = (version, serialized)
return (version, serialized)
def test_git(temp_tree: TempTreeCB, has_src, with_v, version):
src_path = Path("git_mod.py")
content: Desc = {src_path: "print('hello')\n"}
if has_src:
src_path = Path("src") / src_path
content = dict(src=content)
with temp_tree(content) as package:
with get_version.working_dir(package):
def add_and_commit(msg: str):
run(f"git add {src_path}".split(), check=True)
run([*"git commit -m".split(), msg], check=True)
run("git init".split(), check=True)
add_and_commit("initial")
run(f"git tag {'v' if with_v else ''}{version}".split(),
check=True)
src_path.write_text("print('modified')")
add_and_commit("modified")
hash = run(
"git rev-parse --short HEAD".split(),
capture_output=True,
encoding="ascii",
).stdout.strip()
src_path.write_text("print('dirty')")
v = get_version.dunamai_get_from_vcs(package)
assert (Version(
version.base,
stage=(version.stage, version.revision),
distance=1,
commit=hash,
dirty=True,
) == v)
parent = (package / "src") if has_src else package
v_str = get_version.get_version(parent / "git_mod.py")
assert f"{version}.post1.dev0+{hash}.dirty" == v_str
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
# -- Project information -----------------------------------------------------
project = 'pydvdcss'
copyright = '2021, PHOENiX'
author = 'PHOENiX'
# The full version, including alpha/beta/rc tags
version = Version.from_git().base
release = version
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ['sphinx.ext.autosectionlabel', 'sphinx.ext.autodoc']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
def test__version__from_fossil(tmp_path) -> None:
vcs = tmp_path / "dunamai-fossil"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_fossil)
with chdir(vcs):
run("fossil init repo")
run("fossil open repo")
assert from_vcs() == Version("0.0.0",
distance=0,
commit="abc",
dirty=False)
(vcs / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit="abc",
dirty=True)
run("fossil add .")
run('fossil commit -m "Initial commit"')
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=False)
run("fossil tag add v0.1.0 trunk")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from fossil") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=True)
run("fossil add .")
run('fossil commit -m "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
run("fossil tag add unmatched trunk")
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
(vcs / "foo.txt").write_text("third")
run("fossil add .")
run("fossil commit --tag v0.2.0 -m 'Third'")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
run("fossil tag add v0.1.1 v0.1.0")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
run("fossil checkout v0.1.0")
assert from_vcs() == Version("0.1.1", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.1",
commit="abc",
dirty=False)
import os
from typing import Optional
from dunamai import Version, bump_version, serialize_pep440
if "CI_MERGE_REQUEST_IID" in os.environ:
mr_version: Optional[str] = os.environ["CI_MERGE_REQUEST_IID"]
else:
mr_version = None
build_official = "BUILD_OFFICIAL" in os.environ
v = Version.from_git(pattern=r"^(?P<base>\d+\.\d+\.\d+)$")
if v.distance == 0:
out = serialize_pep440(v.base, v.stage, v.revision)
else:
if build_official:
out = serialize_pep440(bump_version(v.base),
None,
None,
dev=v.distance)
elif mr_version is not None:
out = serialize_pep440(bump_version(v.base),
None,
None,
dev=v.distance,
metadata=[f"mr{mr_version}"])
else:
out = serialize_pep440(bump_version(v.base),
None,
None,
def test__version__from_git__with_annotated_tags(tmp_path) -> None:
vcs = tmp_path / "dunamai-git-annotated"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_git)
with chdir(vcs):
run("git init")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
(vcs / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
run("git add .")
run('git commit -m "Initial commit"')
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=False)
# Detect dirty if untracked files
(vcs / "bar.txt").write_text("bye")
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=True)
# Once the untracked file is removed we are no longer dirty
(vcs / "bar.txt").unlink()
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=False)
# Additional one-off check not in other VCS integration tests:
# when the only tag in the repository does not match the pattern.
run("git tag other -m Annotated")
with pytest.raises(ValueError):
from_vcs()
avoid_identical_ref_timestamps()
run("git tag v0.1.0 -m Annotated")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from git") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
# Additional one-off checks not in other VCS integration tests:
assert run(
r'dunamai from any --pattern "(?P<base>\d\.\d\.\d)"') == "0.1.0"
run(r'dunamai from any --pattern "(\d\.\d\.\d)"', 1)
assert run('dunamai from any --format "v{base}"') == "v0.1.0"
assert run('dunamai from any --style "semver"') == "0.1.0"
assert (
run('dunamai from any --format "v{base}" --style "semver"', 1) ==
"Version 'v0.1.0' does not conform to the Semantic Versioning style"
)
assert run("dunamai from any --latest-tag") == "0.1.0"
assert from_explicit_vcs(Vcs.Any) == Version("0.1.0",
commit="abc",
dirty=False)
assert from_explicit_vcs(Vcs.Git) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from any --bump") == "0.1.1"
(vcs / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=True)
run("git add .")
run('git commit -m "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
run("git tag unmatched -m Annotated")
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
avoid_identical_ref_timestamps()
run("git tag v0.2.0 -m Annotated")
avoid_identical_ref_timestamps()
run("git tag v0.1.1 HEAD~1 -m Annotated")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
# Check handling with identical tag and branch names:
run("git checkout -b v0.2.0")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
run("git checkout v0.1.0")
assert from_vcs() == Version("0.1.1", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.1",
commit="abc",
dirty=False)
# Additional one-off check not in other VCS integration tests:
# tag with pre-release segment.
run("git checkout master")
(vcs / "foo.txt").write_text("third")
run("git add .")
run('git commit -m "Third"')
run("git tag v0.2.1b3 -m Annotated")
assert from_vcs() == Version("0.2.1",
stage=("b", 3),
commit="abc",
dirty=False)
def test__version__from_bazaar(tmp_path) -> None:
vcs = tmp_path / "dunamai-bzr"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_bazaar, mock_commit=None)
with chdir(vcs):
run("bzr init")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=False)
(vcs / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
run("bzr add .")
run('bzr commit -m "Initial commit"')
assert from_vcs() == Version("0.0.0",
distance=1,
commit="1",
dirty=False)
run("bzr tag v0.1.0")
assert from_vcs() == Version("0.1.0", commit="1", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="1",
dirty=False)
assert run("dunamai from bazaar") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="1", dirty=True)
run("bzr add .")
run('bzr commit -m "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="2",
dirty=False)
assert from_any_vcs_unmocked() == Version("0.1.0",
distance=1,
commit="2",
dirty=False)
run("bzr tag unmatched")
assert from_vcs() == Version("0.1.0",
distance=1,
commit="2",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
run("bzr tag v0.2.0")
run("bzr tag v0.1.1 -r v0.1.0")
assert from_vcs() == Version("0.2.0", commit="2", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="2",
dirty=False)
run("bzr checkout . old -r v0.1.0")
with chdir(vcs / "old"):
assert from_vcs() == Version("0.1.1", commit="1", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.1",
commit="1",
dirty=False)
def test__version__from_subversion(tmp_path) -> None:
vcs = tmp_path / "dunamai-svn"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_subversion, mock_commit=None)
vcs_srv = tmp_path / "dunamai-svn-srv"
vcs_srv.mkdir()
run_srv = make_run_callback(vcs_srv)
vcs_srv_uri = vcs_srv.as_uri()
with chdir(vcs_srv):
run_srv("svnadmin create .")
with chdir(vcs):
run('svn checkout "{}" .'.format(vcs_srv_uri))
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=False)
run("svn mkdir trunk tags")
(vcs / "trunk" / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
run("svn add --force .")
run('svn commit -m "Initial commit"') # commit 1
run("svn update")
assert from_vcs() == Version("0.0.0",
distance=1,
commit="1",
dirty=False)
run('svn copy {0}/trunk {0}/tags/v0.1.0 -m "Tag 1"'.format(
vcs_srv_uri)) # commit 2
run("svn update")
assert from_vcs() == Version("0.1.0", commit="2", dirty=False)
assert run("dunamai from subversion") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "trunk" / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="2", dirty=True)
run('svn commit -m "Second"') # commit 3
run("svn update")
assert from_vcs() == Version("0.1.0",
distance=1,
commit="3",
dirty=False)
assert from_any_vcs_unmocked() == Version("0.1.0",
distance=1,
commit="3",
dirty=False)
# Ensure we get the tag based on the highest commit, not necessarily
# just the newest tag.
run('svn copy {0}/trunk {0}/tags/v0.2.0 -m "Tag 2"'.format(
vcs_srv_uri)) # commit 4
run('svn copy {0}/trunk {0}/tags/v0.1.1 -r 1 -m "Tag 3"'.format(
vcs_srv_uri)) # commit 5
run("svn update")
assert from_vcs() == Version("0.2.0",
distance=1,
commit="5",
dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
distance=1,
commit="5",
dirty=False)
run('svn copy {0}/trunk {0}/tags/unmatched -m "Tag 4"'.format(
vcs_srv_uri)) # commit 6
run("svn update")
assert from_vcs() == Version("0.2.0",
distance=2,
commit="6",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
run("svn update -r 2")
assert from_vcs() == Version("0.1.0", commit="2", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="2",
dirty=False)
def test__version__from_darcs(tmp_path) -> None:
vcs = tmp_path / "dunamai-darcs"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_darcs)
with chdir(vcs):
run("darcs init")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=False)
(vcs / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
run("darcs add foo.txt")
run('darcs record -am "Initial commit"')
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=False)
run("darcs tag v0.1.0")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from darcs") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=True)
run('darcs record -am "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
run("darcs tag unmatched")
assert from_vcs() == Version("0.1.0",
distance=2,
commit="abc",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
run("darcs tag v0.2.0")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
run("darcs obliterate --all --last 3")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
def test__version__from_mercurial(tmp_path) -> None:
vcs = tmp_path / "dunamai-hg"
vcs.mkdir()
run = make_run_callback(vcs)
from_vcs = make_from_callback(Version.from_mercurial)
with chdir(vcs):
run("hg init")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=False)
(vcs / "foo.txt").write_text("hi")
assert from_vcs() == Version("0.0.0",
distance=0,
commit=None,
dirty=True)
run("hg add .")
run('hg commit -m "Initial commit"')
assert from_vcs() == Version("0.0.0",
distance=1,
commit="abc",
dirty=False)
run("hg tag v0.1.0")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
assert run("dunamai from mercurial") == "0.1.0"
assert run("dunamai from any") == "0.1.0"
(vcs / "foo.txt").write_text("bye")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=True)
run("hg add .")
run('hg commit -m "Second"')
assert from_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
assert from_any_vcs() == Version("0.1.0",
distance=1,
commit="abc",
dirty=False)
run("hg tag unmatched")
assert from_vcs() == Version("0.1.0",
distance=2,
commit="abc",
dirty=False)
with pytest.raises(ValueError):
from_vcs(latest_tag=True)
run("hg tag v0.2.0")
assert from_vcs() == Version("0.2.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
commit="abc",
dirty=False)
run('hg tag v0.1.1 -r "tag(v0.1.0)"')
assert from_vcs() == Version("0.2.0",
distance=1,
commit="abc",
dirty=False)
assert from_vcs(latest_tag=True) == Version("0.2.0",
distance=1,
commit="abc",
dirty=False)
run("hg checkout v0.1.0")
assert from_vcs() == Version("0.1.0", commit="abc", dirty=False)
assert from_vcs(latest_tag=True) == Version("0.1.0",
commit="abc",
dirty=False)
import pathlib
import setuptools
try:
try:
from dunamai import Version
except ImportError:
import sys
import subprocess
subprocess.check_call(
[sys.executable, '-m', 'pip', 'install', 'dunamai'])
from dunamai import Version
version = Version.from_any_vcs().serialize()
except RuntimeError as error:
logging.exception(error)
version = '0.0.0'
logging.info(f'using version {version}')
metadata = setuptools.config.read_configuration(
pathlib.Path(__file__).parent.absolute() / 'setup.cfg')['metadata']
setuptools.setup(
name=metadata['name'],
version=version,
author=metadata['author'],
author_email=metadata['author_email'],
description=metadata['description'],
else:
return repository_root(path.parent)
sys.path.insert(0, str(repository_root()))
# -- Project information -----------------------------------------------------
metadata = config.read_configuration('../../setup.cfg')['metadata']
project = metadata['name']
author = metadata['author']
copyright = f'2021, Office of Coast Survey (OCS), National Oceanic and Atmospheric Administration (NOAA)'
# The full version, including alpha/beta/rc tags
try:
release = Version.from_any_vcs().serialize()
except RuntimeError:
release = os.environ.get('VERSION')
# -- General configuration ---------------------------------------------------
autoclass_content = 'both' # include both class docstring and __init__
autodoc_default_options = {
# Make sure that any autodoc declarations show the right members
'members': True,
'inherited-members': True,
'private-members': True,
'member-order': 'bysource',
'exclude-members': '__weakref__',
}
autosummary_generate = True # Make _autosummary files and include them
